class ZmqPushPullTestCase(unittest.TestCase):
"""
Test case for L{tx0mq.pushpull}
"""
def setUp(self):
self.factory = ZmqFactory()
def tearDown(self):
self.factory.shutdown()
def test_send_recv(self):
""" Check hsending and receiving """
def onListen(pusher, puller, d):
# now connect the puller
dpuller = puller.connect(self.factory)
dpuller.addCallback(onConnect, pusher, d)
def onConnect(puller, pusher, d):
reactor.callLater(0.2, perform_test, pusher, puller, d)
def perform_test(pusher, puller, d):
for i in range(0,5):
pusher.push(str(i))
reactor.callLater(0.2, check, pusher, puller, d)
def check(pusher, puller, d):
result = getattr(puller, 'messages', [])
expected = [ ['0'], ['1'], ['2'], ['3'], ['4'] ]
self.failUnlessEqual(
result, expected, "Message should have been received")
d.callback(True)
pusher = ZmqPushConnection(ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5858"))
puller = ZmqTestPullConnection(ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5858"))
d = defer.Deferred()
dpush = pusher.listen(self.factory)
dpush.addCallback(onListen, puller, d)
return d
class Worker(object):
def __init__(self):
self.factory = None
self.receiver = None
self.sink = None
def start(self):
self.factory = ZmqFactory()
endpoint = ZmqEndpoint(ZmqEndpointType.connect, "tcp://localhost:5557")
self.receiver = ZmqPullConnection(endpoint)
self.receiver.messageReceived = self.performWork
deferred = self.receiver.connect(self.factory)
deferred.addCallback(self.onReceiverConnected)
endpoint = ZmqEndpoint(ZmqEndpointType.connect, "tcp://localhost:5558")
self.sink = ZmqPushConnection(endpoint)
deferred = self.sink.listen(self.factory)
deferred.addCallback(self.onSinkConnected)
def stop(self):
self.factory.shutdown()
def onReceiverConnected(self, receiver):
print "worker connected to task ventilator"
def onSinkConnected(self, sink):
print "worker connected to task sink"
def performWork(self, message):
# send results to sink after waiting specified job time
# in this example only single-part messages are used
time_interval = message[0]
time_wait = int(time_interval) * 0.001
reactor.callLater(time_wait, self.sendWorkResult, "")
def sendWorkResult(self, result):
self.sink.send(result)
def start(self):
self.factory = ZmqFactory()
endpoint = ZmqEndpoint(ZmqEndpointType.connect, "tcp://localhost:5557")
self.receiver = ZmqPullConnection(endpoint)
self.receiver.messageReceived = self.performWork
deferred = self.receiver.connect(self.factory)
deferred.addCallback(self.onReceiverConnected)
endpoint = ZmqEndpoint(ZmqEndpointType.connect, "tcp://localhost:5558")
self.sink = ZmqPushConnection(endpoint)
deferred = self.sink.listen(self.factory)
deferred.addCallback(self.onSinkConnected)
def setUp(self):
self.factory = ZmqFactory()
class ZmqConnectionTestCase(unittest.TestCase):
"""
Test case for L{zmq.twisted.connection.Connection}.
"""
def setUp(self):
self.factory = ZmqFactory()
def tearDown(self):
self.factory.shutdown()
def test_interfaces(self):
ziv.verifyClass(IReadDescriptor, ZmqConnection)
ziv.verifyClass(IFileDescriptor, ZmqConnection)
def test_init(self):
ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "ipc://#1"))
ZmqTestSender(ZmqEndpoint(ZmqEndpointType.connect, "ipc://#1"))
def test_repr(self):
expected = ("ZmqTestReceiver(None, (ZmqEndpoint(type='bind', address='ipc://#1'),))")
result = ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "ipc://#1"))
self.failUnlessEqual(expected, repr(result))
def test_send_recv(self):
def onListen(r, s, d):
ds = s.connect(self.factory)
ds.addCallback(onConnect, r, d)
def onConnect(s, r, d):
s.send('abcd')
reactor.callLater(0.2, check, r, d)
def check(r, d):
result = getattr(r, 'messages', [])
expected = [['abcd']]
self.failUnlessEqual(
result, expected, "Message should have been received")
d.callback(True)
r = ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "ipc://#1"))
s = ZmqTestSender(ZmqEndpoint(ZmqEndpointType.connect, "ipc://#1"))
d = defer.Deferred()
dr = r.listen(self.factory)
dr.addCallback(onListen, s, d)
return d
def test_send_recv_tcp(self):
def onListen(r, s, d):
ds = s.connect(self.factory)
ds.addCallback(onConnect, r, d)
def onConnect(s, r, d):
for i in xrange(100):
s.send(str(i))
reactor.callLater(0.3, check, r, d)
def check(r, d):
result = getattr(r, 'messages', [])
expected = map(lambda i: [str(i)], xrange(100))
self.failUnlessEqual(
result, expected, "Messages should have been received")
d.callback(True)
r = ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555"))
s = ZmqTestSender(ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555"))
d = defer.Deferred()
dr = r.listen(self.factory)
dr.addCallback(onListen, s, d)
return d
def test_send_recv_tcp_large(self):
def onListen(r, s, d):
ds = s.connect(self.factory)
ds.addCallback(onConnect, r, d)
def onConnect(s, r, d):
s.send(["0" * 10000, "1" * 10000])
reactor.callLater(0.3, check, r, d)
def check(r, d):
result = getattr(r, 'messages', [])
expected = [["0" * 10000, "1" * 10000]]
self.failUnlessEqual(
result, expected, "Messages should have been received")
d.callback(True)
r = ZmqTestReceiver(ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555"))
s = ZmqTestSender(ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555"))
d = defer.Deferred()
dr = r.listen(self.factory)
dr.addCallback(onListen, s, d)
return d
def setUp(self):
self.factory = ZmqFactory()
ZmqPubConnection.allowLoopbackMulticast = True
class ZmqPubSubTestCase(unittest.TestCase):
"""
Test case for L{tx0mq.pubsub}
"""
def setUp(self):
self.factory = ZmqFactory()
ZmqPubConnection.allowLoopbackMulticast = True
def tearDown(self):
del ZmqPubConnection.allowLoopbackMulticast
self.factory.shutdown()
def test_send_recv(self):
""" Check sending and receiving """
def onListen(p, s, d):
ds = s.connect(self.factory)
ds.addCallback(onConnect, p, d)
def onConnect(s, p, d):
s.subscribe("tag")
reactor.callLater(0.2, performTest, s, p, d)
def performTest(s, p, d):
p.publish("xyz", "different-tag")
p.publish("abcd", "tag1")
p.publish("efgh", "tag2")
reactor.callLater(0.2, check, s, d)
def check(s, d):
result = getattr(s, "messages", [])
expected = [["tag1", ["abcd"]], ["tag2", ["efgh"]]]
self.failUnlessEqual(result, expected, "Message should have been received")
d.callback(True)
s = ZmqTestSubConnection(ZmqEndpoint(ZmqEndpointType.connect, "ipc://test-sock"))
p = ZmqPubConnection(ZmqEndpoint(ZmqEndpointType.bind, "ipc://test-sock"))
d = defer.Deferred()
ds = p.listen(self.factory)
ds.addCallback(onListen, s, d)
return d
#
# PGM is not enabled in my 0MQ. OpenPGM is currently broken on
# OS X 10.7. It will be fixed in the OpenPGM 5.2 release.
#
# def test_send_recv_pgm(self):
# """ Test send and receive using multicast """
#
# def onListen(p, s, d):
# print "publisher listening"
# ds = s.connect(self.factory)
# ds.addCallback(onConnect, p, d)
#
# def onConnect(s, p, d):
# print "subscriber connected"
# s.subscribe('tag')
# reactor.callLater(0.2, perform_test, s, p, d)
#
# def perform_test(s, p, d):
# print "publishing messages"
# p.publish('xyz', 'different-tag')
# p.publish('abcd', 'tag1')
# reactor.callLater(0.2, check, s, d)
#
# def check(s, d):
# print "checking results"
# result = getattr(s, 'messages', [])
# print "result: %s" % result
# expected = [['tag1', ['abcd']]]
# print "expected: %s" % expected
# self.failUnlessEqual(
# result, expected, "Message should have been received")
# d.callback(True)
#
# s = ZmqTestSubConnection(
# ZmqEndpoint(ZmqEndpointType.connect, "epgm://127.0.0.1;239.192.1.1:5556"))
# p = ZmqPubConnection(
# ZmqEndpoint(ZmqEndpointType.bind, "epgm://127.0.0.1;239.192.1.1:5556"))
#
# d = defer.Deferred()
#
# dp = p.listen(self.factory)
# dp.addCallback(onListen, s, d)
#
# return d
def test_send_recv_multiple_endpoints(self):
""" Check send and receive using multiple endpoint """
def onP1Listen(p1, p2, s, d):
dp2 = p2.listen(self.factory)
dp2.addCallback(onP2Listen, p1, s, d)
def onP2Listen(p2, p1, s, d):
ds = s.connect(self.factory)
ds.addCallback(onConnect, p1, p2, d)
def onConnect(s, p1, p2, d):
s.subscribe("")
reactor.callLater(0.2, perform_test, s, p1, p2, d)
def perform_test(s, p1, p2, d):
p1.publish("111", "tag1")
p2.publish("222", "tag2")
reactor.callLater(0.2, check, s, d)
def check(s, d):
result = getattr(s, "messages", [])
expected = [["tag2", ["222"]], ["tag1", ["111"]]]
self.failUnlessEqual(result, expected, "Message should have been received")
d.callback(True)
s = ZmqTestSubConnection(
ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5556"),
ZmqEndpoint(ZmqEndpointType.connect, "inproc://endpoint"),
)
p1 = ZmqPubConnection(ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5556"))
p2 = ZmqPubConnection(ZmqEndpoint(ZmqEndpointType.bind, "inproc://endpoint"))
d = defer.Deferred()
ds = p1.listen(self.factory)
ds.addCallback(onP1Listen, p2, s, d)
return d
class ZmqPairTestCase(unittest.TestCase):
"""
Test case for L{tx0mq.pair}
"""
def setUp(self):
self.factory = ZmqFactory()
def tearDown(self):
self.factory.shutdown()
def test_send_recv_ipc(self):
""" Check sending and receiving using ipc """
def onListen(p2, p1, d):
dp1 = p1.connect(self.factory)
dp1.addCallback(onConnect, p2, d)
def onConnect(p1, p2, d):
reactor.callLater(0.2, perform_test, p1, p2, d)
def perform_test(p1, p2, d):
p1.send('abcd')
p2.send('xyz')
p1.send('efgh')
reactor.callLater(0.2, check, p1, p2, d)
def check(p1, p2, d):
p1_result = getattr(p1, 'messages', [])
p1_expected = [['xyz']]
self.failUnlessEqual(
p1_result, p1_expected, "Message should have been received")
p2_result = getattr(p2, 'messages', [])
p2_expected = [['abcd'], ['efgh']]
self.failUnlessEqual(
p2_result, p2_expected, "Message should have been received")
d.callback(True)
p1 = ZmqTestPairConnection(ZmqEndpoint(ZmqEndpointType.connect, "ipc://test-sock"))
p2 = ZmqTestPairConnection(ZmqEndpoint(ZmqEndpointType.bind, "ipc://test-sock"))
d = defer.Deferred()
dp2 = p2.listen(self.factory)
dp2.addCallback(onListen, p1, d)
return d
def test_send_recv_tcp(self):
""" Check sending and receiving using tcp """
def onListen(p2, p1, d):
dp1 = p1.connect(self.factory)
dp1.addCallback(onConnect, p2, d)
def onConnect(p1, p2, d):
reactor.callLater(0.2, perform_test, p1, p2, d)
def perform_test(p1, p2, d):
p1.send('abcd')
p2.send('xyz')
p1.send('efgh')
reactor.callLater(0.2, check, p1, p2, d)
def check(p1, p2, d):
p1_result = getattr(p1, 'messages', [])
p1_expected = [['xyz']]
self.failUnlessEqual(
p1_result, p1_expected, "Message should have been received")
p2_result = getattr(p2, 'messages', [])
p2_expected = [['abcd'], ['efgh']]
self.failUnlessEqual(
p2_result, p2_expected, "Message should have been received")
d.callback(True)
p1 = ZmqTestPairConnection(ZmqEndpoint(ZmqEndpointType.connect, "tcp://127.0.0.1:5555"))
p2 = ZmqTestPairConnection(ZmqEndpoint(ZmqEndpointType.bind, "tcp://127.0.0.1:5555"))
d = defer.Deferred()
dp2 = p2.listen(self.factory)
dp2.addCallback(onListen, p1, d)
return d
def setUp(self):
self.factory = ZmqFactory()
ZmqReqConnection.identity = 'client'
self.r = ZmqTestRepConnection(ZmqEndpoint(ZmqEndpointType.bind, "ipc://#3"))
self.s = ZmqReqConnection(ZmqEndpoint(ZmqEndpointType.connect, "ipc://#3"))
self.count = 0
class ZmqReqRepConnectionTestCase(unittest.TestCase):
"""
Test case for L{tx0mq.reqrep}.
"""
def setUp(self):
self.factory = ZmqFactory()
ZmqReqConnection.identity = 'client'
self.r = ZmqTestRepConnection(ZmqEndpoint(ZmqEndpointType.bind, "ipc://#3"))
self.s = ZmqReqConnection(ZmqEndpoint(ZmqEndpointType.connect, "ipc://#3"))
self.count = 0
def tearDown(self):
ZmqReqConnection.identity = None
self.factory.shutdown()
def test_getNextId(self):
self.failUnlessEqual([], self.s._uuids)
id1 = self.s._getNextId()
self.failUnlessEqual(self.s.UUID_POOL_GEN_SIZE - 1, len(self.s._uuids))
self.failUnlessIsInstance(id1, str)
id2 = self.s._getNextId()
self.failUnlessIsInstance(id2, str)
self.failIfEqual(id1, id2)
ids = [self.s._getNextId() for _ in range(1000)]
self.failUnlessEqual(len(ids), len(set(ids)))
def test_releaseId(self):
self.s._releaseId(self.s._getNextId())
self.failUnlessEqual(self.s.UUID_POOL_GEN_SIZE, len(self.s._uuids))
def test_send_recv(self):
def get_next_id():
self.count += 1
return 'msg_id_%d' % (self.count,)
self.s._getNextId = get_next_id
def onListen(r, d):
ds = self.s.connect(self.factory)
ds.addCallback(onConnect, d)
def onConnect(s, d):
d1 = self.s.request(['aaa', 'aab'])
d2 = self.s.request('bbb')
reactor.callLater(0.2, check, d)
def check(d):
result = getattr(self.r, 'messages', [])
expected = [['msg_id_1', ['aaa', 'aab']], ['msg_id_2', ['bbb']]]
self.failUnlessEqual(
result, expected, "Message should have been received")
d.callback(True)
d = defer.Deferred()
dr = self.r.listen(self.factory)
dr.addCallback(onListen, d)
return d
def test_send_recv_reply(self):
def onListen(r, d):
ds = self.s.connect(self.factory)
ds.addCallback(onConnect, d)
def onConnect(s, d):
d1 = self.s.request('aaa')
d1.addCallback(check_response, d)
def check_response(response, d):
self.assertEqual(response, ['aaa'])
d.callback(True)
d = defer.Deferred()
dr = self.r.listen(self.factory)
dr.addCallback(onListen, d)
return d
def test_lot_send_recv_reply(self):
def onListen(r, d):
ds = self.s.connect(self.factory)
ds.addCallback(onConnect, d)
def onConnect(s, d):
reactor.callLater(0.2, perform_test, d)
def perform_test(d):
def check_response(response, identifier):
expected = ['aaa']
self.assertEqual(response, expected)
return response == expected
deferreds = []
for i in range(1, 11):
identifier = "msg_id_%d" % (i,)
ds = self.s.request(['aaa'])
deferreds.append(ds)
ds.addCallback(check_response, identifier)
dl = defer.DeferredList(deferreds)
dl.addCallback(d.callback)
d = defer.Deferred()
dr = self.r.listen(self.factory)
dr.addCallback(onListen, d)
return d
def test_cleanup_requests(self):
"""The request dict is cleanedup properly."""
def onListen(r, d):
ds = self.s.connect(self.factory)
ds.addCallback(onConnect, d)
def onConnect(s, d):
d1 = self.s.request('aaa')
d1.addCallback(check, d)
def check(ignore, d):
self.assertEqual(self.s._requests, {})
self.failUnlessEqual(self.s.UUID_POOL_GEN_SIZE, len(self.s._uuids))
d.callback(True)
d = defer.Deferred()
dr = self.r.listen(self.factory)
dr.addCallback(onListen, d)
return d
