signalrcore 0.9.5__py3-none-any.whl → 0.9.6a2__py3-none-any.whl

test/base_test_case.py

@@ -3,17 +3,21 @@ import logging
 import time
 from signalrcore.hub_connection_builder import HubConnectionBuilder
 from signalrcore.protocol.messagepack_protocol import MessagePackHubProtocol
+
+
 class Urls:
     server_url_no_ssl = "ws://localhost:5000/chatHub"
     server_url_ssl = "wss://localhost:5001/chatHub"
     server_url_no_ssl_auth = "ws://localhost:5000/authHub"
     server_url_ssl_auth = "wss://localhost:5001/authHub"
-    login_url_ssl =  "https://localhost:5001/users/authenticate"
-    login_url_no_ssl =  "http://localhost:5000/users/authenticate"
+    login_url_ssl = "https://localhost:5001/users/authenticate"
+    login_url_no_ssl = "http://localhost:5000/users/authenticate"
+
 
 class InternalTestCase(unittest.TestCase):
     connection = None
     connected = False
+
     def get_connection(self):
         raise NotImplementedError()
 
@@ -35,12 +39,13 @@ class InternalTestCase(unittest.TestCase):
     def on_close(self):
         self.connected = False
 
+
 class BaseTestCase(InternalTestCase):
     server_url = Urls.server_url_ssl
 
     def get_connection(self, msgpack=False):
         builder = HubConnectionBuilder()\
