Removing Basic Auth support, removing stupid module globals in favor of proper configuration, bumping version accordingly.

Author: joshmarshall

requirements.txt

@@ -1,4 +1,6 @@
 argparse==1.2.1
+httplib2==0.7.4
 nose==1.1.2
+oauth2==1.5.211
 tornado==2.3
 wsgiref==0.1.2

setup.py

@@ -17,7 +17,7 @@
 
 setup(
     name='tweetstream',
-    version='0.1.2',
+    version='0.2.0',
     description='Simple Twitter Streaming client for Tornado ',
     author='Josh Marshall',
     author_email='catchjosh@gmail.com',

tests.py

@@ -1,41 +1,69 @@
 from tornado.testing import AsyncTestCase
 import tweetstream
 import logging
+import os
+import time
 
-try:
-    import test_settings
-except ImportError:
-    test_settings = None
+TEST_CONSUMER_KEY = os.environ.get("TWEETSTREAM_TEST_CONSUMER_KEY")
+TEST_CONSUMER_SECRET = os.environ.get("TWEETSTREAM_TEST_CONSUMER_SECRET")
+TEST_ACCESS_TOKEN = os.environ.get("TWEETSTREAM_TEST_ACCESS_TOKEN")
+TEST_ACCESS_SECRET = os.environ.get("TWEETSTREAM_TEST_ACCESS_TOKEN_SECRET")
 
+def test_real_config():
+    configuration = {
+        "twitter_consumer_secret": TEST_CONSUMER_SECRET,
+        "twitter_consumer_key": TEST_CONSUMER_KEY,
+        "twitter_access_token_secret": TEST_ACCESS_SECRET,
+        "twitter_access_token": TEST_ACCESS_TOKEN
+    }
+    if None in configuration.values():
+        logging.debug("Missing one or more test configuration values.")
+        return None
+    return configuration
 
 class TestTweetStream(AsyncTestCase):
 
-    def setUp(self):
-        super(TestTweetStream, self).setUp()
-        self.original_app_password = tweetstream.TWITTER_APP_PASSWORD
-        tweetstream.TWITTER_APP_PASSWORD = "foobar"
-
-    def tearDown(self):
-        super(TestTweetStream, self).tearDown()
-        tweetstream.TWITTER_APP_PASSWORD = self.original_app_password
-
     def test_twitter_stream(self):
         """ Test that the twitter stream is started with module defaults """
         result = {}
         def error_callback(error):
             result["error"] = error
+            print error
             self.stop()
-        stream = tweetstream.TweetStream(ioloop=self.io_loop)
-        stream.error_callback = error_callback
-        stream.fetch("foobar?whats=up")
+
+        configuration = {
+            "twitter_consumer_secret": "ABCDEF1234567890",
+            "twitter_consumer_key": "0987654321ABCDEF",
+            "twitter_access_token_secret": "1234567890ABCDEF",
+            "twitter_access_token": "FEDCBA09123456789",
+        }
+        stream = tweetstream.TweetStream(configuration, ioloop=self.io_loop)
+        stream.set_error_callback(error_callback)
+        stream.fetch("/1/statuses/sample.json")
         self.wait()
         self.assertTrue("error" in result)
 
+    def test_twitter_stream_bad_configuration(self):
+        """Test the configuration missing values."""
+        configuration = {
+            "twitter_consumer_secret": "ABCDEF1234567890",
+            "twitter_consumer_key": "0987654321ABCDEF",
+            "twitter_access_token_secret": "1234567890ABCDEF",
+            "twitter_access_token": "FEDCBA09123456789"
+        }
+        for key in configuration:
+            bad_config = configuration.copy()
+            del bad_config[key]
+            self.assertRaises(tweetstream.MissingConfiguration,
+                lambda: tweetstream.TweetStream(bad_config))
+
     def test_twitter_stream_with_configuration(self):
         """Test that the twitter stream supports instance configuration."""
         configuration = {
-            "twitter_app_username": "newusername",
-            "twitter_app_password": "newpassword",
+            "twitter_consumer_secret": "ABCDEF1234567890",
+            "twitter_consumer_key": "0987654321ABCDEF",
+            "twitter_access_token_secret": "1234567890ABCDEF",
+            "twitter_access_token": "FEDCBA09123456789",
             "twitter_stream_host": "whatever.com",
             "twitter_stream_port": 556,
             "twitter_stream_scheme": "http"
@@ -44,48 +72,42 @@ def test_twitter_stream_with_configuration(self):
             configuration=configuration)
         # this is evil, but until module stuff is removed and
         # proper configuration is refactored it will have to do.
-        self.assertEqual("newusername", stream._twitter_app_user)
-        self.assertEqual("newpassword", stream._twitter_app_password)
-        self.assertEqual("whatever.com", stream._twitter_stream_host)
         self.assertEqual(556, stream._twitter_stream_port)
         self.assertEqual("http", stream._twitter_stream_scheme)
 
 
 class TestActualTwitterCalls(AsyncTestCase):
     """ Testing actual calls, assuming settings are loaded. """
 
-    def setUp(self):
-        super(TestActualTwitterCalls, self).setUp()
-        self.original_app_user = tweetstream.TWITTER_APP_USER
-        self.original_app_password = tweetstream.TWITTER_APP_PASSWORD
-        if test_settings:
-            tweetstream.TWITTER_APP_USER = \
-                    test_settings.TWITTER_APP_USER
-            tweetstream.TWITTER_APP_PASSWORD = \
-                    test_settings.TWITTER_APP_PASSWORD
-
-    def tearDown(self):
-        super(TestActualTwitterCalls, self).tearDown()
-        tweetstream.TWITTER_APP_USER = self.original_app_user
-        tweetstream.TWITTER_APP_PASSWORD = self.original_app_password
-
     def get_message(self, path, clean=False):
         """ Wraps the ioloop start much like self.fetch """
-        stream = tweetstream.TweetStream(ioloop=self.io_loop, clean=clean)
+        def error_callback(error):
+            self.io_loop.stop()
+            self.fail(str(error))
+
+        stream = tweetstream.TweetStream(
+            configuration=test_real_config(),
+            ioloop=self.io_loop, clean=clean)
+        stream.set_error_callback(error_callback)
         result = {}
         def callback(message):
             """ Save result """
-            result["message"] = message
-            self.stop()
+            if message.get("text"):
+                result["message"] = message
+                self.stop()
+            # otherwise, it's not a tweet we care about...
+
         stream.fetch(path, callback=callback)
         self.wait()
         # will block until a message comes in or timeout
+        # now waiting to keep from hammering the stream connections
+        time.sleep(5)
         return result["message"]
 
     def test_message(self):
         """ Test that twitter connects. """
         #... if only everyone used 2.7 ...
-        if not test_settings:
+        if not test_real_config():
             logging.debug("Skipping test.")
             return
         result = self.get_message("/1/statuses/sample.json")
@@ -94,7 +116,7 @@ def test_message(self):
 
     def test_stripped_message(self):
         """ Test that twitter connects and retrieves simple message. """
-        if not test_settings:
+        if not test_real_config():
             logging.debug("Skipping test")
             return
         result = self.get_message("/1/statuses/sample.json", clean=True)
@@ -103,3 +125,12 @@ def test_stripped_message(self):
         self.assertTrue("text" in result)
         self.assertTrue(result["type"] == "tweet")
 
+    def test_search_term(self):
+        """Test the statuses with a search term."""
+        if not test_real_config():
+            logging.debug("Skipping test")
+            return
+        result = self.get_message("/1/statuses/filter.json?track=twitter")
+        self.assertTrue("user" in result)
+        self.assertTrue("text" in result)
+