def test_double_subscribe(self):
handler = ApplicationSession()
MockTransport(handler)
event0 = Deferred()
event1 = Deferred()
subscription0 = yield handler.subscribe(
lambda: event0.callback(42), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
lambda: event1.callback('foo'), u'com.myapp.topic1')
# same topic, same ID
self.assertTrue(subscription0.id == subscription1.id)
# do a publish (MockTransport fakes the acknowledgement
# message) and then do an actual publish event. The IDs
# are the same, so we just do one Event.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True, exclude_me=False),
)
handler.onMessage(message.Event(subscription0.id, publish.id))
# ensure we actually got both callbacks
self.assertTrue(event0.called, "Missing callback")
self.assertTrue(event1.called, "Missing callback")
def test_double_subscribe(self):
handler = ApplicationSession()
MockTransport(handler)
event0 = Deferred()
event1 = Deferred()
subscription0 = yield handler.subscribe(
lambda: event0.callback(42), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
lambda: event1.callback('foo'), u'com.myapp.topic1')
# same topic, same ID
self.assertTrue(subscription0.id == subscription1.id)
# do a publish (MockTransport fakes the acknowledgement
# message) and then do an actual publish event. The IDs
# are the same, so we just do one Event.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True,
exclude_me=False),
)
handler.onMessage(message.Event(subscription0.id, publish.id))
# ensure we actually got both callbacks
self.assertTrue(event0.called, "Missing callback")
self.assertTrue(event1.called, "Missing callback")
def test_double_subscribe_double_unsubscribe(self):
'''
If we subscribe twice, and unsubscribe twice, we should then get
an Unsubscribed message.
'''
handler = ApplicationSession()
MockTransport(handler)
# monkey-patch ApplicationSession to ensure we get our message
unsubscribed_d = Deferred()
def onMessage(msg):
if isinstance(msg, message.Unsubscribed):
unsubscribed_d.callback(msg)
return ApplicationSession.onMessage(handler, msg)
handler.onMessage = onMessage
event0 = Deferred()
event1 = Deferred()
subscription0 = yield handler.subscribe(
lambda: event0.callback(42), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
lambda: event1.callback('foo'), u'com.myapp.topic1')
self.assertTrue(subscription0.id == subscription1.id)
yield subscription0.unsubscribe()
yield subscription1.unsubscribe()
# after the second unsubscribe, we should have gotten an
# Unsubscribed message
assert unsubscribed_d.called
# do a publish (MockTransport fakes the acknowledgement
# message) and then do an actual publish event. Sending
# the Event should be an error, as we have no
# subscriptions left.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True,
exclude_me=False),
)
try:
handler.onMessage(message.Event(subscription0.id, publish.id))
self.fail("Expected ProtocolError")
except ProtocolError:
pass
# since we unsubscribed the second event handler, we
# should NOT have called its callback
self.assertTrue(not event0.called, "First callback fired.")
self.assertTrue(not event1.called, "Second callback fired.")
def test_subscribe(self):
handler = ApplicationSession()
MockTransport(handler)
def on_event(*args, **kwargs):
print("got event", args, kwargs)
subscription = yield handler.subscribe(on_event, 'com.myapp.topic1')
self.assertTrue(type(subscription.id) in (int, long))
subscription = yield handler.subscribe(on_event, 'com.myapp.topic1', options = types.SubscribeOptions(match = 'wildcard'))
self.assertTrue(type(subscription.id) in (int, long))
def test_subscribe(self):
handler = ApplicationSession()
MockTransport(handler)
def on_event(*args, **kwargs):
print("got event", args, kwargs)
subscription = yield handler.subscribe(on_event, u'com.myapp.topic1')
self.assertTrue(type(subscription.id) in (int, long))
subscription = yield handler.subscribe(on_event, u'com.myapp.topic1', options=types.SubscribeOptions(match=u'wildcard'))
self.assertTrue(type(subscription.id) in (int, long))
def test_double_subscribe_double_unsubscribe(self):
'''
If we subscribe twice, and unsubscribe twice, we should then get
an Unsubscribed message.
'''
handler = ApplicationSession()
MockTransport(handler)
# monkey-patch ApplicationSession to ensure we get our message
unsubscribed_d = Deferred()
def onMessage(msg):
if isinstance(msg, message.Unsubscribed):
unsubscribed_d.callback(msg)
return ApplicationSession.onMessage(handler, msg)
handler.onMessage = onMessage
event0 = Deferred()
event1 = Deferred()
subscription0 = yield handler.subscribe(
lambda: event0.callback(42), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
lambda: event1.callback('foo'), u'com.myapp.topic1')
self.assertTrue(subscription0.id == subscription1.id)
yield subscription0.unsubscribe()
yield subscription1.unsubscribe()
# after the second unsubscribe, we should have gotten an
# Unsubscribed message
assert unsubscribed_d.called
# do a publish (MockTransport fakes the acknowledgement
# message) and then do an actual publish event. Sending
# the Event should be an error, as we have no
# subscriptions left.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True, exclude_me=False),
)
try:
handler.onMessage(message.Event(subscription0.id, publish.id))
self.fail("Expected ProtocolError")
except ProtocolError:
pass
# since we unsubscribed the second event handler, we
# should NOT have called its callback
self.assertTrue(not event0.called, "First callback fired.")
self.assertTrue(not event1.called, "Second callback fired.")
def test_double_subscribe_errors(self):
"""
Test various error-conditions when we try to add a second
subscription-handler (its signature must match any
existing handlers).
"""
handler = ApplicationSession()
MockTransport(handler)
event0 = Deferred()
event1 = Deferred()
def second(*args, **kw):
# our EventDetails should have been passed as the
# "boom" kwarg; see "details_arg=" below
self.assertTrue('boom' in kw)
self.assertTrue(isinstance(kw['boom'], types.EventDetails))
event1.callback(args)
subscription0 = yield handler.subscribe(
lambda arg: event0.callback(arg), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
second,
u'com.myapp.topic1',
types.SubscribeOptions(details_arg='boom'),
)
# same topic, same ID
self.assertTrue(subscription0.id == subscription1.id)
# MockTransport gives us the ack reply and then we do our
# own event message.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True,
exclude_me=False),
)
# note that the protocol serializer converts all sequences
# to lists, so we pass "args" as a list, not a tuple on
# purpose.
handler.onMessage(
message.Event(subscription0.id, publish.id, args=['arg0']))
# each callback should have gotten called, each with its
# own args (we check the correct kwarg in second() above)
self.assertTrue(event0.called)
self.assertTrue(event1.called)
self.assertEqual(event0.result, 'arg0')
self.assertEqual(event1.result, ('arg0', ))
def test_publish_callback_exception(self):
"""
Ensure we handle an exception from the user code.
"""
handler = ApplicationSession()
MockTransport(handler)
error_instance = RuntimeError("we have a problem")
got_err_d = Deferred()
def observer(e, msg):
if error_instance == e.value:
got_err_d.callback(True)
handler.onUserError = observer
def boom():
raise error_instance
sub = yield handler.subscribe(boom, u'com.myapp.topic1')
# MockTransport gives us the ack reply and then we do our
# own event message
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True, exclude_me=False),
)
msg = message.Event(sub.id, publish.id)
handler.onMessage(msg)
# we know it worked if our observer worked and did
# .callback on our Deferred above.
self.assertTrue(got_err_d.called)
def test_publish_callback_exception(self):
"""
Ensure we handle an exception from the user code.
"""
handler = ApplicationSession()
MockTransport(handler)
error_instance = RuntimeError("we have a problem")
got_err_d = Deferred()
def observer(e, msg):
if error_instance == e.value:
got_err_d.callback(True)
handler.onUserError = observer
def boom():
raise error_instance
sub = yield handler.subscribe(boom, u'com.myapp.topic1')
# MockTransport gives us the ack reply and then we do our
# own event message
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True, exclude_me=False),
)
msg = message.Event(sub.id, publish.id)
handler.onMessage(msg)
# we know it worked if our observer worked and did
# .callback on our Deferred above.
self.assertTrue(got_err_d.called)
def test_double_subscribe_errors(self):
"""
Test various error-conditions when we try to add a second
subscription-handler (its signature must match any
existing handlers).
"""
handler = ApplicationSession()
MockTransport(handler)
event0 = Deferred()
event1 = Deferred()
def second(*args, **kw):
# our EventDetails should have been passed as the
# "boom" kwarg; see "details_arg=" below
self.assertTrue('boom' in kw)
self.assertTrue(isinstance(kw['boom'], types.EventDetails))
event1.callback(args)
subscription0 = yield handler.subscribe(
lambda arg: event0.callback(arg), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
second, u'com.myapp.topic1',
types.SubscribeOptions(details_arg='boom'),
)
# same topic, same ID
self.assertTrue(subscription0.id == subscription1.id)
# MockTransport gives us the ack reply and then we do our
# own event message.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True, exclude_me=False),
)
# note that the protocol serializer converts all sequences
# to lists, so we pass "args" as a list, not a tuple on
# purpose.
handler.onMessage(
message.Event(subscription0.id, publish.id, args=['arg0']))
# each callback should have gotten called, each with its
# own args (we check the correct kwarg in second() above)
self.assertTrue(event0.called)
self.assertTrue(event1.called)
self.assertEqual(event0.result, 'arg0')
self.assertEqual(event1.result, ('arg0',))
def test_unsubscribe(self):
handler = ApplicationSession()
MockTransport(handler)
def on_event(*args, **kwargs):
print("got event", args, kwargs)
subscription = yield handler.subscribe(on_event, u'com.myapp.topic1')
yield subscription.unsubscribe()
def test_unsubscribe(self):
handler = ApplicationSession()
MockTransport(handler)
def on_event(*args, **kwargs):
print("got event", args, kwargs)
subscription = yield handler.subscribe(on_event, u'com.myapp.topic1')
yield subscription.unsubscribe()
def subscribe(self, handler, topic=None, options=None):
topic = _prepend(self.pdid, topic)
out.info('cxbr: (%s) subscribe (%s)' % (
self.pdid,
topic,
))
return ApplicationSession.subscribe(self,
handler,
topic=topic,
options=options)
def test_double_subscribe_single_unsubscribe(self):
'''
Make sure we correctly deal with unsubscribing one of our handlers
from the same topic.
'''
handler = ApplicationSession()
MockTransport(handler)
# monkey-patch ApplicationSession to ensure we DO NOT get
# an Unsubscribed message -- since we only unsubscribe
# from ONE of our handlers for com.myapp.topic1
def onMessage(msg):
assert not isinstance(msg, message.Unsubscribed)
return ApplicationSession.onMessage(handler, msg)
handler.onMessage = onMessage
event0 = Deferred()
event1 = Deferred()
subscription0 = yield handler.subscribe(
lambda: event0.callback(42), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
lambda: event1.callback('foo'), u'com.myapp.topic1')
self.assertTrue(subscription0.id == subscription1.id)
yield subscription1.unsubscribe()
# do a publish (MockTransport fakes the acknowledgement
# message) and then do an actual publish event. Note the
# IDs are the same, so there's only one Event.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True,
exclude_me=False),
)
handler.onMessage(message.Event(subscription0.id, publish.id))
# since we unsubscribed the second event handler, we
# should NOT have called its callback
self.assertTrue(event0.called, "Missing callback")
self.assertTrue(not event1.called, "Second callback fired.")
def test_double_subscribe_single_unsubscribe(self):
'''
Make sure we correctly deal with unsubscribing one of our handlers
from the same topic.
'''
handler = ApplicationSession()
MockTransport(handler)
# monkey-patch ApplicationSession to ensure we DO NOT get
# an Unsubscribed message -- since we only unsubscribe
# from ONE of our handlers for com.myapp.topic1
def onMessage(msg):
assert not isinstance(msg, message.Unsubscribed)
return ApplicationSession.onMessage(handler, msg)
handler.onMessage = onMessage
event0 = Deferred()
event1 = Deferred()
subscription0 = yield handler.subscribe(
lambda: event0.callback(42), u'com.myapp.topic1')
subscription1 = yield handler.subscribe(
lambda: event1.callback('foo'), u'com.myapp.topic1')
self.assertTrue(subscription0.id == subscription1.id)
yield subscription1.unsubscribe()
# do a publish (MockTransport fakes the acknowledgement
# message) and then do an actual publish event. Note the
# IDs are the same, so there's only one Event.
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True, exclude_me=False),
)
handler.onMessage(message.Event(subscription0.id, publish.id))
# since we unsubscribed the second event handler, we
# should NOT have called its callback
self.assertTrue(event0.called, "Missing callback")
self.assertTrue(not event1.called, "Second callback fired.")
def test_publish_callback_exception(self):
"""
Ensure we handle an exception from the user code.
"""
handler = ApplicationSession()
MockTransport(handler)
error_instance = RuntimeError("we have a problem")
got_err_d = Deferred()
def observer(kw):
if kw['isError'] and 'failure' in kw:
fail = kw['failure']
fail.trap(RuntimeError)
if error_instance == fail.value:
got_err_d.callback(True)
log.addObserver(observer)
def boom():
raise error_instance
try:
sub = yield handler.subscribe(boom, u'com.myapp.topic1')
# MockTransport gives us the ack reply and then we do our
# own event message
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True,
exclude_me=False),
)
msg = message.Event(sub.id, publish.id)
handler.onMessage(msg)
# we know it worked if our observer worked and did
# .callback on our Deferred above.
self.assertTrue(got_err_d.called)
# ...otherwise trial will fail the test anyway
self.flushLoggedErrors()
finally:
log.removeObserver(observer)
def test_publish_callback_exception(self):
"""
Ensure we handle an exception from the user code.
"""
handler = ApplicationSession()
MockTransport(handler)
error_instance = RuntimeError("we have a problem")
got_err_d = Deferred()
def observer(kw):
if kw['isError'] and 'failure' in kw:
fail = kw['failure']
fail.trap(RuntimeError)
if error_instance == fail.value:
got_err_d.callback(True)
log.addObserver(observer)
def boom():
raise error_instance
try:
sub = yield handler.subscribe(boom, u'com.myapp.topic1')
# MockTransport gives us the ack reply and then we do our
# own event message
publish = yield handler.publish(
u'com.myapp.topic1',
options=types.PublishOptions(acknowledge=True, exclude_me=False),
)
msg = message.Event(sub.id, publish.id)
handler.onMessage(msg)
# we know it worked if our observer worked and did
# .callback on our Deferred above.
self.assertTrue(got_err_d.called)
# ...otherwise trial will fail the test anyway
self.flushLoggedErrors()
finally:
log.removeObserver(observer)
def stockSubscribe(self, handler, topic=None, options=None):
out.info('cxbr: (%s) subscribe (%s)' % (self.pdid, topic,))
return ApplicationSession.subscribe(self, handler, topic=topic, options=options)
def stockSubscribe(self, handler, topic=None, options=None):
return ApplicationSession.subscribe(self, handler, topic=u''+topic, options=options)
def stockSubscribe(self, handler, topic=None, options=None):
return ApplicationSession.subscribe(self,
handler,
topic=u'' + topic,
options=options)
def subscribe(self, handler, pdid, topic=None, options=None):
topic = _prepend(self.pdid, topic)
#out.info('riff: (%s) subscribe (%s)' % (self.pdid, topic,))
return ApplicationSession.subscribe(self, handler, topic=topic, options=options)
def absSubscribe(self, handler, topic=None, options=None):
#out.info('riff: (%s) subscribe (%s)' % (self.pdid, topic,))
return ApplicationSession.subscribe(self, handler, topic=u'' + topic, options=options)