-            .with_url(self.server_url, options={"verify_ssl":False})\
+            .with_url(self.server_url, options={"verify_ssl": False})\
             .configure_logging(logging.ERROR)\
             .with_automatic_reconnect({
                 "type": "raw",
@@ -55,4 +60,4 @@ class BaseTestCase(InternalTestCase):
         hub = builder.build()
         hub.on_open(self.on_open)
         hub.on_close(self.on_close)
-        return hub
+        return hub

test/client_streaming_test.py

@@ -1,32 +1,28 @@
-import os
-import unittest
-import logging
-import time
-import uuid
-
-from subprocess import Popen, PIPE
-from signalrcore.hub_connection_builder import HubConnectionBuilder
 from signalrcore.subject import Subject
 from test.base_test_case import BaseTestCase, Urls
 
+
 class TestClientStreamMethod(BaseTestCase):
 
     def test_stream(self):
         self.complete = False
-        self.items = list(range(0,10))
+        self.items = list(range(0, 10))
         subject = Subject()
         self.connection.send("UploadStream", subject)
-        while(len(self.items) > 0):
+        while (len(self.items) > 0):
             subject.next(str(self.items.pop()))
         subject.complete()
         self.assertTrue(len(self.items) == 0)
 
+
 class TestClientStreamMethodMsgPack(TestClientStreamMethod):
     def get_connection(self):
-        return super().get_connection(msgpack=True)    
+        return super().get_connection(msgpack=True)
+
 
-class TestClientNosslStreamMethodMsgPack(TestClientStreamMethodMsgPack):
+class TestClientNoSslStreamMethodMsgPack(TestClientStreamMethodMsgPack):
     server_url = Urls.server_url_no_ssl
 
-class TestClientNosslStreamMethod(TestClientStreamMethod):
-    server_url = Urls.server_url_no_ssl
+
+class TestClientNoSslStreamMethod(TestClientStreamMethod):
+    server_url = Urls.server_url_no_ssl

test/configuration_test.py

@@ -1,22 +1,23 @@
-import websocket
 import logging
 from signalrcore.hub_connection_builder import HubConnectionBuilder
 
-from test.base_test_case import BaseTestCase, Urls
+from test.base_test_case import BaseTestCase
+
 
 class TestConfiguration(BaseTestCase):
-    
+
     def test_bad_auth_function(self):
         with self.assertRaises(TypeError):
             self.connection = HubConnectionBuilder()\
-                .with_url(self.server_url,
-                options={
-                    "verify_ssl": False,
-                    "access_token_factory": 1234,
-                    "headers": {
-                        "mycustomheader": "mycustomheadervalue"
-                    }
-                })
+                .with_url(
+                    self.server_url,
+                    options={
+                        "verify_ssl": False,
+                        "access_token_factory": 1234,
+                        "headers": {
+                            "mycustomheader": "mycustomheadervalue"
+                        }
+                    })
 
     def test_bad_url(self):
         with self.assertRaises(ValueError):
@@ -26,26 +27,28 @@ class TestConfiguration(BaseTestCase):
     def test_bad_options(self):
         with self.assertRaises(TypeError):
             self.connection = HubConnectionBuilder()\
-                .with_url(self.server_url,
-                options=["ssl", True])
-    
+                .with_url(
+                    self.server_url,
+                    options=["ssl", True])
+
     def test_auth_configured(self):
         with self.assertRaises(TypeError):
             hub = HubConnectionBuilder()\
-                    .with_url(self.server_url,
-                    options={
-                        "verify_ssl": False,
-                        "headers": {
-                            "mycustomheader": "mycustomheadervalue"
-                        }
-                    })
+                    .with_url(
+                        self.server_url,
+                        options={
+                            "verify_ssl": False,
+                            "headers": {
+                                "mycustomheader": "mycustomheadervalue"
+                            }
+                        })
             hub.has_auth_configured = True
             hub.options["access_token_factory"] = ""
-            conn = hub.build()
+            _ = hub.build()
 
     def test_enable_trace(self):
         hub = HubConnectionBuilder()\
-            .with_url(self.server_url, options={"verify_ssl":False})\
+            .with_url(self.server_url, options={"verify_ssl": False})\
             .configure_logging(logging.WARNING, socket_trace=True)\
             .with_automatic_reconnect({
                 "type": "raw",
@@ -57,6 +60,5 @@ class TestConfiguration(BaseTestCase):
         hub.on_open(self.on_open)
         hub.on_close(self.on_close)
         hub.start()
-        self.assertTrue(websocket.isEnabledForDebug())
-        websocket.enableTrace(False)
-        hub.stop()
+        self.assertTrue(hub.transport.is_trace_enabled())
+        hub.stop()

test/open_close_test.py

@@ -1,16 +1,14 @@
-import os
-import unittest
 import logging
-import time
 import threading
 import uuid
 
-from subprocess import Popen, PIPE
 from signalrcore.hub_connection_builder import HubConnectionBuilder
-from signalrcore.subject import Subject
-from test.base_test_case import BaseTestCase, Urls
+from test.base_test_case import BaseTestCase
 
-class TestClientStreamMethod(BaseTestCase):    
+LOCKS = {}
+
+
+class TestClientStreamMethod(BaseTestCase):
     def setUp(self):
         pass
 
@@ -22,43 +20,54 @@ class TestClientStreamMethod(BaseTestCase):
             .with_url(self.server_url, options={"verify_ssl": False})\
             .configure_logging(logging.ERROR)\
             .build()
-        
-        _lock = threading.Lock()
-        self.assertTrue(_lock.acquire(timeout=30))
-        
-
-        connection.on_open(lambda: _lock.release())
-        connection.on_close(lambda: _lock.release())
-        
+
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+
+        def release():
+            LOCKS[identifier].release()
+
+        self.assertTrue(LOCKS[identifier].acquire(timeout=30))
+
+        connection.on_open(release)
+        connection.on_close(release)
+
         result = connection.start()
 
         self.assertTrue(result)
-        
-        self.assertTrue(_lock.acquire(timeout=30))  # Released on open
-        
+
+        self.assertTrue(LOCKS[identifier].acquire(timeout=30))
+        # Released on open
+
         result = connection.start()
 
         self.assertFalse(result)
 
         connection.stop()
 
+        del LOCKS[identifier]
+
     def test_open_close(self):
         self.connection = self.get_connection()
-      
-        _lock = threading.Lock()
 
-        self.connection.on_open(lambda: _lock.release())
-        self.connection.on_close(lambda: _lock.release())
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+
+        def release():
+            LOCKS[identifier].release()
 
-        self.assertTrue(_lock.acquire())
+        self.connection.on_open(release)
+        self.connection.on_close(release)
+
+        self.assertTrue(LOCKS[identifier].acquire())
 
         self.connection.start()
 
-        self.assertTrue(_lock.acquire())
-        
+        self.assertTrue(LOCKS[identifier].acquire())
+
         self.connection.stop()
-        
-        self.assertTrue(_lock.acquire())
 
-        _lock.release()
-        del _lock
+        self.assertTrue(LOCKS[identifier].acquire())
+
+        release()
+        del LOCKS[identifier]

test/reconnection_test.py

@@ -1,22 +1,19 @@
-import os
-import unittest
 import logging
 import time
 import uuid
 import threading
 
-from subprocess import Popen, PIPE
 from signalrcore.hub_connection_builder import HubConnectionBuilder
 from signalrcore.hub.errors import HubConnectionError
-from test.base_test_case import BaseTestCase, Urls
-from signalrcore.transport.websockets.reconnection import RawReconnectionHandler, IntervalReconnectionHandler
+from test.base_test_case import BaseTestCase
+from signalrcore.transport.websockets.reconnection\
+    import RawReconnectionHandler, IntervalReconnectionHandler
 
 
-class TestReconnectMethods(BaseTestCase):
+LOCKS = {}
+
 
-    def receive_message(self, args):
-        self.assertEqual(args[1], self.message)
-        self.received = True
+class TestReconnectMethods(BaseTestCase):
 
     def test_reconnect_interval_config(self):
         connection = HubConnectionBuilder()\
@@ -27,21 +24,27 @@ class TestReconnectMethods(BaseTestCase):
                 "intervals": [1, 2, 4, 45, 6, 7, 8, 9, 10]
             })\
             .build()
-        _lock = threading.Lock()
-        connection.on_open(lambda: _lock.release())
-        connection.on_close(lambda: _lock.release())
 
-        self.assertTrue(_lock.acquire(timeout=10))
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+
+        def release():
+            LOCKS[identifier].release()
+
+        connection.on_open(release)
+        connection.on_close(release)
+
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
 
         connection.start()
 
-        self.assertTrue(_lock.acquire(timeout=10))
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
 
         connection.stop()
 
-        self.assertTrue(_lock.acquire(timeout=10))
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
 
-        del _lock
+        del LOCKS[identifier]
 
     def test_reconnect_interval(self):
         connection = HubConnectionBuilder()\
@@ -61,21 +64,26 @@ class TestReconnectMethods(BaseTestCase):
             .configure_logging(logging.ERROR)\
             .build()
 
-        _lock = threading.Lock()
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+
+        def release(msg=None):
+            LOCKS[identifier].release()
 
-        _lock.acquire(timeout=10)
+        LOCKS[identifier].acquire(timeout=10)
 
-        connection.on_open(lambda: _lock.release())
+        connection.on_open(release)
 
-        connection.on("ReceiveMessage", lambda _: _lock.release())
+        connection.on("ReceiveMessage", release)
 
         connection.start()
 
-        self.assertTrue(_lock.acquire(timeout=10))  # Released on ReOpen
-        
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
+        # Released on ReOpen
+
         connection.send("DisconnectMe", [])
 
-        self.assertTrue(_lock.acquire(timeout=10))
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
 
         time.sleep(10)
 
@@ -84,23 +92,29 @@ class TestReconnectMethods(BaseTestCase):
             lambda: connection.send("DisconnectMe", []))
 
         connection.stop()
-        del _lock
+        del LOCKS[identifier]
 
     def reconnect_test(self, connection):
-        _lock = threading.RLock()
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+
+        def release():
+            LOCKS[identifier].release()
 
-        connection.on_open(lambda: _lock.release())
+        connection.on_open(release)
 
         connection.start()
 
-        self.assertTrue(_lock.acquire(timeout=10)) # Release on Open
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
+        # Release on Open
 
         connection.send("DisconnectMe", [])
 
-        self.assertTrue(_lock.acquire(timeout=10)) # released on open
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
+        # released on open
 
         connection.stop()
-        del _lock
+        del LOCKS[identifier]
 
     def test_raw_reconnection(self):
         connection = HubConnectionBuilder()\
@@ -117,11 +131,11 @@ class TestReconnectMethods(BaseTestCase):
 
     def test_raw_handler(self):
         handler = RawReconnectionHandler(5, 10)
-        attemp = 0
+        attempt = 0
 
-        while attemp <= 10:
+        while attempt <= 10:
             self.assertEqual(handler.next(), 5)
-            attemp = attemp + 1
+            attempt = attempt + 1
 
         self.assertRaises(ValueError, handler.next)
 

test/send_auth_errors_test.py

@@ -1,14 +1,10 @@
-import os
-import unittest
 import logging
-import time
-import uuid
 import requests
-from subprocess import Popen, PIPE
 from signalrcore.hub_connection_builder import HubConnectionBuilder
 from signalrcore.protocol.messagepack_protocol import MessagePackHubProtocol
 from test.base_test_case import BaseTestCase, Urls
 
+
 class TestSendAuthErrorMethod(BaseTestCase):
     server_url = Urls.server_url_ssl_auth
     login_url = Urls.login_url_ssl
@@ -23,8 +19,9 @@ class TestSendAuthErrorMethod(BaseTestCase):
             json={
                 "username": self.email,
                 "password": self.password
-                },verify=False)
-        if response.status_code == 200:
+                },
+            verify=False)
+        if response.status_code == 200:  # pragma: no cover
             return response.json()["token"]
         raise requests.exceptions.ConnectionError()
 
