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_to_json(self):
assert Message.to_json([]) == dumps([])
message = Message(channel='/test', id='1')
assert Message.to_json(message) == dumps([message])
messages = [
Message(channel='/test1', id='1'),
Message(channel='/test2', id='2')
]
assert Message.to_json(messages) == dumps(messages)
def test_init(self):
message = Message()
assert message == {}
message = Message({'channel': '/bad', 'id': '1'}, {'channel': '/test'})
assert message == {'channel': '/test', 'id': '1'}
message = Message(channel='/test', id='1')
assert message == {'channel': '/test', 'id': '1'}
message = Message({'channel': '/bad', 'id': '1'}, channel='/test')
assert message == {'channel': '/test', 'id': '1'}
def test_copy(self):
message = Message()
message_copy = message.copy()
assert message == message_copy
assert isinstance(message_copy, Message)
message = Message(channel='/test', id='1', ext={'ack': True})
message_copy = message.copy()
assert message == message_copy
assert isinstance(message_copy, Message)
def test_failure(self):
message = Message()
assert message.failure
message = Message(successful=True)
assert not message.failure
message = Message(successful=False)
assert message.failure
message['successful'] = True
assert not message.failure
def test_setdefault(self):
message = Message()
self.assertRaises(KeyError, message.__getitem__, 'ext')
assert message.setdefault('ext') is None
assert message['ext'] is None
message = Message()
assert message.setdefault('ext', {}) == {}
assert message['ext'] == {}
message = Message(ext={'ack': 1})
assert message.setdefault('ext', {}) == {'ack': 1}
assert message['ext'] == {'ack': 1}
def test_channel(self):
message = Message({'channel': '/test'})
assert isinstance(message.channel, ChannelId)
message = Message(channel='/test')
assert isinstance(message.channel, ChannelId)
message = Message()
message['channel'] = '/test'
assert isinstance(message.channel, ChannelId)
message = Message()
message.channel = '/test'
assert isinstance(message.channel, ChannelId)
def connect_client(self, client_id='client-1'):
self.client.handshake()
self.transport.receive([
Message(channel=ChannelId.META_HANDSHAKE,
successful=True,
client_id=client_id,
supported_connection_types=[self.transport.name],
version=Client.BAYEUX_VERSION)
])
self.transport.receive(
[Message(channel=ChannelId.META_CONNECT, successful=True)])
self.transport.clear_sent_messages()
def create_sent_message(self, *args, **kwargs):
message = Message(*args, **kwargs)
if not message.client_id and self.client.client_id:
message.client_id = self.client.client_id
if not message.id:
message.id = str(self.client.message_id)
return message
def test_send(self):
message = Message(channel='/test')
with patch.object(timestamp, 'formatdate') as mock_formatdate:
mock_formatdate.return_value = formatdate(usegmt=True)
assert self.extension.send(message) is message
mock_formatdate.assert_called_with(usegmt=True)
assert message.timestamp == mock_formatdate.return_value
def test_disconnect(self):
# Connect the client so we can disconnect
self.connect_client()
# Issue the disconnect request
self.client.disconnect()
assert self.client.status == ClientStatus.DISCONNECTING
assert len(self.transport.sent_messages) == 1
message = self.transport.sent_messages[0]
assert message == self.create_sent_message(
channel=ChannelId.META_DISCONNECT)
# Make sure we can't attempt to disconnect again during a disconnect
self.client.disconnect()
assert self.client.status == ClientStatus.DISCONNECTING
assert len(self.transport.sent_messages) == 1
# Complete the disconnect
self.transport.receive(
[Message(channel=ChannelId.META_DISCONNECT, successful=True)])
assert self.client.status == ClientStatus.DISCONNECTED
assert len(self.transport.sent_messages) == 1
assert self.client.backoff_period == 0
assert self.client.client_id is None
def test_receive_handshake(self):
message = Message(channel=ChannelId.META_HANDSHAKE)
assert self.extension.receive(message) == message
assert not self.extension.server_supports_acks
message.ext = {AckExtension.FIELD_ACK: True}
assert self.extension.receive(message) == message
assert self.extension.server_supports_acks
def test_send_connect(self):
message = Message(channel=ChannelId.META_CONNECT)
assert self.extension.send(message) == message
assert not message.ext
self.extension.receive(Message(
channel=ChannelId.META_HANDSHAKE,
ext={AckExtension.FIELD_ACK: True}
))
assert self.extension.send(message) == message
assert message.ext[AckExtension.FIELD_ACK] is None
self.extension.receive(Message(
channel=ChannelId.META_CONNECT,
successful=True,
ext={AckExtension.FIELD_ACK: 1}
))
assert self.extension.send(message) == message
assert message.ext[AckExtension.FIELD_ACK] == 1
def test_update(self):
message = Message(channel='/bad1')
assert message['channel'] == '/bad1'
message.update({'channel': '/bad2', 'id': '1'}, channel='/test')
assert message == {'channel': '/test', 'id': '1'}
self.assertRaises(TypeError, message.update, {'channel': '/bad3'},
{'id': '2'})
assert message == {'channel': '/test', 'id': '1'}
def test_send_handshake(self):
message = Message(channel=ChannelId.META_HANDSHAKE)
assert self.extension.send(message) == message
assert message.ext[AckExtension.FIELD_ACK]
assert self.extension.ack_id is None
self.client.configure(ack_enabled=False)
assert self.extension.send(message) == message
assert not message.ext[AckExtension.FIELD_ACK]
assert self.extension.ack_id is None
def test_receive_connect(self):
# Check that nothing happens when no ACK ID is included
message = Message(channel=ChannelId.META_CONNECT, successful=True)
assert self.extension.receive(message) is message
assert self.extension.ack_id is None
assert not self.extension.server_supports_acks
# Check that nothing happens when server support is unknown
message.ext = {AckExtension.FIELD_ACK: 1}
assert self.extension.receive(message) == message
assert self.extension.ack_id is None
assert not self.extension.server_supports_acks
# Notify the extension that server supports ACKs
self.extension.receive(Message(
channel=ChannelId.META_HANDSHAKE,
ext={AckExtension.FIELD_ACK: True}
))
# Check that the ACK ID is captured
assert self.extension.server_supports_acks
assert self.extension.receive(message) == message
assert self.extension.ack_id == 1
# Check that the ACK ID is ignored for failed messages
message.ext[AckExtension.FIELD_ACK] = 2
message.successful = False
assert self.extension.receive(message) == message
assert self.extension.ack_id == 1
# Check that the ACK ID is ignored if not an integer
message.ext[AckExtension.FIELD_ACK] = '2'
message.successful = True
assert self.extension.receive(message) == message
assert self.extension.ack_id == 1
# Check that updates to the ACK ID are captured
message.ext[AckExtension.FIELD_ACK] = 2
assert self.extension.receive(message) == message
assert self.extension.ack_id == 2
def subscribe(self, function, *extra_args, **extra_kwargs):
properties = None
if 'properties' in extra_kwargs:
properties = extra_kwargs.pop('properties')
if not self.has_subscriptions:
self.log.debug('Subscribe to channel "%s"' % self._channel_id)
message = Message(properties,
channel=ChannelId.META_SUBSCRIBE,
subscription=self._channel_id)
self._client.send(message)
return self._add_listener(self._subscriptions, function, extra_args,
extra_kwargs)
def unsubscribe(self, id=None, function=None, properties=None):
success = self._remove_listener(self._subscriptions,
id=id,
function=function)
if not self.has_subscriptions:
self.log.debug(
'Channel has no remaining subscriptions, sending unsubscribe')
message = Message(properties,
channel=ChannelId.META_UNSUBSCRIBE,
subscription=self._channel_id)
self._client.send(message)
return success
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_fields(self):
timestamp = formatdate(usegmt=True)
message = Message(
advice={'reconnect': 'none'},
channel='/test',
client_id='client-1',
connection_type='long-polling',
data='dummy',
error='402 Client Unauthorized',
ext={},
id='1',
interval=0,
minimum_version='0.9',
reconnect='none',
subscription='/topic',
supported_connection_types=['long-polling', 'callback-polling'],
timeout=1000,
timestamp=timestamp,
version='1.0')
assert message == {
'advice': {
'reconnect': 'none'
},
'channel': '/test',
'clientId': 'client-1',
'connectionType': 'long-polling',
'data': 'dummy',
'error': '402 Client Unauthorized',
'ext': {},
'id': '1',
'interval': 0,
'minimumVersion': '0.9',
'reconnect': 'none',
'subscription': '/topic',
'supportedConnectionTypes': ['long-polling', 'callback-polling'],
'timeout': 1000,
'timestamp': timestamp,
'version': '1.0'
}
def test_receive(self):
message = Message(channel='/test')
assert self.extension.receive(message) is message
assert message == {'channel': '/test'}
def test_receive_other(self):
message = Message(channel='/test', ext={AckExtension.FIELD_ACK: 1})
assert self.extension.receive(message) is message
assert not self.extension.server_supports_acks
assert self.extension.ack_id is None
def test_key(self):
message = Message()
self.assertRaises(KeyError, message.__getitem__, 'channel')
message['channel'] = '/test'
assert message['channel'] == '/test'
def test_bad_attribute(self):
message = Message()
self.assertRaises(AttributeError, getattr, message, 'bad_attribute')
message.bad_attribute = 'dummy'
assert message.bad_attribute == 'dummy'
assert message == {}
def test_attribute(self):
message = Message()
assert message.channel is None
message.channel = '/test'
assert message.channel == '/test'
assert message == {'channel': '/test'}
def test_disconnect_second_response(self):
self.connect_client()
self.client.disconnect()
self.transport.receive(
[Message(channel=ChannelId.META_DISCONNECT, successful=True)])
def test_to_json_with_encoding(self):
message = Message(channel='/caf\xe9', id='1')
value = dumps([message], ensure_ascii=False).encode('utf8')
assert Message.to_json(message, encoding='utf8') == value
def setUp(self):
self.client = Mock(spec_set=Client)
self.channel_id = ChannelId('/test')
self.channel = Channel(self.client, self.channel_id)
self.mock_message = Message(data='dummy')
def test_send_other(self):
message = Message(channel='/test')
assert self.extension.send(message) == message
assert message == {'channel': '/test'}
def publish(self, data, properties=None):
self.log.debug('Publishing data to channel: %s' % data)
message = Message(properties, channel=self._channel_id, data=data)
self._client.send(message)
