def test_from_message(self):
message = Message()
failure_message = FailureMessage.from_message(message)
assert isinstance(failure_message, FailureMessage)
assert failure_message.exception is None
assert failure_message == {
'channel': None,
'id': None,
'request': message,
'successful': False,
'exception': None,
'advice': {
'reconnect': 'none',
'interval': 0
}
}
message = Message(channel='/test', id='1')
exception = Exception()
failure_message = FailureMessage.from_message(message,
exception=exception,
successful=True)
assert isinstance(failure_message, FailureMessage)
assert failure_message == {
'channel': '/test',
'id': '1',
'request': message,
'successful': True,
'exception': exception,
'advice': {
'reconnect': 'none',
'interval': 0
}
}
def test_from_message(self):
message = Message()
failure_message = FailureMessage.from_message(message)
assert isinstance(failure_message, FailureMessage)
assert failure_message.exception is None
assert failure_message == {
'channel': None,
'id': None,
'request': message,
'successful': False,
'exception': None,
'advice': {'reconnect': 'none', 'interval': 0}
}
message = Message(channel='/test', id='1')
exception = Exception()
failure_message = FailureMessage.from_message(
message,
exception=exception,
successful=True
)
assert isinstance(failure_message, FailureMessage)
assert failure_message == {
'channel': '/test',
'id': '1',
'request': message,
'successful': True,
'exception': exception,
'advice': {'reconnect': 'none', 'interval': 0}
}
def test_fail_messages_connect(self):
self.connect_client()
mock_message_1 = Message(
channel=ChannelId.META_CONNECT,
client_id=self.client.client_id,
connection_type=self.transport.name,
advice={Message.FIELD_TIMEOUT: 0}
)
mock_message_2 = mock_message_1.copy()
exception = Exception()
with nested(
self.capture_messages(),
self.capture_timeouts()
) as (messages, timeouts):
self.client.fail_messages([mock_message_1])
self.client.fail_messages([mock_message_2], exception=exception)
self.check_failure_messages(messages, {
ChannelId.META_CONNECT: [
FailureMessage.from_message(
mock_message_1,
advice={
FailureMessage.FIELD_RECONNECT: FailureMessage.RECONNECT_RETRY,
FailureMessage.FIELD_INTERVAL: 0
}
),
FailureMessage.from_message(
mock_message_2,
exception=exception,
advice={
FailureMessage.FIELD_RECONNECT: FailureMessage.RECONNECT_RETRY,
FailureMessage.FIELD_INTERVAL: self.DEFAULT_OPTIONS['backoff_period_increment']
}
)
]
})
# Make sure a single delayed connect was scheduled
self.transport.clear_sent_messages()
assert len(timeouts) == 1
assert timeouts[0].deadline == timedelta(
milliseconds=self.DEFAULT_OPTIONS['backoff_period_increment'] * 2
)
timeouts[0].callback()
assert self.transport.sent_messages == [
self.create_sent_message(
channel=ChannelId.META_CONNECT,
connection_type=self.transport.name,
advice={
Message.FIELD_TIMEOUT: 0
}
)
]
def test_fail_messages(self):
self.connect_client()
mock_message_1 = self.mock_message.copy()
mock_message_2 = self.mock_message.copy()
exception = Exception()
with self.capture_messages() as messages:
self.client.fail_messages([])
self.client.fail_messages([mock_message_1])
self.client.fail_messages([mock_message_2], exception=exception)
self.check_failure_messages(messages, {
ChannelId.META_PUBLISH: [
FailureMessage.from_message(mock_message_1),
FailureMessage.from_message(mock_message_2, exception=exception)
]
})
def test_fail_messages_connect(self):
self.connect_client()
mock_message_1 = Message(channel=ChannelId.META_CONNECT,
client_id=self.client.client_id,
connection_type=self.transport.name,
advice={Message.FIELD_TIMEOUT: 0})
mock_message_2 = mock_message_1.copy()
exception = Exception()
with nested(self.capture_messages(),
self.capture_timeouts()) as (messages, timeouts):
self.client.fail_messages([mock_message_1])
self.client.fail_messages([mock_message_2], exception=exception)
self.check_failure_messages(
messages, {
ChannelId.META_CONNECT: [
FailureMessage.from_message(
mock_message_1,
advice={
FailureMessage.FIELD_RECONNECT:
FailureMessage.RECONNECT_RETRY,
FailureMessage.FIELD_INTERVAL: 0
}),
FailureMessage.from_message(
mock_message_2,
exception=exception,
advice={
FailureMessage.FIELD_RECONNECT:
FailureMessage.RECONNECT_RETRY,
FailureMessage.FIELD_INTERVAL:
self.DEFAULT_OPTIONS['backoff_period_increment']
})
]
})
# Make sure a single delayed connect was scheduled
self.transport.clear_sent_messages()
assert len(timeouts) == 1
assert timeouts[0].deadline == timedelta(
milliseconds=self.DEFAULT_OPTIONS['backoff_period_increment'] * 2)
timeouts[0].callback()
assert self.transport.sent_messages == [
self.create_sent_message(channel=ChannelId.META_CONNECT,
connection_type=self.transport.name,
advice={Message.FIELD_TIMEOUT: 0})
]
def test_fail_messages(self):
self.connect_client()
mock_message_1 = self.mock_message.copy()
mock_message_2 = self.mock_message.copy()
exception = Exception()
with self.capture_messages() as messages:
self.client.fail_messages([])
self.client.fail_messages([mock_message_1])
self.client.fail_messages([mock_message_2], exception=exception)
self.check_failure_messages(
messages, {
ChannelId.META_PUBLISH: [
FailureMessage.from_message(mock_message_1),
FailureMessage.from_message(mock_message_2,
exception=exception)
]
})
def _handle_handshake_failure(self, message, exception):
self.log.debug('Handling failed handshake')
self._notify_handshake_failure(FailureMessage.from_message(message,
exception=exception,
advice={
FailureMessage.FIELD_RECONNECT: FailureMessage.RECONNECT_RETRY,
FailureMessage.FIELD_INTERVAL: self._backoff_period
}
))
def test_fields(self):
exception = Exception()
message = FailureMessage(exception=exception, request={})
assert message == {
'successful': False,
'exception': exception,
'request': {},
'advice': {
'reconnect': 'none',
'interval': 0
}
}
def test_init(self):
message = FailureMessage()
assert message.failure
assert message == {
'successful': False,
'exception': None,
'advice': {
'reconnect': 'none',
'interval': 0
}
}
exception = Exception()
message = FailureMessage({'exception': exception}, successful=True)
assert not message.failure
assert message == {
'successful': True,
'exception': exception,
'advice': {
'reconnect': 'none',
'interval': 0
}
}
def test_disconnect_with_queued_messages(self):
self.client.handshake()
mock_message = self.mock_message.copy()
self.client.send(mock_message)
with self.capture_messages(only_failures=True) as messages:
self.disconnect_client()
self.check_failure_messages(messages, {
ChannelId.META_PUBLISH: [
FailureMessage.from_message(
mock_message,
exception=errors.StatusError(ClientStatus.DISCONNECTED)
)
]
})
def test_disconnect_with_queued_messages(self):
self.client.handshake()
mock_message = self.mock_message.copy()
self.client.send(mock_message)
with self.capture_messages(only_failures=True) as messages:
self.disconnect_client()
self.check_failure_messages(
messages, {
ChannelId.META_PUBLISH: [
FailureMessage.from_message(mock_message,
exception=errors.StatusError(
ClientStatus.DISCONNECTED))
]
})
def _handle_unsubscribe_failure(self, message, exception):
self.log.debug('Handling failed unsubscribe')
self._notify_unsubscribe_failure(FailureMessage.from_message(message, exception=exception))
def _handle_disconnect_failure(self, message, exception):
self.log.debug('Handling failed disconnect')
self._notify_disconnect_failure(FailureMessage.from_message(message, exception=exception))
