moved relevant tests in to test_authentication_client.py

Author: Callum Oakley

pusher/authentication_client.py

@@ -10,10 +10,11 @@
     ensure_text,
     validate_channel,
     validate_socket_id,
-    data_to_string)
+    channel_name_re)
 
 from pusher.client import Client
 from pusher.http import GET, POST, Request, request_method
+from pusher.signature import sign, verify
 
 import collections
 import hashlib

pusher/pusher.py

@@ -8,13 +8,9 @@
 
 from pusher.util import (
     ensure_text,
-    validate_channel,
-    validate_socket_id,
     pusher_url_re,
-    channel_name_re,
     doc_string)
 
-from pusher.signature import sign, verify
 from pusher.pusher_client import PusherClient
 from pusher.notification_client import NotificationClient
 from pusher.authentication_client import AuthenticationClient

pusher_tests/test_authentication_client.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import print_function, absolute_import, division
+
+import os
+import six
+import hmac
+import json
+import hashlib
+import unittest
+import time
+from decimal import Decimal
+
+from pusher.authentication_client import AuthenticationClient
+from pusher.signature import sign, verify
+
+try:
+    import unittest.mock as mock
+except ImportError:
+    import mock
+
+
+class TestAuthenticationClient(unittest.TestCase):
+    def test_authenticate_for_private_channels(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        expected = {
+            u'auth': u"foo:89955e77e1b40e33df6d515a5ecbba86a01dc816a5b720da18a06fd26f7d92ff"
+        }
+
+        self.assertEqual(authenticationClient.authenticate(u'private-channel', u'345.23'), expected)
+
+
+    def test_authenticate_types(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        self.assertRaises(TypeError, lambda: authenticationClient.authenticate(2423, u'34554'))
+        self.assertRaises(TypeError, lambda: authenticationClient.authenticate(u'plah', 234234))
+        self.assertRaises(ValueError, lambda: authenticationClient.authenticate(u'::', u'345345'))
+
+
+    def test_authenticate_for_presence_channels(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        custom_data = {
+            u'user_id': u'fred',
+            u'user_info': {
+                u'key': u'value'
+            }
+        }
+
+        expected = {
+            u'auth': u"foo:e80ba6439492c2113022c39297a87a948de14061cc67b5788e045645a68b8ccd",
+            u'channel_data': u"{\"user_id\":\"fred\",\"user_info\":{\"key\":\"value\"}}"
+        }
+
+        with mock.patch('json.dumps', return_value=expected[u'channel_data']) as dumps_mock:
+            actual = authenticationClient.authenticate(u'presence-channel', u'345.43245', custom_data)
+
+        self.assertEqual(actual, expected)
+        dumps_mock.assert_called_once_with(custom_data, cls=None)
+
+
+    def test_validate_webhook_success_case(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        body = u'{"time_ms": 1000000}'
+        signature = six.text_type(hmac.new(authenticationClient.secret.encode('utf8'), body.encode('utf8'), hashlib.sha256).hexdigest())
+
+        with mock.patch('time.time', return_value=1200):
+            self.assertEqual(authenticationClient.validate_webhook(authenticationClient.key, signature, body), {u'time_ms': 1000000})
+
+
+    def test_validate_webhook_bad_types(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        authenticationClient.validate_webhook(u'key', u'signature', u'body')
+
+        # These things are meant to be human readable, so enforcing being
+        # text is sensible.
+
+        with mock.patch('time.time') as time_mock:
+            self.assertRaises(TypeError, lambda: authenticationClient.validate_webhook(4, u'signature', u'body'))
+            self.assertRaises(TypeError, lambda: authenticationClient.validate_webhook(u'key', 4, u'body'))
+            self.assertRaises(TypeError, lambda: authenticationClient.validate_webhook(u'key', u'signature', 4))
+
+        time_mock.assert_not_called()
+
+
+    def test_validate_webhook_bad_key(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        body = u'some body'
+        signature = six.text_type(hmac.new(authenticationClient.secret.encode(u'utf8'), body.encode(u'utf8'), hashlib.sha256).hexdigest())
+
+        with mock.patch('time.time') as time_mock:
+            self.assertEqual(authenticationClient.validate_webhook(u'badkey', signature, body), None)
+
+        time_mock.assert_not_called()
+
+
+    def test_validate_webhook_bad_signature(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        body = u'some body'
+        signature = u'some signature'
+
+        with mock.patch('time.time') as time_mock:
+            self.assertEqual(authenticationClient.validate_webhook(authenticationClient.key, signature, body), None)
+
+        time_mock.assert_not_called()
+
+
+    def test_validate_webhook_bad_time(self):
+        authenticationClient = AuthenticationClient(
+            key=u'foo', secret=u'bar', host=u'host', app_id=u'4', ssl=True)
+
+        body = u'{"time_ms": 1000000}'
+        signature = six.text_type(hmac.new(authenticationClient.secret.encode('utf8'), body.encode('utf8'), hashlib.sha256).hexdigest())
+
+        with mock.patch('time.time', return_value=1301):
+            self.assertEqual(authenticationClient.validate_webhook(authenticationClient.key, signature, body), None)
+
+
+if __name__ == '__main__':
+    unittest.main()

pusher_tests/test_client.py

@@ -16,6 +16,7 @@
 
 try:
     import unittest.mock as mock
+
 except ImportError:
     import mock
 
@@ -24,25 +25,36 @@ class TestClient(unittest.TestCase):
     def test_should_be_constructable(self):
         Client(app_id=u'4', key=u'key', secret=u'secret', ssl=False)
 
+
     def test_app_id_should_be_text_if_present(self):
-        self.assertRaises(TypeError, lambda: Client(app_id=4, key=u'key', secret=u'secret', ssl=False))
+        self.assertRaises(TypeError, lambda: Client(
+            app_id=4, key=u'key', secret=u'secret', ssl=False))
+
 
     def test_key_should_be_text_if_present(self):
-        self.assertRaises(TypeError, lambda: Client(app_id=u'4', key=4, secret=u'secret', ssl=False))
+        self.assertRaises(TypeError, lambda: Client(
+            app_id=u'4', key=4, secret=u'secret', ssl=False))
+
 
     def test_secret_should_be_text_if_present(self):
-        self.assertRaises(TypeError, lambda: Client(app_id=u'4', key=u'key', secret=4, ssl=False))
+        self.assertRaises(TypeError, lambda: Client(
+            app_id=u'4', key=u'key', secret=4, ssl=False))
+
 
     def test_ssl_should_be_boolean(self):
         Client(app_id=u'4', key=u'key', secret=u'secret', ssl=False)
         Client(app_id=u'4', key=u'key', secret=u'secret', ssl=True)
 
-        self.assertRaises(TypeError, lambda: Client(app_id=u'4', key=u'key', secret=u'secret', ssl=4))
+        self.assertRaises(TypeError, lambda: Client(
+            app_id=u'4', key=u'key', secret=u'secret', ssl=4))
+
 
     def test_port_should_be_number(self):
         Client(app_id=u'4', key=u'key', secret=u'secret', ssl=True, port=400)
 
-        self.assertRaises(TypeError, lambda: Client(app_id=u'4', key=u'key', secret=u'secret', ssl=True, port=u'400'))
+        self.assertRaises(TypeError, lambda: Client(
+            app_id=u'4', key=u'key', secret=u'secret', ssl=True, port=u'400'))
+
 
     def test_port_behaviour(self):
         conf = Client(app_id=u'4', key=u'key', secret=u'secret', ssl=True)
@@ -51,8 +63,11 @@ def test_port_behaviour(self):
         conf = Client(app_id=u'4', key=u'key', secret=u'secret', ssl=False)
         self.assertEqual(conf.port, 80, u'port should be 80 for non ssl')
 
-        conf = Client(app_id=u'4', key=u'key', secret=u'secret', ssl=False, port=4000)
-        self.assertEqual(conf.port, 4000, u'the port setting override the default')
+        conf = Client(
+            app_id=u'4', key=u'key', secret=u'secret', ssl=False, port=4000)
+
+        self.assertEqual(
+            conf.port, 4000, u'the port setting overrides the default')
 
 
 if __name__ == '__main__':

pusher_tests/test_pusher_client.py

@@ -13,7 +13,6 @@
 
 from pusher.pusher_client import PusherClient
 from pusher.http import GET
-from pusher.signature import sign
 
 try:
     import unittest.mock as mock
@@ -154,97 +153,6 @@ def test_user_info_success_case(self):
         self.assertEqual(request.path, u'/apps/4/channels/presence-channel/users')
         self.assertEqual(request.params, {})
 
-    def test_authenticate_for_private_channels(self):
-        pusher = Pusher.from_url(u'http://foo:bar@host/apps/4')
-
-        expected = {
-            u'auth': u"foo:89955e77e1b40e33df6d515a5ecbba86a01dc816a5b720da18a06fd26f7d92ff"
-        }
-
-        self.assertEqual(pusher.authenticate(u'private-channel', u'345.23'), expected)
-
-    def test_authenticate_types(self):
-        pusher = PusherClient.from_url(u'http://foo:bar@host/apps/4')
-
-        self.assertRaises(TypeError, lambda: pusher.authenticate(2423, u'34554'))
-        self.assertRaises(TypeError, lambda: pusher.authenticate(u'plah', 234234))
-        self.assertRaises(ValueError, lambda: pusher.authenticate(u'::', u'345345'))
-
-    def test_authenticate_for_presence_channels(self):
-        pusher = PusherClient.from_url(u'http://foo:bar@host/apps/4')
-
-        custom_data = {
-            u'user_id': u'fred',
-            u'user_info': {
-                u'key': u'value'
-            }
-        }
-
-        expected = {
-            u'auth': u"foo:e80ba6439492c2113022c39297a87a948de14061cc67b5788e045645a68b8ccd",
-            u'channel_data': u"{\"user_id\":\"fred\",\"user_info\":{\"key\":\"value\"}}"
-        }
-
-        with mock.patch('json.dumps', return_value=expected[u'channel_data']) as dumps_mock:
-            actual = pusher.authenticate(u'presence-channel', u'345.43245', custom_data)
-
-        self.assertEqual(actual, expected)
-        dumps_mock.assert_called_once_with(custom_data, cls=None)
-
-    def test_validate_webhook_success_case(self):
-        pusher = Pusher.from_url(u'http://foo:bar@host/apps/4')
-
-        body = u'{"time_ms": 1000000}'
-        signature = six.text_type(hmac.new(pusher.secret.encode('utf8'), body.encode('utf8'), hashlib.sha256).hexdigest())
-
-        with mock.patch('time.time', return_value=1200):
-            self.assertEqual(pusher.validate_webhook(pusher.key, signature, body), {u'time_ms': 1000000})
-
-    def test_validate_webhook_bad_types(self):
-        pusher = PusherClient.from_url(u'http://foo:bar@host/apps/4')
-
-        pusher.validate_webhook(u'key', u'signature', u'body')
-
-        # These things are meant to be human readable, so enforcing being text is
-        # sensible.
-
-        with mock.patch('time.time') as time_mock:
-            self.assertRaises(TypeError, lambda: pusher.validate_webhook(4, u'signature', u'body'))
-            self.assertRaises(TypeError, lambda: pusher.validate_webhook(u'key', 4, u'body'))
-            self.assertRaises(TypeError, lambda: pusher.validate_webhook(u'key', u'signature', 4))
-
-        time_mock.assert_not_called()
-
-    def test_validate_webhook_bad_key(self):
-        pusher = PusherClient.from_url(u'http://foo:bar@host/apps/4')
-
-        body = u'some body'
-        signature = six.text_type(hmac.new(pusher.secret.encode(u'utf8'), body.encode(u'utf8'), hashlib.sha256).hexdigest())
-
-        with mock.patch('time.time') as time_mock:
-            self.assertEqual(pusher.validate_webhook(u'badkey', signature, body), None)
-
-        time_mock.assert_not_called()
-
-    def test_validate_webhook_bad_signature(self):
-        pusher = PusherClient.from_url(u'http://foo:bar@host/apps/4')
-
-        body = u'some body'
-        signature = u'some signature'
-
-        with mock.patch('time.time') as time_mock:
-            self.assertEqual(pusher.validate_webhook(pusher.key, signature, body), None)
-
-        time_mock.assert_not_called()
-
-    def test_validate_webhook_bad_time(self):
-        pusher = PusherClient.from_url(u'http://foo:bar@host/apps/4')
-
-        body = u'{"time_ms": 1000000}'
-        signature = six.text_type(hmac.new(pusher.secret.encode('utf8'), body.encode('utf8'), hashlib.sha256).hexdigest())
-
-        with mock.patch('time.time', return_value=1301):
-            self.assertEqual(pusher.validate_webhook(pusher.key, signature, body), None)
 
 if __name__ == '__main__':
     unittest.main()