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

test/send_test.py

@@ -1,15 +1,13 @@
-import os
-import re
-import unittest
-import logging
 import time
 import uuid
 import threading
 
-from signalrcore.hub_connection_builder import HubConnectionBuilder
-from signalrcore.hub.errors import HubError, HubConnectionError
+from signalrcore.hub.errors import HubConnectionError
 from test.base_test_case import BaseTestCase, Urls
 
+LOCKS = {}
+
+
 class TestSendException(BaseTestCase):
     def receive_message(self, _):
         raise Exception()
@@ -19,46 +17,61 @@ class TestSendException(BaseTestCase):
         self.connection.start()
         while not self.connected:
             time.sleep(0.1)
-    
+
     def test_send_exception(self):
-        _lock = threading.Lock()
-        _lock.acquire()
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+        LOCKS[identifier].acquire()
         self.connection.send("SendMessage", ["user", "msg"])
-        del _lock
+        del LOCKS[identifier]
 
     def test_hub_error(self):
-        _lock = threading.Lock()
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
 
-        self.assertTrue(_lock.acquire(timeout=10))     
-        self.connection.on_error(lambda _: _lock.release())
+        def on_error(err=None):
+            LOCKS[identifier].release()
+
+        self.connection.on_error(on_error)
 
         def on_message(_):
-            _lock.release()
-            self.assertTrue(_lock.acquire(timeout=10)) 
+            LOCKS[identifier].release()
+            self.assertTrue(LOCKS[identifier].acquire(timeout=10))
 
         self.connection.on("ThrowExceptionCall", on_message)
         self.connection.send("ThrowException", ["msg"])
 
+
 class TestSendExceptionMsgPack(TestSendException):
     def setUp(self):
         self.connection = self.get_connection(msgpack=True)
         self.connection.start()
         while not self.connected:
             time.sleep(0.1)
-        
+
+
 class TestSendWarning(BaseTestCase):
     def setUp(self):
         self.connection = self.get_connection()
         self.connection.start()
         while not self.connected:
             time.sleep(0.1)
-    
+
     def test_send_warning(self):
-        _lock = threading.Lock()
-        _lock.acquire()
-        self.connection.send("SendMessage", ["user", "msg"], lambda m: _lock.release())
-        self.assertTrue(_lock.acquire(timeout=10))
-        del _lock
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+        LOCKS[identifier].acquire()
+
+        def release(msg=None):
+            global LOCKS
+            LOCKS[identifier].release()
+
+        self.connection.send("SendMessage", ["user", "msg"], release)
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
+        del LOCKS[identifier]
+
 
 class TestSendWarningMsgPack(TestSendWarning):
     def setUp(self):
@@ -66,11 +79,12 @@ class TestSendWarningMsgPack(TestSendWarning):
         self.connection.start()
         while not self.connected:
             time.sleep(0.1)
-        
+
 
 class TestSendMethod(BaseTestCase):
     received = False
     message = None
+
     def setUp(self):
         self.connection = self.get_connection()
         self.connection.on("ReceiveMessage", self.receive_message)
@@ -82,12 +96,13 @@ class TestSendMethod(BaseTestCase):
         self.assertEqual(args[1], self.message)
         self.received = True
 
-
     def test_send_bad_args(self):
         class A():
             pass
 
-        self.assertRaises(TypeError, lambda : self.connection.send("SendMessage", A()))
+        self.assertRaises(
+            TypeError,
+            lambda: self.connection.send("SendMessage", A()))
 
     def test_send(self):
         self.message = "new message {0}".format(uuid.uuid4())
@@ -102,13 +117,16 @@ class TestSendMethod(BaseTestCase):
         self.message = "new message {0}".format(uuid.uuid4())
         self.username = "mandrewcito"
         self.received = False
-        _lock = threading.Lock()
-        _lock.acquire()
+        identifier = str(uuid.uuid4())
+        LOCKS[identifier] = threading.Lock()
+
+        LOCKS[identifier].acquire()
         uid = str(uuid.uuid4())
 
         def release(m):
+            global LOCKS
             self.assertTrue(m.invocation_id, uid)
-            _lock.release()
+            LOCKS[identifier].release()
 
         self.connection.send(
             "SendMessage",
@@ -116,12 +134,14 @@ class TestSendMethod(BaseTestCase):
             release,
             invocation_id=uid)
 
-        self.assertTrue(_lock.acquire(timeout=10))
-        del _lock
+        self.assertTrue(LOCKS[identifier].acquire(timeout=10))
+        del LOCKS[identifier]
+
 
 class TestSendNoSslMethod(TestSendMethod):
     server_url = Urls.server_url_no_ssl
 
+
 class TestSendMethodMsgPack(TestSendMethod):
     def setUp(self):
         self.connection = super().get_connection(msgpack=True)
