def test_message_get_channel(self):
class FakeClass(object):
pass
message = Message(body='', channel=FakeClass())
self.assertIsInstance(message.channel, FakeClass)
def test_message_auto_decode_when_method_contains_list(self):
method_data = {'key': [b'a', b'b']}
message = Message(body=self.message, method=method_data, channel=None)
self.assertEqual(method_data['key'][0].decode('utf-8'),
message.method['key'][0])
def test_message_auto_decode_cache(self):
body = 'Hello World',
message = Message(body=body, channel=None)
self.assertEqual(body, message.body)
message._body = 'invalidate'
self.assertEqual(body, message.body)
def test_message_json(self):
body = '{"key": "value"}'
message = Message(body=body, channel=None)
result = message.json()
self.assertIsInstance(result, dict)
self.assertEqual(result['key'], 'value')
def test_message_auto_decode_when_method_is_tuple(self):
method_data = (1, 2, 3, 4, 5)
message = Message(body=self.message, method=method_data, channel=None)
self.assertEqual(method_data, message.method)
self.assertEqual(method_data[0], message.method[0])
self.assertEqual(method_data[4], message.method[4])
def test_message_auto_decode_when_properties_contains_dict(self):
prop_data = {'hello': b'travis'}
message = Message(body=self.message,
properties={'key': prop_data},
channel=None)
self.assertIsInstance(message.properties['key'], dict)
self.assertEqual(prop_data['hello'].decode('utf-8'),
message.properties['key']['hello'])
def test_message_auto_decode_when_properties_contains_tuple(self):
prop_data = (b'travis', 2, 3, 4, 5)
message = Message(body=self.message,
properties={'key': prop_data},
channel=None)
self.assertIsInstance(message.properties['key'], tuple)
self.assertEqual(prop_data[0].decode('utf-8'),
message.properties['key'][0])
self.assertEqual(prop_data[4], message.properties['key'][4])
def test_message_auto_decode_when_properties_contains_list(self):
prop_data = [b'travis', 2, 3, 4, 5]
message = Message(body='Hello World',
properties={'key': prop_data},
channel=None)
self.assertIsInstance(message.properties['key'], list)
self.assertEqual(prop_data[0].decode('utf-8'),
message.properties['key'][0])
self.assertEqual(prop_data[4], message.properties['key'][4])
def test_message_to_tuple(self):
body = self.message
message = Message(body=body,
properties={'key': 'value'},
method={'key': 'value'},
channel=None)
body, channel, method, properties = message.to_tuple()
self.assertEqual(body, body)
self.assertIsInstance(method, dict)
self.assertIsInstance(properties, dict)
self.assertIsNone(channel)
def test_message_auto_decode_enabled(self):
message = Message(body=self.message,
properties={
'key': 'value',
'headers': {
b'name': b'eandersson'
}
},
channel=None)
self.assertEqual(self.message, message.body)
self.assertIn('name', message.properties['headers'])
self.assertIn(b'name', message._properties['headers'])
self.assertIsInstance(message.properties['headers']['name'], str)
def test_message_to_dict(self):
body = self.message
properties = {'key': 'value'}
method = {b'alternative': 'value'}
message = Message(body=body,
properties=properties,
method=method,
channel=None)
result = message.to_dict()
self.assertIsInstance(result, dict)
self.assertEqual(result['body'], body)
self.assertEqual(result['properties'], properties)
self.assertEqual(result['method'], method)
def test_message_auto_decode_disabled(self):
body = self.message
message = Message(body=body,
properties={
'key': 'value',
'headers': {
b'name': b'eandersson'
}
},
channel=None,
auto_decode=False)
self.assertEqual(body, message.body)
self.assertIn(b'name', message.properties['headers'])
self.assertIsInstance(message.properties['headers'][b'name'], bytes)
def test_message_update_property_with_decode(self):
message = Message(None, auto_decode=True)
message._update_properties('app_id', '123')
self.assertEqual(message.properties['app_id'], '123')
self.assertEqual(message._properties['app_id'], '123')
def test_message_auto_decode_when_method_is_none(self):
message = Message(body=self.message, method=None, channel=None)
self.assertIsNone(message.method)
def test_message_auto_decode_cache(self):
message = Message(body=self.message, channel=None)
self.assertEqual(self.message, message.body)
message._body = 'invalidate'
self.assertEqual(self.message, message.body)
