def test_ctor(self):
e = message.Yield(123456)
msg = e.marshal()
self.assertEqual(len(msg), 3)
self.assertEqual(msg[0], message.Yield.MESSAGE_TYPE)
self.assertEqual(msg[1], 123456)
self.assertEqual(msg[2], {})
e = message.Yield(123456,
args=[1, 2, 3],
kwargs={
u'foo': 23,
u'bar': u'hello'
})
msg = e.marshal()
self.assertEqual(len(msg), 5)
self.assertEqual(msg[0], message.Yield.MESSAGE_TYPE)
self.assertEqual(msg[1], 123456)
self.assertEqual(msg[2], {})
self.assertEqual(msg[3], [1, 2, 3])
self.assertEqual(msg[4], {u'foo': 23, u'bar': u'hello'})
e = message.Yield(123456, progress=True)
msg = e.marshal()
self.assertEqual(len(msg), 3)
self.assertEqual(msg[0], message.Yield.MESSAGE_TYPE)
self.assertEqual(msg[1], 123456)
self.assertEqual(msg[2], {u'progress': True})
def success(res):
del self._invocations[msg.request]
if isinstance(res, types.CallResult):
reply = message.Yield(msg.request, args = res.results, kwargs = res.kwresults)
else:
reply = message.Yield(msg.request, args = [res])
self._transport.send(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 success(res):
del self._invocations[msg.request]
if isinstance(res, types.CallResult):
reply = message.Yield(msg.request, args=res.results, kwargs=res.kwresults)
else:
reply = message.Yield(msg.request, args=[res])
try:
self._transport.send(reply)
except SerializationError as e:
# the application-level payload returned from the invoked procedure can't be serialized
reply = message.Error(message.Invocation.MESSAGE_TYPE, msg.request, ApplicationError.INVALID_PAYLOAD,
args=[u'success return value from invoked procedure "{0}" could not be serialized: {1}'.format(registration.procedure, e)])
self._transport.send(reply)
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_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'])
def progress(*args, **kwargs):
progress_msg = message.Yield(msg.request,
args=args,
kwargs=kwargs,
progress=True)
self._transport.send(progress_msg)
