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"
def do_test(klass, *args): with test_server(handler=tweetsource, methods=("post", "get"), port="random") as server: stream = klass("foo", "bar", *args, url=server.baseurl) for tweet in stream: if stream.count == total: break
def do_test(klass, *args): with test_server(handler=tweetsource, methods=("post", "get"), port="random") as server: stream = klass("foo", "bar", *args, url=server.baseurl, want_json=True) tweet = stream.next() assert isinstance(tweet, str) anyjson.deserialize(tweet)
def test_keepalive(cls, args, kwargs): """Make sure we behave sanely when there are keepalive newlines in the data recevived from twitter""" def tweetsource(): yield single_tweet yield "\r\n" yield "\r\n" yield single_tweet yield "\r\n" yield "\r\n" yield "\r\n" yield "\r\n" yield "\r\n" yield "\r\n" yield "\r\n" yield single_tweet yield "\r\n" with test_server(response=tweetsource) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) 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"
def test_reponse_code_exceptions(cls, args, kwargs, status_code, exception): """Test that the proper exception is raised when the given status code is recieved""" with raises(exception): with test_server(status=status_code) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) for e in stream: pass
def do_test(klass, *args): with test_server(handler=tweetsource, methods=("post", "get"), port="random") as server: stream = klass("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!"
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) with raises(ConnectionError): with test_server(handler=not_found, methods=("post", "get"), port="random") as server: stream = cls("user", "passwd", *args, url=server.baseurl) for e in stream: pass
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) with raises(AuthenticationError): with test_server(handler=auth_denied, methods=("post", "get"), port="random") as server: stream = cls("user", "passwd", *args, url=server.baseurl) for e in stream: pass
def test_bad_auth(cls, args, kwargs): """Test that the proper exception is raised when the user could not be authenticated""" status = 401 with raises(AuthenticationError): with test_server(status=status) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) for e in stream: pass
def do_test(klass, *args): with test_server(handler=tweetsource, methods=("post", "get"), port="random") as server: stream = klass("foo", "bar", *args, url=server.baseurl) try: for tweet in stream: pass except ConnectionError: assert stream.count == 3 else: assert False, "Didn't handle keepalive"
def test_404_url(cls, args, kwargs): """Test that the proper exception is raised when the stream URL can't be found""" status = 404 with raises(ConnectionError): with test_server(status=status) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) for e in stream: pass
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
def smoke_test_receive_tweets(cls, args, kwargs): """Receive 100k tweets and disconnect (slow)""" total = 100000 def tweetsource(): while True: yield single_tweet with test_server(response=tweetsource) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) for tweet in stream: if stream.count == total: break
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 yield "[1,2,3]\r" 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
def test_404_url(): """Test that the proper exception is raised when the stream URL can't be found""" def not_found(request): request.send_error(404) with test_server(handler=not_found, methods=("post", "get"), port="random") as server: stream = TweetStream("foo", "bar", url=server.baseurl) assert_raises(ConnectionError, stream.next) stream = FollowStream("foo", "bar", [1, 2, 3], url=server.baseurl) assert_raises(ConnectionError, stream.next) stream = TrackStream("foo", "bar", ["opera"], url=server.baseurl) assert_raises(ConnectionError, stream.next)
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 yield "[1,2,3]\r" yield "[1,2, I need no stinking close brace\r" yield "[1,2,3]\r" 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
def test_closed_connection(cls, args, kwargs): """Test error handling if server unexpectedly closes connection""" cnt = 1000 def bad_content(): for n in xrange(cnt): # what json we pass doesn't matter. It's not verifying the # strcuture, only checking that it's parsable yield "[1,2,3]\r\n" with raises(ConnectionError): with test_server(response=bad_content) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) for tweet in stream: pass
def test_bad_auth(): """Test that the proper exception is raised when the user could not be authenticated""" def auth_denied(request): request.send_error(401) with test_server(handler=auth_denied, methods=("post", "get"), port="random") as server: stream = TweetStream("foo", "bar", url=server.baseurl) assert_raises(AuthenticationError, stream.next) stream = FollowStream("foo", "bar", [1, 2, 3], url=server.baseurl) assert_raises(AuthenticationError, stream.next) stream = TrackStream("foo", "bar", ["opera"], url=server.baseurl) assert_raises(AuthenticationError, stream.next)
def test_bad_content(cls, args, kwargs): """Test error handling if we are given invalid data""" def bad_content(): for n in xrange(10): # what json we pass doesn't matter. It's not verifying the # strcuture, only checking that it's parsable yield "[1,2,3]\r\n" yield "[1,2, I need no stinking close brace\r\n" yield "[1,2,3]\r\n" with raises(ConnectionError): with test_server(response=bad_content) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) for tweet in stream: pass
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!"
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(): yield single_tweet 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 with test_server(response=tweetsource) as server: cls.url = server.baseurl stream = cls(*args, **kwargs) start = time.time() next(stream) first = time.time() diff = first - start assert diff < 1, "Getting first tweet took too long! %i > 1" % (diff)
def do_test(klass, *args): with test_server(handler=bad_content, methods=("post", "get"), port="random") as server: stream = klass("foo", "bar", *args, url=server.baseurl) for tweet in stream: pass