def test_async_rpc_success(self): handler_results = [] sender_results = [] def handler(x): handler_results.append(x) return x ** 2 self.peer.accept_rpc("service", 0, 0, "method", handler) backend.pause_for(TIMEOUT) rpcs = [] rpcs.append(self.sender.send_rpc("service", 0, "method", (1,), {})) rpcs.append(self.sender.send_rpc("service", 0, "method", (2,), {})) rpcs.append(self.sender.send_rpc("service", 0, "method", (3,), {})) rpcs.append(self.sender.send_rpc("service", 0, "method", (4,), {})) while rpcs: rpc = junction.wait_any(rpcs, TIMEOUT) rpcs.remove(rpc) sender_results.append(rpc.value) self.assertEqual(handler_results, [1, 2, 3, 4]) self.assertEqual(sender_results, [1, 4, 9, 16])
def test_downed_recipient_cancels_the_hub_sender_during_chunked_request(self): global PORT hub = junction.Hub(("127.0.0.1", PORT), []) PORT += 2 triggered = [False] @hub.accept_rpc('service', 0, 0, 'method') def handle(chunks): for item in chunks: pass return "all done" hub.start() hub2 = junction.Hub(("127.0.0.1", PORT), [("127.0.0.1", PORT - 2)]) PORT += 2 hub2.start() hub2.wait_connected() def gen(): try: while 1: yield None backend.pause_for(TIMEOUT) finally: triggered[0] = True rpc = hub2.send_rpc('service', 0, 'method', (gen(),)) hub = [hub] backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub,)) backend.pause_for(TIMEOUT * 5) assert triggered[0]
def test_downed_recipient_cancels_the_hub_sender_during_chunked_publish(self): port = _free_port() hub = junction.Hub(("127.0.0.1", port), []) triggered = [False] @hub.accept_publish('service', 0, 0, 'method') def handle(chunks): for item in chunks: pass hub.start() port2 = _free_port() hub2 = junction.Hub(("127.0.0.1", port2), [("127.0.0.1", port)]) hub2.start() hub2.wait_connected() def gen(): try: while 1: yield None backend.pause_for(TIMEOUT) finally: triggered[0] = True hub2.publish('service', 0, 'method', (gen(),)) hub = [hub] backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub,)) backend.pause_for(TIMEOUT * 5) assert triggered[0]
def test_downed_recipient_cancels_the_hub_sender_during_chunked_request( self): port = _free_port() hub = junction.Hub(("127.0.0.1", port), []) triggered = [False] @hub.accept_rpc('service', 0, 0, 'method') def handle(chunks): for item in chunks: pass return "all done" hub.start() port2 = _free_port() hub2 = junction.Hub(("127.0.0.1", port2), [("127.0.0.1", port)]) hub2.start() hub2.wait_connected() def gen(): try: while 1: yield None backend.pause_for(TIMEOUT) finally: triggered[0] = True rpc = hub2.send_rpc('service', 0, 'method', (gen(), )) hub = [hub] backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub, )) backend.pause_for(TIMEOUT * 5) assert triggered[0]
def gen(): try: while 1: yield None backend.pause_for(TIMEOUT) finally: triggered[0] = True
def test_singular_rpc(self): handler_results = [] sender_results = [] @self.peer.accept_rpc("service", 0, 0, "method") def handler(x): handler_results.append(x) return x**2 backend.pause_for(TIMEOUT) sender_results.append( self.sender.rpc("service", 0, "method", (1, ), {}, timeout=TIMEOUT)) sender_results.append( self.sender.rpc("service", 0, "method", (2, ), {}, timeout=TIMEOUT)) sender_results.append( self.sender.rpc("service", 0, "method", (3, ), {}, timeout=TIMEOUT)) sender_results.append( self.sender.rpc("service", 0, "method", (4, ), {}, timeout=TIMEOUT)) self.assertEqual(handler_results, [1, 2, 3, 4]) self.assertEqual(sender_results, [1, 4, 9, 16])
def test_async_rpc_success(self): handler_results = [] sender_results = [] def handler(x): handler_results.append(x) return x**2 self.peer.accept_rpc("service", 0, 0, "method", handler) backend.pause_for(TIMEOUT) rpcs = [] rpcs.append(self.sender.send_rpc("service", 0, "method", (1, ), {})) rpcs.append(self.sender.send_rpc("service", 0, "method", (2, ), {})) rpcs.append(self.sender.send_rpc("service", 0, "method", (3, ), {})) rpcs.append(self.sender.send_rpc("service", 0, "method", (4, ), {})) while rpcs: rpc = junction.wait_any(rpcs, TIMEOUT) rpcs.remove(rpc) sender_results.append(rpc.value) self.assertEqual(handler_results, [1, 2, 3, 4]) self.assertEqual(sender_results, [1, 4, 9, 16])
def test_downed_recipient_cancels_the_hub_sender_during_chunked_publish( self): global PORT hub = junction.Hub(("127.0.0.1", PORT), []) PORT += 2 triggered = [False] @hub.accept_publish('service', 0, 0, 'method') def handle(chunks): for item in chunks: pass hub.start() hub2 = junction.Hub(("127.0.0.1", PORT), [("127.0.0.1", PORT - 2)]) PORT += 2 hub2.start() hub2.wait_connected() def gen(): try: while 1: yield None backend.pause_for(TIMEOUT) finally: triggered[0] = True hub2.publish('service', 0, 'method', (gen(), )) hub = [hub] backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub, )) backend.pause_for(TIMEOUT * 5) assert triggered[0]
def test_rpc_ruled_out_by_method(self): results = [] self.peer.accept_rpc("service", 0, 0, "method1", results.append) backend.pause_for(TIMEOUT) self.assertRaises(junction.errors.UnsupportedRemoteMethod, self.sender.rpc, "service", 0, "method2", (1,), {}, TIMEOUT)
def test_rpc_ruled_out_by_method(self): results = [] self.peer.accept_rpc("service", 0, 0, "method1", results.append) backend.pause_for(TIMEOUT) self.assertRaises(junction.errors.UnsupportedRemoteMethod, self.sender.rpc, "service", 0, "method2", (1, ), {}, TIMEOUT)
def test_rpc_ruled_out_by_routing_id(self): results = [] self.peer.accept_rpc("service", 1, 0, "method", results.append) backend.pause_for(TIMEOUT) self.assertRaises(junction.errors.Unroutable, self.sender.rpc, "service", 1, "method", (1,), {}, TIMEOUT) self.assertEqual(results, [])
def test_rpc_ruled_out_by_routing_id(self): results = [] self.peer.accept_rpc("service", 1, 0, "method", results.append) backend.pause_for(TIMEOUT) self.assertRaises(junction.errors.Unroutable, self.sender.rpc, "service", 1, "method", (1, ), {}, TIMEOUT) self.assertEqual(results, [])
def test_publish_receiver_count_includes_self(self): @self.peer.accept_publish('service', 0, 0, 'method') def handler(): return 8 @self.sender.accept_publish('service', 0, 0, 'method') def handler(): return 9 backend.pause_for(TIMEOUT) self.assertEqual(2, self.sender.publish_receiver_count('service', 0))
def test_rpc_handler_unknown_exception(self): class CustomError(Exception): pass def handler(): raise CustomError("WOOPS") self.peer.accept_rpc("service", 0, 0, "method", handler) backend.pause_for(TIMEOUT) try: self.sender.rpc("service", 0, "method", (), {}, TIMEOUT) except junction.errors.RemoteException, exc: result = exc
def test_rpc_handler_recognized_exception(self): class CustomError(junction.errors.HandledError): code = 3 def handler(): raise CustomError("gaah") self.peer.accept_rpc("service", 0, 0, "method", handler) backend.pause_for(TIMEOUT) try: self.sender.rpc("service", 0, "method", (), {}, TIMEOUT) except CustomError, exc: result = exc
def test_unrelated_client_chunked_publishes_are_unrelated(self): global PORT hub = junction.Hub(("127.0.0.1", PORT), []) PORT += 2 d = {} @hub.accept_publish('service', 0, 0, 'method') def handle(x, source): for item in x: d.setdefault(source, 0) d[source] += 1 hub.start() c1 = junction.Client(("127.0.0.1", PORT - 2)) c1.connect() c1.wait_connected() c2 = junction.Client(("127.0.0.1", PORT - 2)) c2.connect() c2.wait_connected() def gen(): backend.pause_for(TIMEOUT) yield None backend.pause_for(TIMEOUT) yield None backend.pause_for(TIMEOUT) yield None backend.schedule(c1.publish, args=('service', 0, 'method'), kwargs={ 'args': (gen(), ), 'kwargs': { 'source': 'a' } }) backend.schedule(c2.publish, args=('service', 0, 'method'), kwargs={ 'args': (gen(), ), 'kwargs': { 'source': 'b' } }) backend.pause_for(TIMEOUT) c2 = [c2] self.kill_client(c2) backend.pause_for(TIMEOUT) backend.pause_for(TIMEOUT) backend.pause_for(TIMEOUT) self.assertEquals(d, {'a': 3, 'b': 1})
def test_chunked_publish_success(self): results = [] ev = backend.Event() @self.peer.accept_publish("service", 0, 0, "method") def handler(items): for item in items: results.append(item) ev.set() backend.pause_for(TIMEOUT) self.sender.publish("service", 0, "method", ((x for x in xrange(5)),)) assert not ev.wait(TIMEOUT) self.assertEqual(results, [0, 1, 2, 3, 4])
def test_rpc_ruled_out_by_service(self): results = [] ev = backend.Event() @self.peer.accept_rpc("service1", 0, 0, "method") def handler(item): results.append(item) ev.set() backend.pause_for(TIMEOUT) self.assertRaises(junction.errors.Unroutable, self.sender.rpc, "service2", 0, "method", (1,), {}, TIMEOUT) assert ev.wait(TIMEOUT) self.assertEqual(results, [])
def test_rpc_ruled_out_by_service(self): results = [] ev = backend.Event() @self.peer.accept_rpc("service1", 0, 0, "method") def handler(item): results.append(item) ev.set() backend.pause_for(TIMEOUT) self.assertRaises(junction.errors.Unroutable, self.sender.rpc, "service2", 0, "method", (1, ), {}, TIMEOUT) assert ev.wait(TIMEOUT) self.assertEqual(results, [])
def test_chunked_publish_success(self): results = [] ev = backend.Event() @self.peer.accept_publish("service", 0, 0, "method") def handler(items): for item in items: results.append(item) ev.set() backend.pause_for(TIMEOUT) self.sender.publish("service", 0, "method", ((x for x in xrange(5)), )) assert not ev.wait(TIMEOUT) self.assertEqual(results, [0, 1, 2, 3, 4])
def test_publish_success(self): results = [] ev = backend.Event() @self.peer.accept_publish("service", 0, 0, "method") def handler(item): results.append(item) if len(results) == 4: ev.set() backend.pause_for(TIMEOUT) self.sender.publish("service", 0, "method", (1,), {}) self.sender.publish("service", 0, "method", (2,), {}) self.sender.publish("service", 0, "method", (3,), {}) self.sender.publish("service", 0, "method", (4,), {}) ev.wait(TIMEOUT) self.assertEqual(results, [1, 2, 3, 4])
def test_publish_ruled_out_by_service(self): results = [] ev = backend.Event() @self.peer.accept_publish("service1", 0, 0, "method") def handler(item): results.append(item) ev.set() backend.pause_for(TIMEOUT) try: self.sender.publish("service2", 0, "method", (1, ), {}) except junction.errors.Unroutable: # eat this as Clients don't get this raised, only Hubs pass assert ev.wait(TIMEOUT) self.assertEqual(results, [])
def test_publish_ruled_out_by_service(self): results = [] ev = backend.Event() @self.peer.accept_publish("service1", 0, 0, "method") def handler(item): results.append(item) ev.set() backend.pause_for(TIMEOUT) try: self.sender.publish("service2", 0, "method", (1,), {}) except junction.errors.Unroutable: # eat this as Clients don't get this raised, only Hubs pass assert ev.wait(TIMEOUT) self.assertEqual(results, [])
def test_publish_success(self): results = [] ev = backend.Event() @self.peer.accept_publish("service", 0, 0, "method") def handler(item): results.append(item) if len(results) == 4: ev.set() backend.pause_for(TIMEOUT) self.sender.publish("service", 0, "method", (1, ), {}) self.sender.publish("service", 0, "method", (2, ), {}) self.sender.publish("service", 0, "method", (3, ), {}) self.sender.publish("service", 0, "method", (4, ), {}) ev.wait(TIMEOUT) self.assertEqual(results, [1, 2, 3, 4])
def test_chunked_publish(self): results = [] @self.peer.accept_rpc('service', 0, 0, 'method') def handler(chunks): for chunk in chunks: results.append(chunk) return 5 backend.pause_for(TIMEOUT) def gen(): yield 1 yield 2 self.assertEqual( self.sender.rpc('service', 0, 'method', (gen(), ), timeout=TIMEOUT), 5) self.assertEqual(results, [1, 2])
def test_chunked_publish(self): results = [] @self.peer.accept_rpc('service', 0, 0, 'method') def handler(chunks): for chunk in chunks: results.append(chunk) return 5 backend.pause_for(TIMEOUT) def gen(): yield 1 yield 2 self.assertEqual( self.sender.rpc('service', 0, 'method', (gen(),), timeout=TIMEOUT), 5) self.assertEqual(results, [1,2])
def gen(): backend.pause_for(TIMEOUT) yield None backend.pause_for(TIMEOUT) yield None backend.pause_for(TIMEOUT) yield None
def test_singular_rpc(self): handler_results = [] sender_results = [] @self.peer.accept_rpc("service", 0, 0, "method") def handler(x): handler_results.append(x) return x ** 2 backend.pause_for(TIMEOUT) sender_results.append(self.sender.rpc("service", 0, "method", (1,), {}, timeout=TIMEOUT)) sender_results.append(self.sender.rpc("service", 0, "method", (2,), {}, timeout=TIMEOUT)) sender_results.append(self.sender.rpc("service", 0, "method", (3,), {}, timeout=TIMEOUT)) sender_results.append(self.sender.rpc("service", 0, "method", (4,), {}, timeout=TIMEOUT)) self.assertEqual(handler_results, [1,2,3,4]) self.assertEqual(sender_results, [1,4,9,16])
def test_unrelated_client_chunked_publishes_are_unrelated(self): global PORT hub = junction.Hub(("127.0.0.1", PORT), []) PORT += 2 d = {} @hub.accept_publish('service', 0, 0, 'method') def handle(x, source): for item in x: d.setdefault(source, 0) d[source] += 1 hub.start() c1 = junction.Client(("127.0.0.1", PORT - 2)) c1.connect() c1.wait_connected() c2 = junction.Client(("127.0.0.1", PORT - 2)) c2.connect() c2.wait_connected() def gen(): backend.pause_for(TIMEOUT) yield None backend.pause_for(TIMEOUT) yield None backend.pause_for(TIMEOUT) yield None backend.schedule(c1.publish, args=('service', 0, 'method'), kwargs={'args': (gen(),), 'kwargs': {'source': 'a'}}) backend.schedule(c2.publish, args=('service', 0, 'method'), kwargs={'args': (gen(),), 'kwargs': {'source': 'b'}}) backend.pause_for(TIMEOUT) c2 = [c2] self.kill_client(c2) backend.pause_for(TIMEOUT) backend.pause_for(TIMEOUT) backend.pause_for(TIMEOUT) self.assertEquals(d, {'a': 3, 'b': 1})
def handle(): backend.pause_for(TIMEOUT) return 1