def test_send_recv_multiple_endpoints(self): r = ZmqTestSubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5556")) r.addEndpoints([ZmqEndpoint(ZmqEndpointType.bind, "inproc://endpoint")]) s1 = ZmqPubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5556")) s2 = ZmqPubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "inproc://endpoint")) r.subscribe('') def publish(ignore): s1.publish('111', 'tag1') s2.publish('222', 'tag2') def check(ignore): result = getattr(r, 'messages', []) expected = [['tag1', '111'], ['tag2', '222']] self.failUnlessEqual( sorted(result), expected, "Message should have been received") return _wait(0.1).addCallback(publish) \ .addCallback(lambda _: _wait(0.1)).addCallback(check)
def test_send_recv_multiple_endpoints(self): r = ZmqTestSubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5556")) r.addEndpoints( [ZmqEndpoint(ZmqEndpointType.bind, "inproc://endpoint")]) s1 = ZmqPubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5556")) s2 = ZmqPubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "inproc://endpoint")) r.subscribe('') def publish(ignore): s1.publish('111', 'tag1') s2.publish('222', 'tag2') def check(ignore): result = getattr(r, 'messages', []) expected = [['tag1', '111'], ['tag2', '222']] self.failUnlessEqual(sorted(result), expected, "Message should have been received") return _wait(0.1).addCallback(publish) \ .addCallback(lambda _: _wait(0.1)).addCallback(check)
def test_send_recv_pgm(self): r = ZmqTestSubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "epgm://127.0.0.1;239.192.1.1:5556")) s = ZmqPubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "epgm://127.0.0.1;239.192.1.1:5556")) r.subscribe('tag') def publish(ignore): s.publish('xyz', 'different-tag') s.publish('abcd', 'tag1') def check(ignore): result = getattr(r, 'messages', []) expected = [['tag1', 'abcd']] self.failUnlessEqual(result, expected, "Message should have been received") return _wait(0.2).addCallback(publish) \ .addCallback(lambda _: _wait(0.2)).addCallback(check)
def test_send_lot(self): from txzmq.test import _wait a_result = [] def a_msg_func(msg): a_result.append(msg) b_result = [] def b_msg_func(msg): b_result.append(msg) a = self.make_one(callback=a_msg_func) a.bind("inproc://#1") b = self.make_one(callback=b_msg_func) b.connect("inproc://#1") a2b_msgs = [['a2b %d' % i] for i in range(100)] for m in a2b_msgs: a.send(m) b2a_msgs = [['b2a %d' % i] for i in range(100)] for m in b2a_msgs: b.send(m) def check(ignore): self.assertEqual(a_result, b2a_msgs) self.assertEqual(b_result, a2b_msgs) return _wait(0.1).addCallback(check)
def test_send_recv(self): from txzmq.test import _wait a_result = [] def a_msg_func(msg): a_result.append(msg) b_result = [] def b_msg_func(msg): b_result.append(msg) a = self.make_one(callback=a_msg_func) a.bind("inproc://#1") b = self.make_one(callback=b_msg_func) b.connect("inproc://#1") b.send(['b2a']) def check(ignore): expected = [['a2b']] self.assertEqual(b_result, expected) def check_and_send(ignore): expected = [['b2a']] self.assertEqual(a_result, expected) a.send(['a2b']) return _wait(0.1).addCallback(check) return _wait(0.1).addCallback(check_and_send)
def test_pub_sub_with_filter(self): import zmq from txzmq.test import _wait result = [] def msg_func(msg): result.append(msg) sub = self.make_sub(callback=msg_func) sub.bind('inproc://#1') sub.setsockopt(zmq.SUBSCRIBE, 'a') pub = self.make_pub() pub.connect('inproc://#1') pub.send(['a', 'data1']) pub.send(['b', 'data2']) pub.send(['a', 'data3']) pub.send(['a', 'data4']) def check(ignore): expected = [['a', 'data1'], ['a', 'data3'], ['a', 'data4']] self.assertEqual(result, expected) return _wait(0.1).addCallback(check)
def test_send_to_multiple_nodes(self): from txzmq.test import _wait result = [] def msg_func(msg): result.append(msg) pull1 = self.make_pull(callback=msg_func) pull1.bind("inproc://#1") pull2 = self.make_pull(callback=msg_func) pull2.bind("inproc://#2") pull3 = self.make_pull(callback=msg_func) pull3.bind("inproc://#3") push = self.make_push() push.connect("inproc://#1") push.connect("inproc://#2") push.connect("inproc://#3") for i in range(1, 6+1): push.send(['msg%d' % i]) def check(ignore): for i in range(1, 6+1): self.assertIn(['msg1'], result) return _wait(0.1).addCallback(check)
def test_send_recv(self): self.s.sendMsg("aaa", "aab") self.s.sendMsg("bbb") def check(ignore): result = getattr(self.r, "messages", []) expected = [["msg_id_1", ("aaa", "aab")], ["msg_id_2", ("bbb",)]] self.failUnlessEqual(result, expected, "Message should have been received") return _wait(0.01).addCallback(check)
def test_send_timeout_fail(self): b = ZmqEndpoint(ZmqEndpointType.bind, "ipc://#4") ZmqSlowREPConnection(self.factory, b) c = ZmqEndpoint(ZmqEndpointType.connect, "ipc://#4") s = ZmqREQConnection(self.factory, c, identity=b'client2') return s.sendMsg(b'aaa', timeout=0.05) \ .addCallbacks(lambda _: self.fail("Should timeout"), lambda fail: fail.trap(ZmqRequestTimeoutError)) \ .addCallback(lambda _: _wait(0.1))
def test_send_recv(self): self.s.sendMsg('aaa', 'aab') self.s.sendMsg('bbb') def check(ignore): result = getattr(self.r, 'messages', []) expected = [['msg_id_1', ('aaa', 'aab')], ['msg_id_2', ('bbb',)]] self.failUnlessEqual( result, expected, "Message should have been received") return _wait(0.01).addCallback(check)
def test_send_recv_pgm(self): r = ZmqTestSubConnection(self.factory, ZmqEndpoint( ZmqEndpointType.bind, "epgm://127.0.0.1;239.192.1.1:5556")) s = ZmqPubConnection(self.factory, ZmqEndpoint( ZmqEndpointType.connect, "epgm://127.0.0.1;239.192.1.1:5556")) r.subscribe('tag') def publish(ignore): s.publish('xyz', 'different-tag') s.publish('abcd', 'tag1') def check(ignore): result = getattr(r, 'messages', []) expected = [['tag1', 'abcd']] self.failUnlessEqual( result, expected, "Message should have been received") return _wait(0.2).addCallback(publish) \ .addCallback(lambda _: _wait(0.2)).addCallback(check)
def test_send_recv(self): r = ZmqTestSubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "inproc://test-sock")) s = ZmqPubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "inproc://test-sock")) r.subscribe('tag') def publish(ignore): s.publish('xyz', 'different-tag') s.publish('abcd', 'tag1') s.publish('efgh', 'tag2') def check(ignore): result = getattr(r, 'messages', []) expected = [['tag1', 'abcd'], ['tag2', 'efgh']] self.failUnlessEqual( result, expected, "Message should have been received") return _wait(0.01).addCallback(publish) \ .addCallback(lambda _: _wait(0.01)).addCallback(check)
def test_send_recv(self): r = ZmqTestSubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "ipc://test-sock")) s = ZmqPubConnection( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "ipc://test-sock")) r.subscribe(b'tag') def publish(ignore): s.publish(b'xyz', b'different-tag') s.publish(b'abcd', b'tag1') s.publish(b'efgh', b'tag2') def check(ignore): result = getattr(r, 'messages', []) expected = [[b'tag1', b'abcd'], [b'tag2', b'efgh']] self.failUnlessEqual(result, expected, "Message should have been received") return _wait(0.01).addCallback(publish) \ .addCallback(lambda _: _wait(0.01)).addCallback(check)
def test_curve_auth(self): self.auth_req.start() self.auth_req.allow('127.0.0.1') public_keys_dir = os.path.join(self._config_prefix, PUBLIC_KEYS_PREFIX) self.auth_req.configure_curve(domain="*", location=public_keys_dir) def check(ignored): authenticator = self.authenticator.authenticator certs = authenticator.certs['*'] self.failUnlessEqual(authenticator.whitelist, set([u'127.0.0.1'])) self.failUnlessEqual(certs[certs.keys()[0]], True) return _wait(0.1).addCallback(check)
def test_cancel(self): d = self.s.sendMsg(b'aaa') d.cancel() def check_requests(_): self.assertEqual(self.s._requests, {}) self.failUnlessEqual(self.s.UUID_POOL_GEN_SIZE, len(self.s._uuids) + 1) return d.addCallbacks(lambda _: self.fail("Should have errored"), lambda fail: fail.trap( "twisted.internet.defer.CancelledError")) \ .addCallback(check_requests) \ .addCallback(lambda _: _wait(0.01))
def test_cancel_with_timeout(self): d = self.s.sendMsg(b'aaa', timeout=10.0) d.cancel() def check_requests(_): self.assertEqual(self.s._requests, {}) self.failUnlessEqual(self.s.UUID_POOL_GEN_SIZE, len(self.s._uuids) + 1) return d.addCallbacks(lambda _: self.fail("Should have errored"), lambda fail: fail.trap( "twisted.internet.defer.CancelledError")) \ .addCallback(check_requests) \ .addCallback(lambda _: _wait(0.01))
def test_send_recv(self): r = ZmqTestReceiver( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1")) s = ZmqTestSender( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "inproc://#1")) s.send('abcd') def check(ignore): result = getattr(r, 'messages', []) expected = [['abcd']] self.failUnlessEqual( result, expected, "Message should have been received") return _wait(0.01).addCallback(check)
def test_send_recv(self): r = ZmqTestReceiver(self.factory, ZmqEndpoint(ZmqEndpointType.bind, "inproc://#1")) s = ZmqTestSender(self.factory, ZmqEndpoint(ZmqEndpointType.connect, "inproc://#1")) s.send('abcd') def check(ignore): result = getattr(r, 'messages', []) expected = [['abcd']] self.failUnlessEqual(result, expected, "Message should have been received") return _wait(0.01).addCallback(check)
def test_send_recv_tcp_large(self): r = ZmqTestReceiver( ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555")) r.listen(self.factory) s = ZmqTestSender( ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555")) s.connect(self.factory) s.send(["0" * 10000, "1" * 10000]) def check(ignore): result = getattr(r, 'messages', []) expected = [["0" * 10000, "1" * 10000]] self.failUnlessEqual(result, expected, "Messages should have been received") return _wait(0.01).addCallback(check)
def test_send_recv_tcp_large(self): r = ZmqTestReceiver( ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555")) r.listen(self.factory) s = ZmqTestSender( ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555")) s.connect(self.factory) s.send(["0" * 10000, "1" * 10000]) def check(ignore): result = getattr(r, 'messages', []) expected = [["0" * 10000, "1" * 10000]] self.failUnlessEqual( result, expected, "Messages should have been received") return _wait(0.01).addCallback(check)
def test_send_recv_tcp(self): r = ZmqTestReceiver( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555")) s = ZmqTestSender( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555")) for i in xrange(100): s.send(str(i)) def check(ignore): result = getattr(r, 'messages', []) expected = map(lambda i: [str(i)], xrange(100)) self.failUnlessEqual(result, expected, "Messages should have been received") return _wait(0.01).addCallback(check)
def test_send_recv_tcp(self): r = ZmqTestReceiver( self.factory, ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555")) s = ZmqTestSender( self.factory, ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555")) for i in xrange(100): s.send(str(i)) def check(ignore): result = getattr(r, 'messages', []) expected = map(lambda i: [str(i)], xrange(100)) self.failUnlessEqual( result, expected, "Messages should have been received") return _wait(0.01).addCallback(check)
def test_send_recv(self): from txzmq.test import _wait result = [] def msg_func(msg_id, msg_parts): result.append(msg_parts) rep = self.make_rep(callback=msg_func) rep.bind('inproc://#1') req = self.make_req() req.connect('inproc://#1') req.request(['hello', 'baby']) def check(ignore): expected = [['hello', 'baby']] self.assertEqual(result, expected) return _wait(0.1).addCallback(check)
def test_send_recv(self): from txzmq.test import _wait result = [] def msg_func(msg): result.append(msg) pull = self.make_pull(callback=msg_func) pull.bind("inproc://#1") push = self.make_push() push.connect("inproc://#1") push.send(['abcd']) def check(ignore): expected = [['abcd']] self.assertEqual(result, expected) return _wait(0.1).addCallback(check)
def test_send_recv(self): self.count = 0 def get_next_id(): self.count += 1 return 'msg_id_%d' % (self.count,) self.s._getNextId = get_next_id self.s.sendMsg('aaa', 'aab') self.s.sendMsg('bbb') def check(ignore): result = getattr(self.r, 'messages', []) expected = [['msg_id_1', ('aaa', 'aab')], ['msg_id_2', ('bbb',)]] self.failUnlessEqual( result, expected, "Message should have been received") return _wait(0.01).addCallback(check)
def test_send_recv(self): self.count = 0 def get_next_id(): self.count += 1 return b'msg_id_' + str(self.count).encode() self.s._getNextId = get_next_id self.s.sendMsg(b'aaa', b'aab') self.s.sendMsg(b'bbb') def check(ignore): result = getattr(self.r, 'messages', []) expected = [[b'msg_id_1', (b'aaa', b'aab')], [b'msg_id_2', (b'bbb',)]] self.failUnlessEqual( result, expected, "Message should have been received") return _wait(0.01).addCallback(check)
def test_send_recv(self): import zmq from txzmq.test import _wait result = [] def msg_func(msg): result.append(msg) r = self.make_one(self.factory.context.socket(zmq.PULL), msg_func) r.bind("inproc://#1") s = self.make_one(self.factory.context.socket(zmq.PUSH)) s.connect("inproc://#1") s.send(['abcd']) def check(ignore): expected = [['abcd']] self.assertEqual(result, expected) return _wait(0.1).addCallback(check)
def test_send_recv_tcp(self): import zmq from txzmq.test import _wait result = [] def msg_func(msg): result.append(msg) r = self.make_one(self.factory.context.socket(zmq.PULL), msg_func) r.bind("tcp://127.0.0.1:5555") s = self.make_one(self.factory.context.socket(zmq.PUSH)) s.connect("tcp://127.0.0.1:5555") msgs = [[str(i)] for i in xrange(100)] for m in msgs: s.send(m) def check(ignore): self.assertEqual(result, msgs) return _wait(0.1).addCallback(check)
def test_send_recv_pgm(self): try: r = ZmqTestSubConnection(self.factory, ZmqEndpoint( ZmqEndpointType.bind, "epgm://127.0.0.1;239.192.1.1:5556")) s = ZmqPubConnection(self.factory, ZmqEndpoint( ZmqEndpointType.connect, "epgm://127.0.0.1;239.192.1.1:5556")) except ZMQError as e: if e.strerror == "Protocol not supported": print >> sys.stderr, "EPGM not supported" return else: raise r.subscribe('tag') s.publish('xyz', 'different-tag') s.publish('abcd', 'tag1') def check(ignore): result = getattr(r, 'messages', []) expected = [['tag1', 'abcd']] self.failUnlessEqual( result, expected, "Message should have been received") return _wait(0.2).addCallback(check)
def check_and_send(ignore): expected = [['b2a']] self.assertEqual(a_result, expected) a.send(['a2b']) return _wait(0.1).addCallback(check)