@@ -130,12 +150,15 @@ class TestSendMethodMsgPack(TestSendMethod):
         while not self.connected:
             time.sleep(0.1)
 
+
 class TestSendNoSslMethodMsgPack(TestSendMethodMsgPack):
-    server_url = Urls.server_url_no_ssl    
+    server_url = Urls.server_url_no_ssl
+
 
 class TestSendErrorMethod(BaseTestCase):
     received = False
     message = None
+
     def setUp(self):
         self.connection = self.get_connection()
         self.connection.on("ReceiveMessage", self.receive_message)
@@ -144,20 +167,21 @@ class TestSendErrorMethod(BaseTestCase):
         self.assertEqual(args[1], self.message)
         self.received = True
 
-
     def test_send_with_error(self):
         self.message = "new message {0}".format(uuid.uuid4())
         self.username = "mandrewcito"
 
-        self.assertRaises(HubConnectionError,lambda : self.connection.send("SendMessage", [self.username, self.message]))
-        
+        self.assertRaises(
+            HubConnectionError,
+            lambda: self.connection.send(
+                "SendMessage", [self.username, self.message]))
+
         self.connection.start()
         while not self.connected:
             time.sleep(0.1)
 
         self.received = False
-        self.connection.send("SendMessage", [self.username, self.message])        
-        t0 = time.time()
+        self.connection.send("SendMessage", [self.username, self.message])
         while not self.received:
             time.sleep(0.1)
         self.assertTrue(self.received)
@@ -171,6 +195,7 @@ class TestSendErrorMethodMsgPack(TestSendErrorMethod):
     def get_connection(self):
         return super().get_connection(msgpack=True)
 
+
 class TestSendErrorNoSslMethodMsgPack(TestSendErrorNoSslMethod):
     def get_connection(self):
         return super().get_connection(msgpack=True)

test/streaming_test.py

@@ -1,17 +1,11 @@
-import os
-import unittest
-import logging
 import time
-import uuid
-
-from subprocess import Popen, PIPE
-from signalrcore.hub_connection_builder import HubConnectionBuilder
 from test.base_test_case import BaseTestCase, Urls
 
+
 class TestSendMethod(BaseTestCase):
     server_url = Urls.server_url_ssl
     received = False
-    items = list(range(0,10))
+    items = list(range(0, 10))
 
     def on_complete(self, x):
         self.complete = True
@@ -23,46 +17,51 @@ class TestSendMethod(BaseTestCase):
 
     def test_stream(self):
         self.complete = False
-        self.items = list(range(0,10))
+        self.items = list(range(0, 10))
         self.connection.stream(
             "Counter",
             [len(self.items), 500]).subscribe({
                 "next": self.on_next,
                 "complete": self.on_complete,
-                "error": self.fail # TestcaseFail
+                "error": self.fail  # TestcaseFail
              })
         while not self.complete:
             time.sleep(0.1)
-    
+
     def test_stream_error(self):
         self.complete = False
-        self.items = list(range(0,10))
+        self.items = list(range(0, 10))
 
-        my_stream =  self.connection.stream(
+        my_stream = self.connection.stream(
             "Counter",
             [len(self.items), 500])
 
         self.assertRaises(TypeError, lambda: my_stream.subscribe(None))
 
-        self.assertRaises(TypeError, lambda:my_stream.subscribe([self.on_next]))        
+        self.assertRaises(
+            TypeError,
+            lambda: my_stream.subscribe([self.on_next]))
 
         self.assertRaises(KeyError, lambda: my_stream.subscribe({
-                "key":self.on_next
-            }))     
+                "key": self.on_next
+            }))
 
         self.assertRaises(ValueError, lambda: my_stream.subscribe({
                 "next": "",
                 "complete": 1,
-                "error": [] # TestcaseFail
+                "error": []  # TestcaseFail
              }))
 
+
 class TestSendNoSslMethod(TestSendMethod):
     server_url = Urls.server_url_no_ssl
 
+
 class TestSendMethodMsgPack(TestSendMethod):
     def get_connection(self):
         return super().get_connection(msgpack=True)
 
+
 class TestSendMethodNoSslMsgPack(TestSendNoSslMethod):
     def get_connection(self):
-        return super().get_connection(msgpack=True)
+        return super().get_connection(msgpack=True)

test/subscribe_test.py

@@ -0,0 +1,18 @@
+from test.base_test_case import BaseTestCase, Urls
+
+
+class TestSendMethod(BaseTestCase):
+    server_url = Urls.server_url_ssl
+
+    def test_unsubscribe(self):
+        def fake_callback(_):
+            pass
+
+        self.connection = self.get_connection()
+        self.connection.on("ReceiveMessage", fake_callback)
+
+        self.assertEqual(len(self.connection.handlers), 1)
+
+        self.connection.unsubscribe("ReceiveMessage", fake_callback)
+
+        self.assertEqual(len(self.connection.handlers), 0)