def test_invoke_request_id_sequences(self):
"""
make sure each session independently generates sequential IDs
"""
handler0 = ApplicationSession()
handler1 = ApplicationSession()
trans0 = MockTransport(handler0)
trans1 = MockTransport(handler1)
# the ID sequences for each session should both start at 0
# (the register) and then increment for the call()
def verify_seq_id(orig, msg):
if isinstance(msg, message.Register):
self.assertEqual(msg.request, 1)
elif isinstance(msg, message.Call):
self.assertEqual(msg.request, 2)
return orig(msg)
orig0 = trans0.send
orig1 = trans1.send
trans0.send = lambda msg: verify_seq_id(orig0, msg)
trans1.send = lambda msg: verify_seq_id(orig1, msg)
def myproc1():
return 23
yield handler0.register(myproc1, u'com.myapp.myproc1')
yield handler1.register(myproc1, u'com.myapp.myproc1')
d0 = handler0.call(u'com.myapp.myproc1')
d1 = handler1.call(u'com.myapp.myproc1')
res = yield DeferredList([d0, d1])
self.assertEqual(res, [(True, 23), (True, 23)])
def test_invoke_request_id_sequences(self):
"""
make sure each session independently generates sequential IDs
"""
handler0 = ApplicationSession()
handler1 = ApplicationSession()
trans0 = MockTransport(handler0)
trans1 = MockTransport(handler1)
# the ID sequences for each session should both start at 0
# (the register) and then increment for the call()
def verify_seq_id(orig, msg):
if isinstance(msg, message.Register):
self.assertEqual(msg.request, 0)
elif isinstance(msg, message.Call):
self.assertEqual(msg.request, 1)
return orig(msg)
orig0 = trans0.send
orig1 = trans1.send
trans0.send = lambda msg: verify_seq_id(orig0, msg)
trans1.send = lambda msg: verify_seq_id(orig1, msg)
def myproc1():
return 23
yield handler0.register(myproc1, u'com.myapp.myproc1')
yield handler1.register(myproc1, u'com.myapp.myproc1')
d0 = handler0.call(u'com.myapp.myproc1')
d1 = handler1.call(u'com.myapp.myproc1')
res = yield DeferredList([d0, d1])
self.assertEqual(res, [(True, 23), (True, 23)])
def test_register(self):
handler = ApplicationSession()
MockTransport(handler)
def on_call(*args, **kwargs):
print("got call", args, kwargs)
registration = yield handler.register(on_call, u'com.myapp.procedure1')
self.assertTrue(type(registration.id) in (int, long))
registration = yield handler.register(on_call, u'com.myapp.procedure1', options=types.RegisterOptions(match=u'prefix'))
self.assertTrue(type(registration.id) in (int, long))
def pdRegister(self, name, *args, **kwargs):
'''
Very quick and dirty RPC registration that prepends the currently set PDID
to the given method name.
Incomplete.
'''
if self.pdid is None:
raise Exception("No PDID set! Cannot register!")
ApplicationSession.register()
def test_register(self):
handler = ApplicationSession()
MockTransport(handler)
def on_call(*args, **kwargs):
print("got call", args, kwargs)
registration = yield handler.register(on_call, u'com.myapp.procedure1')
self.assertTrue(type(registration.id) in (int, long))
registration = yield handler.register(on_call, u'com.myapp.procedure1', options=types.RegisterOptions(match=u'prefix'))
self.assertTrue(type(registration.id) in (int, long))
def test_invoke_user_raises(self):
handler = ApplicationSession()
handler.traceback_app = True
MockTransport(handler)
errors = []
def log_error(e, msg):
errors.append((e.value, msg))
handler.onUserError = log_error
name_error = NameError('foo')
def bing():
raise name_error
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(bing, u'com.myapp.myproc99')
try:
yield handler.call(u'com.myapp.myproc99')
self.fail("Expected an error")
except Exception as e:
# XXX should/could we export all the builtin types?
# right now, we always get ApplicationError
# self.assertTrue(isinstance(e, NameError))
self.assertTrue(isinstance(e, RuntimeError))
# also, we should have logged the real NameError to
# Twisted.
self.assertEqual(1, len(errors))
self.assertEqual(name_error, errors[0][0])
def test_invoke_user_raises(self):
handler = ApplicationSession()
handler.traceback_app = True
MockTransport(handler)
name_error = NameError('foo')
def bing():
raise name_error
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(bing, u'com.myapp.myproc99')
try:
yield handler.call(u'com.myapp.myproc99')
self.fail("Expected an error")
except Exception as e:
# XXX should/could we export all the builtin types?
# right now, we always get ApplicationError
# self.assertTrue(isinstance(e, NameError))
self.assertTrue(isinstance(e, RuntimeError))
# also, we should have logged the real NameError to
# Twisted.
errs = self.flushLoggedErrors()
self.assertEqual(1, len(errs))
self.assertEqual(name_error, errs[0].value)
def test_invoke_progressive_result(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(details=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
for i in range(10):
details.progress(i)
yield succeed(i)
returnValue(42)
progressive = list(map(lambda _: Deferred(), range(10)))
def progress(arg):
progressive[arg].callback(arg)
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
options=types.CallOptions(on_progress=progress),
)
self.assertEqual(42, res)
# make sure we got *all* our progressive results
for i in range(10):
self.assertTrue(progressive[i].called)
self.assertEqual(i, progressive[i].result)
def test_invoke_progressive_result(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(details=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
for i in range(10):
details.progress(i)
yield succeed(i)
returnValue(42)
progressive = list(map(lambda _: Deferred(), range(10)))
def progress(arg):
progressive[arg].callback(arg)
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
options=types.CallOptions(on_progress=progress),
)
self.assertEqual(42, res)
# make sure we got *all* our progressive results
for i in range(10):
self.assertTrue(progressive[i].called)
self.assertEqual(i, progressive[i].result)
def test_invoke_progressive_result_just_kwargs(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(details=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
details.progress(key='word')
yield succeed(True)
returnValue(42)
got_progress = Deferred()
def progress(key=None):
got_progress.callback(key)
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
options=types.CallOptions(on_progress=progress),
)
self.assertEqual(42, res)
self.assertTrue(got_progress.called)
self.assertEqual('word', got_progress.result)
def test_invoke_progressive_result_just_kwargs(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(details=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
details.progress(key='word')
yield succeed(True)
returnValue(42)
got_progress = Deferred()
def progress(key=None):
got_progress.callback(key)
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
options=types.CallOptions(on_progress=progress),
)
self.assertEqual(42, res)
self.assertTrue(got_progress.called)
self.assertEqual('word', got_progress.result)
def test_unregister(self):
handler = ApplicationSession()
MockTransport(handler)
def on_call(*args, **kwargs):
print("got call", args, kwargs)
registration = yield handler.register(on_call, u'com.myapp.procedure1')
yield registration.unregister()
def test_unregister(self):
handler = ApplicationSession()
MockTransport(handler)
def on_call(*args, **kwargs):
print("got call", args, kwargs)
registration = yield handler.register(on_call, u'com.myapp.procedure1')
yield registration.unregister()
def test_unregister_log(self):
handler = ApplicationSession()
transport = MockTransport(handler)
def on_call(*args, **kwargs):
on_call.called = True
on_call.called = False
registration = yield handler.register(on_call, u'com.myapp.procedure1')
transport.drop_registration(registration.id)
self.assertFalse(on_call.called)
def register(self, endpoint, procedure=None, options=None):
# options = RegisterOptions(details_arg='session')
procedure = _prepend(self.pdid, procedure)
out.info('cxbr: (%s) register (%s)' % (
self.pdid,
procedure,
))
return ApplicationSession.register(self,
endpoint,
procedure=procedure,
options=options)
def test_unregister_log(self):
handler = ApplicationSession()
transport = MockTransport(handler)
def on_call(*args, **kwargs):
on_call.called = True
on_call.called = False
registration = yield handler.register(on_call, 'com.myapp.procedure1')
transport.drop_registration(registration.id)
self.assertFalse(on_call.called)
def test_invoke(self):
handler = ApplicationSession()
MockTransport(handler)
def myproc1():
return 23
yield handler.register(myproc1, u'com.myapp.myproc1')
res = yield handler.call(u'com.myapp.myproc1')
self.assertEqual(res, 23)
def test_invoke(self):
handler = ApplicationSession()
MockTransport(handler)
def myproc1():
return 23
yield handler.register(myproc1, u'com.myapp.myproc1')
res = yield handler.call(u'com.myapp.myproc1')
self.assertEqual(res, 23)
def test_invoke_twice(self):
handler = ApplicationSession()
MockTransport(handler)
def myproc1():
return 23
yield handler.register(myproc1, u'com.myapp.myproc1')
d0 = handler.call(u'com.myapp.myproc1')
d1 = handler.call(u'com.myapp.myproc1')
res = yield DeferredList([d0, d1])
self.assertEqual(res, [(True, 23), (True, 23)])
def test_invoke_twice(self):
handler = ApplicationSession()
MockTransport(handler)
def myproc1():
return 23
yield handler.register(myproc1, u'com.myapp.myproc1')
d0 = handler.call(u'com.myapp.myproc1')
d1 = handler.call(u'com.myapp.myproc1')
res = yield DeferredList([d0, d1])
self.assertEqual(res, [(True, 23), (True, 23)])
def test_invoke_progressive_result_error(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(arg, details=None, key=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
self.assertEqual(key, 'word')
self.assertEqual('arg', arg)
details.progress('life', something='nothing')
yield succeed('meaning of')
returnValue(42)
got_progress = Deferred()
progress_error = NameError('foo')
logged_errors = []
def got_error(e, msg):
logged_errors.append((e.value, msg))
handler.onUserError = got_error
def progress(arg, something=None):
self.assertEqual('nothing', something)
got_progress.callback(arg)
raise progress_error
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
'arg',
options=types.CallOptions(on_progress=progress),
key='word',
)
self.assertEqual(42, res)
# our progress handler raised an error, but not before
# recording success.
self.assertTrue(got_progress.called)
self.assertEqual('life', got_progress.result)
# make sure our progress-handler error was logged
self.assertEqual(1, len(logged_errors))
self.assertEqual(progress_error, logged_errors[0][0])
def test_invoke_progressive_result_error(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(arg, details=None, key=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
self.assertEqual(key, 'word')
self.assertEqual('arg', arg)
details.progress('life', something='nothing')
yield succeed('meaning of')
returnValue(42)
got_progress = Deferred()
progress_error = NameError('foo')
logged_errors = []
def got_error(e, msg):
logged_errors.append((e.value, msg))
handler.onUserError = got_error
def progress(arg, something=None):
self.assertEqual('nothing', something)
got_progress.callback(arg)
raise progress_error
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(
bing,
u'com.myapp.myproc2',
types.RegisterOptions(details_arg='details'),
)
res = yield handler.call(
u'com.myapp.myproc2',
'arg',
options=types.CallOptions(on_progress=progress),
key='word',
)
self.assertEqual(42, res)
# our progress handler raised an error, but not before
# recording success.
self.assertTrue(got_progress.called)
self.assertEqual('life', got_progress.result)
# make sure our progress-handler error was logged
self.assertEqual(1, len(logged_errors))
self.assertEqual(progress_error, logged_errors[0][0])
def test_call_exception_bare(self):
handler = ApplicationSession()
MockTransport(handler)
exception = Exception()
def raiser():
raise exception
registration0 = yield handler.register(raiser, "com.myapp.myproc_error")
try:
yield handler.call('com.myapp.myproc_error')
self.fail()
except Exception as e:
self.assertIsInstance(e, ApplicationError)
finally:
yield registration0.unregister()
def test_call_exception_bare(self):
handler = ApplicationSession()
MockTransport(handler)
exception = Exception()
def raiser():
raise exception
registration0 = yield handler.register(raiser, u"com.myapp.myproc_error")
try:
yield handler.call(u'com.myapp.myproc_error')
self.fail()
except Exception as e:
self.assertIsInstance(e, ApplicationError)
finally:
yield registration0.unregister()
def test_call_exception_runtimeerror(self):
handler = ApplicationSession()
MockTransport(handler)
exception = RuntimeError("a simple error")
def raiser():
raise exception
registration0 = yield handler.register(raiser, "com.myapp.myproc_error")
try:
yield handler.call('com.myapp.myproc_error')
self.fail()
except Exception as e:
self.assertIsInstance(e, ApplicationError)
self.assertEqual(e.error_message(), "wamp.error.runtime_error: a simple error")
finally:
yield registration0.unregister()
def test_call_exception_runtimeerror(self):
handler = ApplicationSession()
MockTransport(handler)
exception = RuntimeError("a simple error")
def raiser():
raise exception
registration0 = yield handler.register(raiser, u"com.myapp.myproc_error")
try:
yield handler.call(u'com.myapp.myproc_error')
self.fail()
except Exception as e:
self.assertIsInstance(e, ApplicationError)
self.assertEqual(e.error_message(), "wamp.error.runtime_error: a simple error")
finally:
yield registration0.unregister()
def test_invoke_progressive_result_no_args(self):
handler = ApplicationSession()
MockTransport(handler)
@inlineCallbacks
def bing(details=None):
self.assertTrue(details is not None)
self.assertTrue(details.progress is not None)
details.progress()
yield succeed(True)
returnValue(42)
got_progress = Deferred()
def progress():
got_progress.callback("intentionally left blank")
# see MockTransport, must start with "com.myapp.myproc"
yield handler.register(bing, u"com.myapp.myproc2", types.RegisterOptions(details_arg="details"))
res = yield handler.call(u"com.myapp.myproc2", options=types.CallOptions(on_progress=progress))
self.assertEqual(42, res)
self.assertTrue(got_progress.called)
def stockRegister(self, endpoint, procedure=None, options=None):
out.info('cxbr: (%s) registering (%s)' % (self.pdid, procedure,))
return ApplicationSession.register(self, endpoint, procedure=procedure, options=options)
def stockRegister(self, endpoint, procedure=None, options=None):
return ApplicationSession.register(self, endpoint, procedure=u''+procedure, options=options)
def stockRegister(self, endpoint, procedure=None, options=None):
return ApplicationSession.register(self,
endpoint,
procedure=u'' + procedure,
options=options)
def register(self, endpoint, procedure=None, options=None):
# options = RegisterOptions(details_arg='session')
procedure = _prepend(self.pdid, procedure)
#out.info('riff: (%s) register (%s)' % (self.pdid, procedure,))
return ApplicationSession.register(self, endpoint, procedure=procedure, options=options)
def absRegister(self, endpoint, procedure=None, options=None):
#out.info('riff: (%s) registering (%s)' % (self.pdid, procedure,))
return ApplicationSession.register(self, endpoint, procedure=u'' + procedure, options=options)
