def test_router_session_goodbye_fire_disconnect_error(self):
"""
Reason should be propagated properly from Goodbye message
"""
from crossbar.router.session import RouterApplicationSession
session = mock.Mock()
the_exception = RuntimeError("sad times at ridgemont high")
def boom(*args, **kw):
if args[0] == 'disconnect':
return defer.fail(the_exception)
return defer.succeed(None)
session.fire = mock.Mock(side_effect=boom)
session._realm = u'realm'
router_factory = mock.Mock()
rap = RouterApplicationSession(session, router_factory)
rap.send(
message.Hello(u'realm', {u'caller': role.RoleCallerFeatures()}))
session.reset_mock()
rap.send(message.Goodbye(u'wamp.reason.logout',
u'some custom message'))
errors = self.flushLoggedErrors()
self.assertEqual(1, len(errors))
self.assertEqual(the_exception, errors[0].value)
def test_router_session_internal_error_onHello(self):
"""
similar to above, but during _RouterSession's onMessage handling,
where it calls self.onHello
"""
# setup
transport = mock.MagicMock()
transport.get_channel_id = mock.MagicMock(return_value=b'deadbeef')
the_exception = RuntimeError("kerblam")
def boom(*args, **kw):
raise the_exception
session = self.session_factory() # __call__ on the _RouterSessionFactory
session.onHello = boom
session.onOpen(transport)
msg = message.Hello(u'realm1', dict(caller=role.RoleCallerFeatures()))
# XXX think: why isn't this using _RouterSession.log?
from crossbar.router.session import RouterSession
with mock.patch.object(RouterSession, 'log') as logger:
# do the test; should call onHello which is now "boom", above
session.onMessage(msg)
# check we got the right log.failure() call
self.assertTrue(len(logger.method_calls) > 0)
call = logger.method_calls[0]
# for a MagicMock call-object, 0th thing is the method-name, 1st
# thing is the arg-tuple, 2nd thing is the kwargs.
self.assertEqual(call[0], 'failure')
self.assertTrue('failure' in call[2])
self.assertEqual(call[2]['failure'].value, the_exception)
def test_router_session_lifecycle(self):
"""
We see all 'lifecycle' notifications.
"""
from crossbar.router.session import RouterApplicationSession
def mock_fire(name, *args, **kw):
fired.append(name)
return defer.succeed(None)
fired = []
session = mock.Mock()
session._realm = u'realm'
session.fire = mock.Mock(side_effect=mock_fire)
router_factory = mock.Mock()
rap = RouterApplicationSession(session, router_factory)
# we never fake out the 'Welcome' message, so there will be no
# 'ready' notification...
rap.send(
message.Hello(u'realm', {u'caller': role.RoleCallerFeatures()}))
rap.send(message.Goodbye(u'wamp.reason.logout',
u'some custom message'))
self.assertTrue('connect' in fired)
self.assertTrue('join' in fired)
self.assertTrue('ready' in fired)
self.assertTrue('leave' in fired)
self.assertTrue('disconnect' in fired)
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 test_router_session_goodbye_onLeave_error(self):
"""
Reason should be propagated properly from Goodbye message
"""
from crossbar.router.session import RouterApplicationSession
session = mock.Mock()
the_exception = RuntimeError("onLeave fails")
def boom(*args, **kw):
raise the_exception
session.onLeave = mock.Mock(side_effect=boom)
session._realm = u'realm'
router_factory = mock.Mock()
rap = RouterApplicationSession(session, router_factory)
rap.send(
message.Hello(u'realm', {u'caller': role.RoleCallerFeatures()}))
session.reset_mock()
rap.send(message.Goodbye(u'wamp.reason.logout',
u'some custom message'))
errors = self.flushLoggedErrors()
self.assertEqual(1, len(errors))
self.assertEqual(the_exception, errors[0].value)
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_router_session_goodbye_custom_message(self):
"""
Reason should be propagated properly from Goodbye message
"""
from crossbar.router.session import RouterApplicationSession
session = mock.Mock()
session._realm = u'realm'
router_factory = mock.Mock()
rap = RouterApplicationSession(session, router_factory)
rap.send(message.Hello(u'realm', {u'caller': role.RoleCallerFeatures()}))
session.reset_mock()
rap.send(message.Goodbye(u'wamp.reason.logout', u'some custom message'))
leaves = [call for call in session.mock_calls if call[0] == 'onLeave']
self.assertEqual(1, len(leaves))
details = leaves[0][1][0]
self.assertEqual(u'wamp.reason.logout', details.reason)
self.assertEqual(u'some custom message', details.message)
def join(self, realm, authmethods = None, authid = None):
"""
Implements :func:`autobahn.wamp.interfaces.ISession.join`
"""
if six.PY2 and type(realm) == str:
realm = six.u(realm)
if self._session_id:
raise Exception("already joined")
self._goodbye_sent = False
roles = [
role.RolePublisherFeatures(),
role.RoleSubscriberFeatures(),
role.RoleCallerFeatures(),
role.RoleCalleeFeatures()
]
msg = message.Hello(realm, roles, authmethods, authid)
self._realm = realm
self._transport.send(msg)
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 send(msg):
bytes, _ = serializer.serialize(msg)
l = struct.pack("!I", len(bytes))
sys.stdout.write(l)
sys.stdout.write(bytes)
msgs = []
## HELLO
##
roles = [
role.RolePublisherFeatures(),
role.RoleSubscriberFeatures(),
role.RoleCallerFeatures(),
role.RoleCalleeFeatures()
]
msgs.append(message.Hello("foobar", roles))
## CHALLENGE
##
msgs.append(message.Challenge("cookie"))
## HEARTBEAT
##
msgs.append(message.Heartbeat(3, 7, "throw me away"))
for msg in msgs:
send(msg)