@@ -35,26 +32,29 @@ class TestSendAuthErrorMethod(BaseTestCase):
         self._test_send(msgpack=False)
 
     def test_send_msgpack(self):
-        self._test_send(msgpack=True)    
-    
+        self._test_send(msgpack=True)
+
     def _test_send(self, msgpack=False):
         builder = HubConnectionBuilder()\
-            .with_url(self.server_url,
-            options={
-                "verify_ssl": False,
-                "access_token_factory": self.login,
-            })
-        
+            .with_url(
+                self.server_url,
+                options={
+                    "verify_ssl": False,
+                    "access_token_factory": self.login,
+                })
+
         if msgpack:
             builder.with_hub_protocol(MessagePackHubProtocol())
-        
+
         builder.configure_logging(logging.ERROR)
         self.connection = builder.build()
         self.connection.on_open(self.on_open)
         self.connection.on_close(self.on_close)
-        self.assertRaises(requests.exceptions.ConnectionError, lambda :self.connection.start())
+        self.assertRaises(
+            requests.exceptions.ConnectionError,
+            lambda: self.connection.start())
+
 
-        
 class TestSendNoSslAuthMethod(TestSendAuthErrorMethod):
     server_url = Urls.server_url_no_ssl_auth
     login_url = Urls.login_url_no_ssl

