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_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_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 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_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)