def test_message_timeout_1(self):
""" Test if a response message to a request results in the handler being called correctly.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
req = chan.request('name', 'payload')
handler = Mock()
req.add_handler(handler, MessageStatus.ANY)
reqi = req.send()
conn.mock_downstream_verb(verbs.MessageVerb(
messageref=1,
status=verbs.MessageVerb.STATUS_TIMEOUT,
payload=b'response'
))
self.__verify_handler_call(
handler,
Message,
status=MessageStatus.TIMEOUT,
payload=None,
source=reqi,
)
def test_interest_2(self):
""" Test if the sessions interest handler is called when an interest packet is received.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
session = chan.session('name')
handler = Mock()
session.add_interest_handler(handler)
conn.mock_downstream_verb(verbs.InterestVerb(
postref=1,
name=b'name',
status=verbs.InterestVerb.STATUS_NO_INTEREST,
topic=b'topic'
))
self.__verify_handler_call(
handler,
Interest,
status=InterestStatus.NO_INTEREST,
name='name',
topic='topic',
source=session,
)
def test_subscribe_unsubscribe_1(self):
""" Test if both an subscribe and unsubscribe verb is pushed when the
connection is ready before creation of the subscription.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
sub = chan.subscribe('name', 'topic')
conn.assert_upstream_verb(verbs.SubscribeVerb(
name=b'name',
topic=b'topic',
messageref=1,
))
sub.cancel()
conn.assert_upstream_verb(verbs.UnsubscribeVerb(
name=b'name',
topic=b'topic',
))
conn.assert_upstream_verb(None)
def test_login_logout_2(self):
""" Test if both the login and logout verb are pushed when the connection becomes ready
after the session is created.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(False)
session = chan.session('name')
conn.mock_connection_ready(True)
conn.assert_upstream_verb(verbs.LoginVerb(
name=b'name',
enforce=False,
standby=False,
persist=False,
))
session.cancel()
conn.assert_upstream_verb(verbs.LogoutVerb(
name=b'name',
))
conn.assert_upstream_verb(None)
def test_call_1(self):
""" Test if the sessions call handler is called when an unidirectional call packet is
received.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
session = chan.session('name')
handler = Mock()
session.add_call_handler(handler)
conn.mock_downstream_verb(verbs.CallVerb(
unidirectional=False,
postref=1,
name=b'name',
payload=b'payload',
))
self.__verify_handler_call(
handler,
Call,
unidirectional=False,
name='name',
postref=1,
payload='payload',
)
def test_backlog_no_ttl(self):
""" Test if the backlog discards requests with no ttl at all.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(False)
chan.request('name', 'payload0').send(ttl=0)
chan.request('name', 'payload1').send(ttl=4.0)
chan.request('name', 'payload2').send(ttl=0)
chan.request('name', 'payload3').send(ttl=4.0)
conn.mock_connection_ready(True)
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload1'
))
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload3'
))
def test_subscribe_unsubscribe_2(self):
""" Test if subscribe and unusbscribe verbs is pushed even when the connection only
becomes ready after the subscription is created.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(False)
sub = chan.subscribe('name', 'topic')
conn.mock_connection_ready(True)
conn.assert_upstream_verb(verbs.SubscribeVerb(
name=b'name',
topic=b'topic',
messageref=1,
))
sub.cancel()
conn.assert_upstream_verb(verbs.UnsubscribeVerb(
name=b'name',
topic=b'topic',
))
conn.assert_upstream_verb(None)
def test_post_4(self):
""" Test if a post is discarded when connection becomes ready after the ttl is expired.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(False)
with patch_time() as time:
chan.request('name', 'payload').send(ttl=5.0)
time.sleep(5.001)
conn.mock_connection_ready(True)
conn.assert_upstream_verb(None)
def test_subscribe_unsubscribe_3(self):
""" Test if no verbs at all are pushed if the subscription is created and canceled before
the connection was ready.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(False)
sub = chan.subscribe('name', 'topic')
sub.cancel()
conn.mock_connection_ready(True)
conn.assert_upstream_verb(None)
def test_login_logout_3(self):
""" Test if no verbs are pushed at all if the session is created and canceled before the
connection became ready.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(False)
session = chan.session('name')
session.cancel()
conn.mock_connection_ready(True)
conn.assert_upstream_verb(None)
def test_session_verb_logging_3(self):
conn = MockedConnection()
chan = Channel(conn)
with self.assertLogs(channel.logger, level='INFO'):
conn.mock_downstream_verb(verbs.SessionVerb(
name=b'name',
state=verbs.SessionVerb.STATE_ENDED,
))
def test_request_1(self):
""" Test if a request verb is pushed when the connection is ready immediately.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
chan.request('name', 'payload').send()
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload'
))
def test_request_2(self):
""" Test if the pushed request verb is unidirectional and has no messageref when no
handlers were set.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
req = chan.request('name', 'payload')
req.send()
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload'
))
def test_request_3(self):
""" Test if the pushed request verb is directional and has a messsageref when a handler
is set.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
req = chan.request('name', 'payload')
req.add_handler(Mock())
req.send()
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=False,
messageref=1,
timeout=5.0,
payload=b'payload'
))
def create_channel(uri, loop=None):
""" Creates Channel instance based on the given uri.
If no mainloop is given a new Mainloop will be created.
Returns a (mainloop, channel) tuple.
"""
if not loop:
loop = Mainloop()
connection = create_connection(loop, uri)
chan = Channel(connection)
return loop, chan
def test_backlog_different_ttls(self):
""" Test if the backlog discards requests whos ttl have expired but keeps
others.
"""
conn = MockedConnection()
chan = Channel(conn)
with patch_time() as time:
conn.mock_connection_ready(False)
chan.request('name', 'payload0').send(ttl=2.0)
chan.request('name', 'payload1').send(ttl=4.0)
chan.request('name', 'payload2').send(ttl=2.0)
chan.request('name', 'payload3').send(ttl=4.0)
time.sleep(3.0)
conn.mock_connection_ready(True)
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload1'
))
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload3'
))
def test_subscribe_message_1(self):
""" Test that the handler is called when a message is received for a subscription.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
handler = unittest.mock.Mock()
sub = chan.subscribe('name', 'topic')
sub.add_handler(handler)
conn.mock_downstream_verb(verbs.MessageVerb(
messageref=1,
status=verbs.MessageVerb.STATUS_OK,
payload=b'payload1',
))
self.__verify_handler_call(
handler,
Message,
status=MessageStatus.OK,
payload='payload1',
)
conn.mock_downstream_verb(verbs.MessageVerb(
messageref=1,
status=verbs.MessageVerb.STATUS_OK,
payload=b'payload2',
))
self.__verify_handler_call(
handler,
Message,
status=MessageStatus.OK,
payload='payload2',
)
def test_interest_connection_lost_1(self):
""" Test if the interest is lost when the connection is lost.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
session = chan.session('name')
handler = Mock()
session.add_interest_handler(handler)
conn.mock_downstream_verb(verbs.InterestVerb(
postref=1,
name=b'name',
status=verbs.InterestVerb.STATUS_INTEREST,
topic=b'topic'
))
self.__verify_handler_call(
handler,
Interest,
status=InterestStatus.INTEREST,
topic='topic',
source=session,
)
conn.mock_connection_ready(False)
self.__verify_handler_call(
handler,
Interest,
status=InterestStatus.NO_INTEREST,
topic='topic',
source=session,
)
def test_request_4(self):
""" Test if a request is still pushed when the connection becomes ready just before
the ttl is expires.
"""
conn = MockedConnection()
chan = Channel(conn)
with patch_time() as time:
conn.mock_connection_ready(False)
chan.request('name', 'payload').send(ttl=5.0)
time.sleep(4.999)
conn.mock_connection_ready(True)
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload'
))
def test_post_1(self):
""" Test if a post verb is pushed when posted and connection was ready.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(True)
post = Post(chan.core, postref=1, payload='payload', ttl=5.0)
conn.assert_upstream_verb(verbs.PostVerb(
postref=1,
payload=b'payload',
))
def test_call_post_warning(self):
""" Test if a warning is logged when a post is attempted on an unidirectional call.
"""
conn = MockedConnection()
chan = Channel(conn)
verb = verbs.CallVerb(
unidirectional=True,
postref=None,
name=b'name',
payload=b'payload'
)
call = Call(chan.core, verb, None)
with self.assertLogs(channel.logger, level='WARNING'):
call.post('payload')
def test_interest_post_warning(self):
""" Test if a warning is logged when a post is attempted on a lost interest.
"""
conn = MockedConnection()
chan = Channel(conn)
verb = verbs.InterestVerb(
postref=1,
name=b'name',
status=verbs.InterestVerb.STATUS_NO_INTEREST,
topic=b'topic',
)
interest = Interest(chan.core, verb, None)
with self.assertLogs(channel.logger, level='WARNING'):
interest.post('payload')
def test_post_3(self):
""" Test if a post is still pushed when the connection becomes ready just before
the ttl is expires.
"""
conn = MockedConnection()
chan = Channel(conn)
with patch_time() as time:
conn.mock_connection_ready(False)
post = Post(chan.core, postref=1, payload='payload', ttl=5.0)
time.sleep(4.999)
conn.mock_connection_ready(True)
conn.assert_upstream_verb(verbs.PostVerb(
postref=1,
payload=b'payload',
))
def test_backlog_order(self):
""" Test if the order of requests is preserved when queued in the backlog.
"""
conn = MockedConnection()
chan = Channel(conn)
conn.mock_connection_ready(False)
chan.request('name', 'payload0').send(ttl=5.0)
chan.request('name', 'payload1').send(ttl=5.0)
chan.request('name', 'payload2').send(ttl=5.0)
conn.mock_connection_ready(True)
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload0'
))
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload1'
))
conn.assert_upstream_verb(verbs.RequestVerb(
name=b'name',
unidirectional=True,
messageref=None,
timeout=5.0,
payload=b'payload2'
))
