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