test/send_auth_test.py

@@ -1,14 +1,12 @@
-import os
-import unittest
 import threading
 import logging
-import time
 import uuid
 import requests
 from signalrcore.hub_connection_builder import HubConnectionBuilder
 from signalrcore.protocol.messagepack_protocol import MessagePackHubProtocol
 from test.base_test_case import BaseTestCase, Urls
 
+
 class TestSendAuthMethod(BaseTestCase):
     server_url = Urls.server_url_ssl_auth
     login_url = Urls.login_url_ssl
@@ -24,19 +22,21 @@ class TestSendAuthMethod(BaseTestCase):
             json={
                 "username": self.email,
                 "password": self.password
-                },verify=False)
+                },
+            verify=False)
         return response.json()["token"]
 
-    def _setUp(self, msgpack= False):
+    def _setUp(self, msgpack=False):
         builder = HubConnectionBuilder()\
-            .with_url(self.server_url,
-            options={
-                "verify_ssl": False,
-                "access_token_factory": self.login,
-                "headers": {
-                    "mycustomheader": "mycustomheadervalue"
-                }
-            })
+            .with_url(
+                self.server_url,
+                options={
+                    "verify_ssl": False,
+                    "access_token_factory": self.login,
+                    "headers": {
+                        "mycustomheader": "mycustomheadervalue"
+                    }
+                })
 
         if msgpack:
             builder.with_hub_protocol(MessagePackHubProtocol())
@@ -55,7 +55,7 @@ class TestSendAuthMethod(BaseTestCase):
         self._lock = threading.Lock()
         self.assertTrue(self._lock.acquire(timeout=30))
         self.connection.start()
-    
+
     def on_open(self):
         self._lock.release()
 
@@ -65,23 +65,26 @@ class TestSendAuthMethod(BaseTestCase):
     def receive_message(self, args):
         self._lock.release()
         self.assertEqual(args[0], self.message)
-        
+
     def test_send(self):
         self.message = "new message {0}".format(uuid.uuid4())
         self.username = "mandrewcito"
         self.assertTrue(self._lock.acquire(timeout=30))
         self.connection.send("SendMessage", [self.message])
         self.assertTrue(self._lock.acquire(timeout=30))
-        del self._lock    
-        
+        del self._lock
+
+
 class TestSendNoSslAuthMethod(TestSendAuthMethod):
     server_url = Urls.server_url_no_ssl_auth
     login_url = Urls.login_url_no_ssl
 
+
 class TestSendAuthMethodMsgPack(TestSendAuthMethod):
     def setUp(self):
         self._setUp(msgpack=True)
 
+
 class TestSendNoSslAuthMethodMsgPack(TestSendAuthMethod):
     server_url = Urls.server_url_no_ssl_auth
-    login_url = Urls.login_url_no_ssl
+    login_url = Urls.login_url_no_ssl