import contextlib

import threading

import time

from tweetstream import TweetStream, FollowStream, TrackStream, LocationStream

import pytest

from pytest import raises

slow = pytest.mark.slow

from servercontext import test_server

def parameterized(funcarglist):

    def wrapper(function):

        function.funcarglist = funcarglist

        return function

    return wrapper

def pytest_generate_tests(metafunc):

    for funcargs in getattr(metafunc.function, 'funcarglist', ()):

        metafunc.addcall(funcargs=funcargs)

streamtypes = [

    dict(cls=TweetStream, args=[], kwargs=dict()),

    dict(cls=SampleStream, args=[], kwargs=dict()),

    dict(cls=FollowStream, args=[[1, 2, 3]], kwargs=dict()),

    dict(cls=TrackStream, args=["opera"], kwargs=dict()),

    dict(cls=LocationStream, args=["123,4321"], kwargs=dict())

]

@parameterized(streamtypes)

def test_bad_auth(cls, args, kwargs):

    """Test that the proper exception is raised when the user could not be

    authenticated"""

    def auth_denied(request):

        request.send_error(401)

@parameterized(streamtypes)

def test_404_url(cls, args, kwargs):

    """Test that the proper exception is raised when the stream URL can't be

    found"""

    def not_found(request):

        request.send_error(404)

@parameterized(streamtypes)

def test_bad_content(cls, args, kwargs):

    """Test error handling if we are given invalid data"""

    def bad_content(request):

        for n in xrange(10):

            # what json we pass doesn't matter. It's not verifying the

            # strcuture, only checking that it's parsable

    with raises(ConnectionError):

        with test_server(handler=bad_content, methods=("post", "get"), port="random") as server:

            stream = cls("user", "passwd", *args, url=server.baseurl)

            for tweet in stream:

                pass

@parameterized(streamtypes)

def test_closed_connection(cls, args, kwargs):

    """Test error handling if server unexpectedly closes connection"""

    cnt = 1000

    def bad_content(request):

        for n in xrange(cnt):

            # what json we pass doesn't matter. It's not verifying the

            # strcuture, only checking that it's parsable

    with raises(ConnectionError):

        with test_server(handler=bad_content, methods=("post", "get"), port="random") as server:

            stream = cls("foo", "bar", *args, url=server.baseurl)

            for tweet in stream:

                pass

@parameterized(streamtypes)

def test_bad_host(cls, args, kwargs):

    """Test behaviour if we can't connect to the host"""

    with raises(ConnectionError):

        stream = cls("username", "passwd", *args, url="http://wedfwecfghhreewerewads.foo")

        stream.next()

@parameterized(streamtypes)

def smoke_test_receive_tweets(cls, args, kwargs):

    """Receive 100k tweets and disconnect (slow)"""

    total = 100000

    def tweetsource(request):

        while True:

            yield single_tweet + "\n"

    with test_server(handler=tweetsource, methods=("post", "get"), port="random") as server:

        stream = cls("foo", "bar", *args, url=server.baseurl)

        for tweet in stream:

            if stream.count == total:

                break

@parameterized(streamtypes)

def test_keepalive(cls, args, kwargs):

    """Make sure we behave sanely when there are keepalive newlines in the

    data recevived from twitter"""

    def tweetsource(request):

        yield single_tweet+"\n"

        yield "\n"

        yield "\n"

        yield single_tweet+"\n"

        yield "\n"

        yield "\n"

        yield "\n"

        yield "\n"

        yield "\n"

        yield "\n"

        yield "\n"

        yield single_tweet+"\n"

        yield "\n"

    with test_server(handler=tweetsource, methods=("post", "get"), port="random") as server:

        stream = cls("foo", "bar", *args, url=server.baseurl)

        try:

            for tweet in stream:

                pass

        except ConnectionError:

            assert stream.count == 3, "Got %s, wanted 3" % stream.count

        else:

            assert False, "Didn't handle keepalive"

@slow

@parameterized(streamtypes)

def test_buffering(cls, args, kwargs):

    """Test if buffering stops data from being returned immediately.

    If there is some buffering in play that might mean data is only returned

    from the generator when the buffer is full. If buffer is bigger than a

    tweet, this will happen. Default buffer size in the part of socket lib

    that enables readline is 8k. Max tweet length is around 3k."""

    def tweetsource(request):

        yield single_tweet+"\n"

        time.sleep(2)

        # need to yield a bunch here so we're sure we'll return from the

        # blocking call in case the buffering bug is present.

        for n in xrange(100):

            yield single_tweet+"\n"

    with test_server(handler=tweetsource, methods=("post", "get"), port="random") as server:

        stream = cls("foo", "bar", *args, url=server.baseurl)

        start = time.time()

        stream.next()

        first = time.time()

        diff = first - start

        assert diff < 1, "Getting first tweet took more than a second!"