def test_force_reregister_kick(self): """ Kick an existing registration with force_reregister=True """ raise unittest.SkipTest('FIXME: Adjust unit test mocks #1567') session = mock.Mock() session._realm = 'realm1' self.router.authorize = mock.Mock(return_value=defer.succeed({'allow': True, 'disclose': True})) rap = RouterApplicationSession(session, self.router_factory) rap.send(message.Hello("realm1", {'caller': role.RoleCallerFeatures()})) rap.send(message.Register(1, 'foo')) reg_id = session.mock_calls[-1][1][0].registration # re-set the authorize, as the Deferred from above is already # used-up and it gets called again to authorize the Call self.router.authorize = mock.Mock(return_value=defer.succeed({'allow': True, 'disclose': True})) # re-register the same procedure rap.send(message.Register(2, 'foo', force_reregister=True)) # the first procedure with 'reg_id' as the Registration ID # should have gotten kicked out unregs = [ call[1][0] for call in session.mock_calls if call[0] == 'onMessage' and isinstance(call[1][0], message.Unregistered) ] self.assertEqual(1, len(unregs)) unreg = unregs[0] self.assertEqual(0, unreg.request) self.assertEqual(reg_id, unreg.registration)
def _register(obj, endpoint, procedure, options): request = util.id() d = self._create_future() self._register_reqs[request] = (d, obj, endpoint, procedure, options) if options is not None: msg = message.Register(request, procedure, **options.options) else: msg = message.Register(request, procedure) self._transport.send(msg) return d
def _register(obj, fn, procedure, options): request_id = self._request_id_gen.next() on_reply = txaio.create_future() endpoint_obj = Endpoint(fn, obj, options.details_arg if options else None) self._register_reqs[request_id] = RegisterRequest(request_id, on_reply, procedure, endpoint_obj) if options: msg = message.Register(request_id, procedure, **options.message_attr()) else: msg = message.Register(request_id, procedure) self._transport.send(msg) return on_reply
def generate_test_messages(): """ List of WAMP test message used for serializers. Expand this if you add more options or messages. This list of WAMP message does not contain any binary app payloads! """ msgs = [ message.Hello(u"realm1", {u'subscriber': role.RoleSubscriberFeatures()}), message.Goodbye(), message.Yield(123456), message.Yield(123456, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}), message.Yield(123456, args=[u'hello']), message.Yield(123456, progress=True), message.Interrupt(123456), message.Interrupt(123456, mode=message.Interrupt.KILL), message.Invocation(123456, 789123), message.Invocation(123456, 789123, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}), message.Invocation(123456, 789123, timeout=10000), message.Result(123456), message.Result(123456, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}), message.Result(123456, progress=True), message.Cancel(123456), message.Cancel(123456, mode=message.Cancel.KILL), message.Call(123456, u'com.myapp.procedure1'), message.Call(123456, u'com.myapp.procedure1', args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}), message.Call(123456, u'com.myapp.procedure1', timeout=10000), message.Unregistered(123456), message.Unregister(123456, 789123), message.Registered(123456, 789123), message.Register(123456, u'com.myapp.procedure1'), message.Register(123456, u'com.myapp.procedure1', match=u'prefix'), message.Register(123456, u'com.myapp.procedure1', invoke=u'roundrobin'), message.Event(123456, 789123), message.Event(123456, 789123, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}), message.Event(123456, 789123, publisher=300), message.Published(123456, 789123), message.Publish(123456, u'com.myapp.topic1'), message.Publish(123456, u'com.myapp.topic1', args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}), message.Publish(123456, u'com.myapp.topic1', exclude_me=False, exclude=[300], eligible=[100, 200, 300]), message.Unsubscribed(123456), message.Unsubscribe(123456, 789123), message.Subscribed(123456, 789123), message.Subscribe(123456, u'com.myapp.topic1'), message.Subscribe(123456, u'com.myapp.topic1', match=message.Subscribe.MATCH_PREFIX), message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1'), message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1', args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}), message.Call(123456, u'com.myapp.\u4f60\u597d\u4e16\u754c', args=[1, 2, 3]), message.Result(123456, args=[1, 2, 3], kwargs={u'en': u'Hello World', u'jp': u'\u3053\u3093\u306b\u3061\u306f\u4e16\u754c'}) ] return [(False, msg) for msg in msgs]
def test_ctor(self): e = message.Register(123456, u'com.myapp.procedure1') msg = e.marshal() self.assertEqual(len(msg), 4) self.assertEqual(msg[0], message.Register.MESSAGE_TYPE) self.assertEqual(msg[1], 123456) self.assertEqual(msg[2], {}) self.assertEqual(msg[3], u'com.myapp.procedure1') e = message.Register(123456, u'com.myapp.procedure1', pkeys = [10, 11, 12]) msg = e.marshal() self.assertEqual(len(msg), 4) self.assertEqual(msg[0], message.Register.MESSAGE_TYPE) self.assertEqual(msg[1], 123456) self.assertEqual(msg[2], {u'pkeys': [10, 11, 12]}) self.assertEqual(msg[3], u'com.myapp.procedure1')
def test_ctor(self): e = message.Register(123456, 'com.myapp.procedure1') msg = e.marshal() self.assertEqual(len(msg), 4) self.assertEqual(msg[0], message.Register.MESSAGE_TYPE) self.assertEqual(msg[1], 123456) self.assertEqual(msg[2], {}) self.assertEqual(msg[3], 'com.myapp.procedure1') e = message.Register(123456, 'com.myapp.procedure1', match='wildcard') msg = e.marshal() self.assertEqual(len(msg), 4) self.assertEqual(msg[0], message.Register.MESSAGE_TYPE) self.assertEqual(msg[1], 123456) self.assertEqual(msg[2], {'match': 'wildcard'}) self.assertEqual(msg[3], 'com.myapp.procedure1')
def test_authorize_exception_register(self): """ When a dynamic authorizor throws an exception (during processRegister) we log it. """ the_exception = RuntimeError("authorizer bug") def boom(*args, **kw): raise the_exception self.router._roles[u'test_role'].authorize = boom class TestSession(ApplicationSession): def __init__(self, *args, **kw): super(TestSession, self).__init__(*args, **kw) self._authrole = u'test_role' self._transport = mock.MagicMock() session0 = TestSession() call = message.Register( request=1234, procedure=u'test.proc_reg', ) # this should produce an error -- however processCall doesn't # itself return the Deferred, so we look for the side-effect # -- the router should have tried to send a message.Error (and # we should also have logged the error). self.router._dealer.processRegister(session0, call) self.assertEqual(1, len(session0._transport.mock_calls)) call = session0._transport.mock_calls[0] self.assertEqual('send', call[0]) # ensure we logged our error (flushLoggedErrors also causes # trial to *not* fail the unit-test despite an error logged) errors = self.flushLoggedErrors() self.assertTrue(the_exception in [fail.value for fail in errors])
def test_call_cancel_two_sessions(self): """ this has 2 different session using the same ID (42) for their Call requests to confirm we deal with the fact that these IDs are only unique per-session properly """ messages = [] def session_send(msg): messages.append(msg) session0 = mock.Mock() session0._transport.send = session_send session0._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)} session1 = mock.Mock() session1._transport.send = session_send session1._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)} dealer = self.router._dealer dealer.attach(session0) dealer.attach(session1) def authorize(*args, **kwargs): return defer.succeed({'allow': True, 'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister(session0, message.Register(1, 'com.example.my.proc', 'exact', message.Register.INVOKE_SINGLE, 2)) registered_msg = messages[-1] self.assertIsInstance(registered_msg, message.Registered) # two calls outstanding to the endpoint, both happen to use # the same ID (42) which is legal dealer.processCall(session0, message.Call(42, 'com.example.my.proc', [])) invocation_msg0 = messages[-1] self.assertIsInstance(invocation_msg0, message.Invocation) dealer.processCall(session1, message.Call(42, 'com.example.my.proc', [])) invocation_msg1 = messages[-1] self.assertIsInstance(invocation_msg1, message.Invocation) # now, cancel the first session's call dealer.processCancel(session0, message.Cancel( 42, "kill", )) # should receive an INTERRUPT from the dealer now (for the # correct session only) interrupt_msg0 = messages[-1] self.assertIsInstance(interrupt_msg0, message.Interrupt) self.assertEqual(interrupt_msg0.request, invocation_msg0.request) dealer.processInvocationError( session0, message.Error(message.Invocation.MESSAGE_TYPE, invocation_msg0.request, 'wamp.error.canceled'))
def test_call_cancel(self): last_message = {'1': []} def session_send(msg): last_message['1'] = msg session = mock.Mock() session._transport.send = session_send session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)} dealer = self.router._dealer dealer.attach(session) def authorize(*args, **kwargs): return defer.succeed({u'allow': True, u'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister(session, message.Register( 1, u'com.example.my.proc', u'exact', message.Register.INVOKE_SINGLE, 1 )) registered_msg = last_message['1'] self.assertIsInstance(registered_msg, message.Registered) dealer.processCall(session, message.Call( 2, u'com.example.my.proc', [] )) invocation_msg = last_message['1'] self.assertIsInstance(invocation_msg, message.Invocation) dealer.processCancel(session, message.Cancel( 2 )) # should receive an INTERRUPT from the dealer now interrupt_msg = last_message['1'] self.assertIsInstance(interrupt_msg, message.Interrupt) self.assertEqual(interrupt_msg.request, invocation_msg.request) dealer.processInvocationError(session, message.Error( message.Invocation.MESSAGE_TYPE, invocation_msg.request, u'wamp.error.canceled' )) call_error_msg = last_message['1'] self.assertIsInstance(call_error_msg, message.Error) self.assertEqual(message.Call.MESSAGE_TYPE, call_error_msg.request_type) self.assertEqual(u'wamp.error.canceled', call_error_msg.error)
def generate_test_messages(): return [ message.Hello(u"realm1", [role.RoleBrokerFeatures()]), message.Goodbye(), message.Heartbeat(123, 456), message.Yield(123456), message.Yield(123456, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}), message.Yield(123456, progress = True), message.Interrupt(123456), message.Interrupt(123456, mode = message.Interrupt.KILL), message.Invocation(123456, 789123), message.Invocation(123456, 789123, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}), message.Invocation(123456, 789123, timeout = 10000), message.Result(123456), message.Result(123456, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}), message.Result(123456, progress = True), message.Cancel(123456), message.Cancel(123456, mode = message.Cancel.KILL), message.Call(123456, u'com.myapp.procedure1'), message.Call(123456, u'com.myapp.procedure1', args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}), message.Call(123456, u'com.myapp.procedure1', timeout = 10000), message.Unregistered(123456), message.Unregister(123456, 789123), message.Registered(123456, 789123), message.Register(123456, u'com.myapp.procedure1'), message.Register(123456, u'com.myapp.procedure1', pkeys = [10, 11, 12]), message.Event(123456, 789123), message.Event(123456, 789123, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}), message.Event(123456, 789123, publisher = 300), message.Published(123456, 789123), message.Publish(123456, u'com.myapp.topic1'), message.Publish(123456, u'com.myapp.topic1', args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}), message.Publish(123456, u'com.myapp.topic1', excludeMe = False, exclude = [300], eligible = [100, 200, 300], discloseMe = True), message.Unsubscribed(123456), message.Unsubscribe(123456, 789123), message.Subscribed(123456, 789123), message.Subscribe(123456, u'com.myapp.topic1'), message.Subscribe(123456, u'com.myapp.topic1', match = message.Subscribe.MATCH_PREFIX), message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1'), message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1', args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}), message.Call(123456, u'com.myapp.\u4f60\u597d\u4e16\u754c', args=[1, 2, 3]), message.Result(123456, args=[1, 2, 3], kwargs={u'en': u'Hello World', u'jp': u'\u3053\u3093\u306b\u3061\u306f\u4e16\u754c'}) ]
def test_call_cancel(self): messages = [] def session_send(msg): messages.append(msg) session = mock.Mock() session._transport.send = session_send session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)} dealer = self.router._dealer dealer.attach(session) def authorize(*args, **kwargs): return defer.succeed({u'allow': True, u'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister(session, message.Register( 1, u'com.example.my.proc', u'exact', message.Register.INVOKE_SINGLE, 1 )) registered_msg = messages[-1] self.assertIsInstance(registered_msg, message.Registered) dealer.processCall(session, message.Call( 2, u'com.example.my.proc', [] )) invocation_msg = messages[-1] self.assertIsInstance(invocation_msg, message.Invocation) dealer.processCancel(session, message.Cancel( 2 )) # we should receive an INTERRUPT from the dealer now -- note # that our session is both the caller and the callee in this # test, so we'll get an INTERRUPT *and* an ERROR -- in that # order. interrupt_msg = messages[-2] self.assertIsInstance(interrupt_msg, message.Interrupt) self.assertEqual(interrupt_msg.request, invocation_msg.request) call_error_msg = messages[-1] self.assertIsInstance(call_error_msg, message.Error) self.assertEqual(message.Call.MESSAGE_TYPE, call_error_msg.request_type) self.assertEqual(u'wamp.error.canceled', call_error_msg.error)
def test_ctor_reregister(self): e = message.Register(123456, 'com.myapp.procedure1', force_reregister=True) msg = e.marshal() self.assertEqual(len(msg), 4) self.assertEqual(msg[0], message.Register.MESSAGE_TYPE) self.assertEqual(msg[1], 123456) self.assertEqual(msg[2], {'force_reregister': True}) self.assertEqual(msg[3], 'com.myapp.procedure1') e2 = message.Register.parse(msg) str(e2)
def test_call_timeout_with_callee_and_caller_support(self): messages = [] def session_send(msg): messages.append(msg) session = ApplicationSession() session._transport = mock.Mock() session._transport.send = session_send session._session_roles = { 'callee': role.RoleCalleeFeatures(call_canceling=True), 'caller': role.RoleCallerFeatures(call_canceling=True), } dealer = self.router._dealer dealer.attach(session) dealer._cancel_timers.call_later = mock.Mock() def authorize(*args, **kwargs): return defer.succeed({u'allow': True, u'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister( session, message.Register(1, u'com.example.my.proc', u'exact', message.Register.INVOKE_SINGLE, 1)) registered_msg = messages[-1] self.assertIsInstance(registered_msg, message.Registered) dealer.processCall( session, message.Call( 2, u'com.example.my.proc', [], timeout=1, )) invocation_msg = messages[-1] self.assertIsInstance(invocation_msg, message.Invocation) # induce a timeout # get the last time-out that was added... mc = dealer._cancel_timers.call_later.mock_calls[0] timeout_fn = mc[1][1] # ...and call it timeout_fn() # caller gets Error (should see it) # callee gets Interrupt (should see it) self.assertTrue(any( isinstance(msg, message.Error) for msg in messages)) self.assertTrue( any(isinstance(msg, message.Interrupt) for msg in messages))
def test_outstanding_invoke(self): """ When a call is pending and the callee goes away, it cancels the in-flight call """ raise unittest.SkipTest('FIXME: Adjust unit test mocks #1567') session = mock.Mock() session._realm = 'realm1' self.router.authorize = mock.Mock( return_value=defer.succeed({ 'allow': True, 'disclose': True })) rap = RouterApplicationSession(session, self.router_factory) rap.send(message.Hello("realm1", {'caller': role.RoleCallerFeatures()})) rap.send(message.Register(1, 'foo')) # we can retrieve the Registration via # session.mock_calls[-1][1][0] if req'd # re-set the authorize, as the Deferred from above is already # used-up and it gets called again to authorize the Call self.router.authorize = mock.Mock( return_value=defer.succeed({ 'allow': True, 'disclose': True })) rap.send(message.Call(42, 'foo')) orig = rap.send d = defer.Deferred() rap.send(message.Goodbye()) def wrapper(*args, **kw): d.callback(args[0]) return orig(*args, **kw) rap.send = wrapper # we can do this *after* the call to send() the Goodbye # (above) because it takes a reactor-turn to actually # process the cancel/errors etc -- hence the Deferred and # yield in this test... msg = yield d self.assertEqual(42, msg.request) self.assertEqual('wamp.error.canceled', msg.error)
def test_call_cancel_nonowned_call(self): last_message = {'1': []} def session_send(msg): last_message['1'] = msg session = mock.Mock() session._transport.send = session_send session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)} dealer = self.router._dealer dealer.attach(session) def authorize(*args, **kwargs): return defer.succeed({u'allow': True, u'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister(session, message.Register( 1, u'com.example.my.proc', u'exact', message.Register.INVOKE_SINGLE, 1 )) registered_msg = last_message['1'] self.assertIsInstance(registered_msg, message.Registered) dealer.processCall(session, message.Call( 2, u'com.example.my.proc', [] )) invocation_msg = last_message['1'] self.assertIsInstance(invocation_msg, message.Invocation) bad_session = mock.Mock() bad_session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)} dealer.attach(bad_session) def attempt_bad_cancel(): dealer.processCancel(bad_session, message.Cancel( 2 )) self.failUnlessRaises(ProtocolError, attempt_bad_cancel)
def test_call_cancel_without_callee_support(self): last_message = {'1': []} def session_send(msg): last_message['1'] = msg session = mock.Mock() session._transport.send = session_send session._session_roles = {'callee': role.RoleCalleeFeatures()} dealer = self.router._dealer dealer.attach(session) def authorize(*args, **kwargs): return defer.succeed({'allow': True, 'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister(session, message.Register( 1, 'com.example.my.proc', 'exact', message.Register.INVOKE_SINGLE, 1 )) registered_msg = last_message['1'] self.assertIsInstance(registered_msg, message.Registered) dealer.processCall(session, message.Call( 2, 'com.example.my.proc', [] )) invocation_msg = last_message['1'] self.assertIsInstance(invocation_msg, message.Invocation) dealer.processCancel(session, message.Cancel( 2 )) # set message to None to make sure that we get nothing back last_message['1'] = None # should NOT receive an INTERRUPT from the dealer now interrupt_msg = last_message['1'] self.assertIsNone(interrupt_msg)
def test_caller_detach_interrupt_cancel_not_supported(self): last_message = {'1': []} def session_send(msg): last_message['1'] = msg session = mock.Mock() session._transport.send = session_send session._session_roles = {'callee': role.RoleCalleeFeatures()} caller_session = mock.Mock() dealer = self.router._dealer dealer.attach(session) dealer.attach(caller_session) def authorize(*args, **kwargs): return defer.succeed({u'allow': True, u'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister(session, message.Register( 1, u'com.example.my.proc', u'exact', message.Register.INVOKE_SINGLE, 1 )) registered_msg = last_message['1'] self.assertIsInstance(registered_msg, message.Registered) dealer.processCall(caller_session, message.Call( 2, u'com.example.my.proc', [] )) invocation_msg = last_message['1'] self.assertIsInstance(invocation_msg, message.Invocation) dealer.detach(caller_session) # reset recorded message to make sure we don't receive anything last_message['1'] = None # should NOT receive an INTERRUPT from the dealer now because we don't support cancellation self.assertIsNone(last_message['1'])
def test_caller_detach_interrupt_cancel_supported(self): last_message = {'1': []} def session_send(msg): last_message['1'] = msg session = mock.Mock() session._transport.send = session_send session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)} caller_session = mock.Mock() dealer = self.router._dealer dealer.attach(session) dealer.attach(caller_session) def authorize(*args, **kwargs): return defer.succeed({'allow': True, 'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) dealer.processRegister(session, message.Register( 1, 'com.example.my.proc', 'exact', message.Register.INVOKE_SINGLE, 1 )) registered_msg = last_message['1'] self.assertIsInstance(registered_msg, message.Registered) dealer.processCall(caller_session, message.Call( 2, 'com.example.my.proc', [] )) invocation_msg = last_message['1'] self.assertIsInstance(invocation_msg, message.Invocation) dealer.detach(caller_session) # should receive an INTERRUPT from the dealer now interrupt_msg = last_message['1'] self.assertIsInstance(interrupt_msg, message.Interrupt) self.assertEqual(interrupt_msg.request, invocation_msg.request)
def test_yield_on_unowned_invocation(self): sessionMessages = {'1': None} def session1send(msg): sessionMessages['1'] = msg def authorize(*args, **kwargs): return defer.succeed({u'allow': True, u'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) session1 = mock.Mock() session1._transport.send = session1send session2 = mock.Mock() dealer = self.router._dealer dealer.attach(session1) dealer.attach(session2) register = message.Register(1, u'com.example.some.call', u'exact', message.Register.INVOKE_SINGLE, 1) dealer.processRegister(session1, register) registered = sessionMessages['1'] self.assertIsInstance(registered, message.Registered) call = message.Call(2, u'com.example.some.call', [], {}) dealer.processCall(session1, call) invocation = sessionMessages['1'] self.assertIsInstance(invocation, message.Invocation) yieldMsg = message.Yield(invocation.request, [u'hello'], {}) # this yield is happening on a different session than the one that # just received the invocation def yield_from_wrong_session(): dealer.processYield(session2, yieldMsg) self.failUnlessRaises(ProtocolError, yield_from_wrong_session)
def generate_test_messages(): """ List of WAMP test message used for serializers. Expand this if you add more options or messages. This list of WAMP message does not contain any binary app payloads! """ some_bytes = os.urandom(32) some_unicode = '\u3053\u3093\u306b\u3061\u306f\u4e16\u754c' some_uri = 'com.myapp.foobar' some_unicode_uri = 'com.myapp.\u4f60\u597d\u4e16\u754c.baz' some_args = [1, 2, 3, 'hello', some_bytes, some_unicode, {'foo': 23, 'bar': 'hello', 'baz': some_bytes, 'moo': some_unicode}] some_kwargs = {'foo': 23, 'bar': 'hello', 'baz': some_bytes, 'moo': some_unicode, 'arr': some_args} msgs = [ message.Hello("realm1", {'subscriber': role.RoleSubscriberFeatures()}), message.Hello("realm1", {'publisher': role.RolePublisherFeatures()}), message.Hello("realm1", {'caller': role.RoleCallerFeatures()}), message.Hello("realm1", {'callee': role.RoleCalleeFeatures()}), message.Hello("realm1", { 'subscriber': role.RoleSubscriberFeatures(), 'publisher': role.RolePublisherFeatures(), 'caller': role.RoleCallerFeatures(), 'callee': role.RoleCalleeFeatures(), }), message.Goodbye(), message.Yield(123456), message.Yield(123456, args=some_args), message.Yield(123456, args=[], kwargs=some_kwargs), message.Yield(123456, args=some_args, kwargs=some_kwargs), message.Yield(123456, progress=True), message.Interrupt(123456), message.Interrupt(123456, mode=message.Interrupt.KILL), message.Invocation(123456, 789123), message.Invocation(123456, 789123, args=some_args), message.Invocation(123456, 789123, args=[], kwargs=some_kwargs), message.Invocation(123456, 789123, args=some_args, kwargs=some_kwargs), message.Invocation(123456, 789123, timeout=10000), message.Result(123456), message.Result(123456, args=some_args), message.Result(123456, args=[], kwargs=some_kwargs), message.Result(123456, args=some_args, kwargs=some_kwargs), message.Result(123456, progress=True), message.Cancel(123456), message.Cancel(123456, mode=message.Cancel.KILL), message.Call(123456, some_uri), message.Call(123456, some_uri, args=some_args), message.Call(123456, some_uri, args=[], kwargs=some_kwargs), message.Call(123456, some_uri, args=some_args, kwargs=some_kwargs), message.Call(123456, some_uri, timeout=10000), message.Call(123456, some_unicode_uri), message.Call(123456, some_unicode_uri, args=some_args), message.Call(123456, some_unicode_uri, args=[], kwargs=some_kwargs), message.Call(123456, some_unicode_uri, args=some_args, kwargs=some_kwargs), message.Call(123456, some_unicode_uri, timeout=10000), message.Unregistered(123456), message.Unregister(123456, 789123), message.Registered(123456, 789123), message.Register(123456, some_uri), message.Register(123456, some_uri, match='prefix'), message.Register(123456, some_uri, invoke='roundrobin'), message.Register(123456, some_unicode_uri), message.Register(123456, some_unicode_uri, match='prefix'), message.Register(123456, some_unicode_uri, invoke='roundrobin'), message.Event(123456, 789123), message.Event(123456, 789123, args=some_args), message.Event(123456, 789123, args=[], kwargs=some_kwargs), message.Event(123456, 789123, args=some_args, kwargs=some_kwargs), message.Event(123456, 789123, publisher=300), message.Published(123456, 789123), message.Publish(123456, some_uri), message.Publish(123456, some_uri, args=some_args), message.Publish(123456, some_uri, args=[], kwargs=some_kwargs), message.Publish(123456, some_uri, args=some_args, kwargs=some_kwargs), message.Publish(123456, some_uri, exclude_me=False, exclude=[300], eligible=[100, 200, 300]), message.Publish(123456, some_unicode_uri), message.Publish(123456, some_unicode_uri, args=some_args), message.Publish(123456, some_unicode_uri, args=[], kwargs=some_kwargs), message.Publish(123456, some_unicode_uri, args=some_args, kwargs=some_kwargs), message.Publish(123456, some_unicode_uri, exclude_me=False, exclude=[300], eligible=[100, 200, 300]), message.Unsubscribed(123456), message.Unsubscribe(123456, 789123), message.Subscribed(123456, 789123), message.Subscribe(123456, some_uri), message.Subscribe(123456, some_uri, match=message.Subscribe.MATCH_PREFIX), message.Subscribe(123456, some_unicode_uri), message.Subscribe(123456, some_unicode_uri, match=message.Subscribe.MATCH_PREFIX), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=some_args), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=[], kwargs=some_kwargs), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=some_args, kwargs=some_kwargs), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=some_args), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=[], kwargs=some_kwargs), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=some_args, kwargs=some_kwargs), message.Result(123456), message.Result(123456, args=some_args), message.Result(123456, args=some_args, kwargs=some_kwargs), ] return [(False, msg) for msg in msgs]
def test_concurrency_with_error(self): """ register a concurrency=2 method, called with errors """ callee_messages = [] caller_messages = [] def callee_send(msg): callee_messages.append(msg) session = mock.Mock() session._transport.send = callee_send session._session_roles = {'callee': role.RoleCalleeFeatures()} def caller_send(msg): caller_messages.append(msg) caller_session = mock.Mock() caller_session._transport.send = caller_send dealer = self.router._dealer dealer.attach(session) dealer.attach(caller_session) def authorize(*args, **kwargs): return defer.succeed({u'allow': True, u'disclose': False}) self.router.authorize = mock.Mock(side_effect=authorize) # we register out procedure, with concurrency=1 dealer.processRegister( session, message.Register(request=1, procedure=u'com.example.my.proc', match=u'exact', invoke=message.Register.INVOKE_SINGLE, concurrency=1)) registered_msg = callee_messages[-1] self.assertIsInstance(registered_msg, message.Registered) # we have registered our procedure that has concurrency=1 # and now we call it dealer.processCall(caller_session, message.Call(2, u'com.example.my.proc', [])) # we pretend that the call caused an error of some sort invocation_msg = callee_messages[-1] self.assertIsInstance(invocation_msg, message.Invocation) dealer.processInvocationError( session, message.Error( message.Call.MESSAGE_TYPE, invocation_msg.request, u"wamp.error.foo", )) self.assertEqual(1, len(caller_messages)) self.assertEqual( u"wamp.error.foo", caller_messages[-1].error, ) # now we call it again, which should work because the # previously-outstanding call was resolved with an error # (before bug 1105 being fixed this wouldn't work properly) dealer.processCall(caller_session, message.Call(3, u'com.example.my.proc', ['foo'])) invocation_msg = callee_messages[-1] self.assertIsInstance(invocation_msg, message.Invocation) self.assertEqual(1, len(caller_messages), "got an extra unexpected message") dealer.processYield( session, message.Yield( invocation_msg.request, args=['a result'], )) result_msg = caller_messages[-1] self.assertIsInstance(result_msg, message.Result) self.assertEqual(result_msg.args, ['a result'])