def test_message_body_value_type():
string_value = b'!@#$%^&*()_+1234567890'
string_value_message = Message(body=string_value,
body_type=MessageBodyType.Value)
assert string_value_message.get_data() == string_value
assert isinstance(string_value_message._body, ValueBody)
assert str(string_value_message)
float_value = 1.23
float_value_message = Message(body=float_value,
body_type=MessageBodyType.Value)
assert float_value_message.get_data() == float_value
assert isinstance(string_value_message._body, ValueBody)
assert str(float_value_message)
dict_value = {b"key1 ": b"value1", b'key2': -1, b'key3': False}
dict_value_message = Message(body=dict_value,
body_type=MessageBodyType.Value)
assert dict_value_message.get_data() == dict_value
assert isinstance(string_value_message._body, ValueBody)
assert str(dict_value_message)
compound_list_value = [
1, b'abc', True, [1.23, b'abc', False], {
b"key1 ": b"value1",
b'key2': -1
}
]
compound_list_value_message = Message(body=compound_list_value,
body_type=MessageBodyType.Value)
assert compound_list_value_message.get_data() == compound_list_value
assert isinstance(string_value_message._body, ValueBody)
assert str(compound_list_value_message)
def test_message_body_data_type():
single_data = b'!@#$%^&*()_+1234567890'
single_data_message = Message(body=single_data,
body_type=MessageBodyType.Data)
check_list = [data for data in single_data_message.get_data()]
assert isinstance(single_data_message._body, DataBody)
assert len(check_list) == 1
assert check_list[0] == single_data
assert str(single_data_message)
multiple_data = [
b'!@#$%^&*()_+1234567890',
'abcdefg~123',
]
multiple_data_message = Message(body=multiple_data,
body_type=MessageBodyType.Data)
check_list = [data for data in multiple_data_message.get_data()]
assert isinstance(multiple_data_message._body, DataBody)
assert len(check_list) == 2
assert check_list[0] == multiple_data[0]
assert check_list[1] == multiple_data[1].encode("UTF-8")
assert str(multiple_data_message)
with pytest.raises(TypeError):
Message(body={"key": "value"}, body_type=MessageBodyType.Data)
with pytest.raises(TypeError):
Message(body=1, body_type=MessageBodyType.Data)
with pytest.raises(TypeError):
Message(body=['abc', True], body_type=MessageBodyType.Data)
with pytest.raises(TypeError):
Message(body=True, body_type=MessageBodyType.Data)
def _parse_payload(self, message: Message, origin_device_id, content_type,
create_payload_error):
payload = ""
data = message.get_data()
if data:
payload = str(next(data), "utf8")
if create_payload_error:
payload = "Some Random Payload"
if "application/json" not in content_type.lower():
self._warnings.append("Content type not supported. "
"Content type found: {}. "
"Content type expected: application/json. "
"DeviceId: {}".format(
content_type, origin_device_id))
else:
try:
payload = json.loads(
re.compile(r"(\\r\\n)+|\\r+|\\n+").sub("", payload))
except Exception:
self._errors.append("Invalid JSON format. "
"DeviceId: {}, Raw payload {}".format(
origin_device_id, payload))
return payload
def _parse_payload(self, message: Message, content_type):
payload = ""
data = message.get_data()
if data:
payload = str(next(data), "utf8")
if "application/json" in content_type.lower():
return self._try_parse_json(payload)
return payload
def test_message_auto_body_type():
single_data = b'!@#$%^&*()_+1234567890'
single_data_message = Message(body=single_data)
check_list = [data for data in single_data_message.get_data()]
assert isinstance(single_data_message._body, DataBody)
assert len(check_list) == 1
assert check_list[0] == single_data
assert (str(single_data_message))
multiple_data = [b'!@#$%^&*()_+1234567890', 'abcdefg~123']
multiple_data_message = Message(body=multiple_data)
check_list = [data for data in multiple_data_message.get_data()]
assert isinstance(multiple_data_message._body, DataBody)
assert len(check_list) == 2
assert check_list[0] == multiple_data[0]
assert check_list[1] == multiple_data[1].encode("UTF-8")
assert (str(multiple_data_message))
list_mixed_body = [b'!@#$%^&*()_+1234567890', 'abcdefg~123', False, 1.23]
list_mixed_body_message = Message(body=list_mixed_body)
check_data = list_mixed_body_message.get_data()
assert isinstance(list_mixed_body_message._body, ValueBody)
assert isinstance(check_data, list)
assert len(check_data) == 4
assert check_data[0] == list_mixed_body[0]
assert check_data[1] == list_mixed_body[1].encode("UTF-8")
assert check_data[2] == list_mixed_body[2]
assert check_data[3] == list_mixed_body[3]
assert (str(list_mixed_body_message))
dic_mixed_body = {b'key1': b'value', b'key2': False, b'key3': -1.23}
dic_mixed_body_message = Message(body=dic_mixed_body)
check_data = dic_mixed_body_message.get_data()
assert isinstance(dic_mixed_body_message._body, ValueBody)
assert isinstance(check_data, dict)
assert len(check_data) == 3
assert check_data == dic_mixed_body
assert (str(dic_mixed_body_message))
def test_message_body_sequence_type():
single_list = [
1, 2, b'aa', b'bb', True, b"abc", {
b"key1": b"value",
b"key2": -1.23
}
]
single_list_message = Message(body=single_list,
body_type=MessageBodyType.Sequence)
check_list = [data for data in single_list_message.get_data()]
assert isinstance(single_list_message._body, SequenceBody)
assert len(check_list) == 1
assert check_list[0] == single_list
assert str(single_list_message)
multiple_lists = [[1, 2, 3, 4], [b'aa', b'bb', b'cc', b'dd']]
multiple_lists_message = Message(body=multiple_lists,
body_type=MessageBodyType.Sequence)
check_list = [data for data in multiple_lists_message.get_data()]
assert isinstance(multiple_lists_message._body, SequenceBody)
assert len(check_list) == 2
assert check_list[0] == multiple_lists[0]
assert check_list[1] == multiple_lists[1]
assert str(multiple_lists_message)
with pytest.raises(TypeError):
Message(body={"key": "value"}, body_type=MessageBodyType.Sequence)
with pytest.raises(TypeError):
Message(body=1, body_type=MessageBodyType.Sequence)
with pytest.raises(TypeError):
Message(body='a', body_type=MessageBodyType.Sequence)
with pytest.raises(TypeError):
Message(body=True, body_type=MessageBodyType.Sequence)
def test_message_pickle():
properties = MessageProperties()
properties.message_id = '2'
properties.user_id = '1'
properties.to = 'dkfj'
properties.subject = 'dsljv'
properties.reply_to = "kdjfk"
properties.correlation_id = 'ienag'
properties.content_type = 'b'
properties.content_encoding = '39ru'
properties.absolute_expiry_time = 24
properties.creation_time = 10
properties.group_id = '3irow'
properties.group_sequence = 39
properties.reply_to_group_id = '39rud'
header = MessageHeader()
header.delivery_count = 3
header.time_to_live = 5
header.first_acquirer = 'dkfj'
header.durable = True
header.priority = 4
data_message = Message(body=[b'testmessage1', b'testmessage2'])
pickled = pickle.loads(pickle.dumps(data_message))
body = list(pickled.get_data())
assert len(body) == 2
assert body == [b'testmessage1', b'testmessage2']
sequence_message = Message(body=[[1234.56, b'testmessage2', True],
[-1234.56, {
b'key': b'value'
}, False]],
body_type=MessageBodyType.Sequence)
pickled = pickle.loads(pickle.dumps(sequence_message))
body = list(pickled.get_data())
assert len(body) == 2
assert body == [[1234.56, b'testmessage2', True],
[-1234.56, {
b'key': b'value'
}, False]]
value_message = Message(body={b'key': [1, b'str', False]},
body_type=MessageBodyType.Value)
pickled = pickle.loads(pickle.dumps(value_message))
body = pickled.get_data()
assert body == {b'key': [1, b'str', False]}
error = errors.MessageModified(False, False, {b'key': b'value'})
pickled_error = pickle.loads(pickle.dumps(error))
assert pickled_error._annotations == {b'key': b'value'} # pylint: disable=protected-access
message = Message(body="test", properties=properties, header=header)
message.on_send_complete = send_complete_callback
message.footer = {'a': 2}
message.state = constants.MessageState.ReceivedSettled
pickled = pickle.loads(pickle.dumps(message))
assert list(message.get_data()) == [b"test"]
assert message.footer == pickled.footer
assert message.state == pickled.state
assert message.application_properties == pickled.application_properties
assert message.annotations == pickled.annotations
assert message.delivery_annotations == pickled.delivery_annotations
assert message.settled == pickled.settled
assert message.properties.message_id == pickled.properties.message_id
assert message.properties.user_id == pickled.properties.user_id
assert message.properties.to == pickled.properties.to
assert message.properties.subject == pickled.properties.subject
assert message.properties.reply_to == pickled.properties.reply_to
assert message.properties.correlation_id == pickled.properties.correlation_id
assert message.properties.content_type == pickled.properties.content_type
assert message.properties.content_encoding == pickled.properties.content_encoding
assert message.properties.absolute_expiry_time == pickled.properties.absolute_expiry_time
assert message.properties.creation_time == pickled.properties.creation_time
assert message.properties.group_id == pickled.properties.group_id
assert message.properties.group_sequence == pickled.properties.group_sequence
assert message.properties.reply_to_group_id == pickled.properties.reply_to_group_id
assert message.header.delivery_count == pickled.header.delivery_count
assert message.header.time_to_live == pickled.header.time_to_live
assert message.header.first_acquirer == pickled.header.first_acquirer
assert message.header.durable == pickled.header.durable
assert message.header.priority == pickled.header.priority
# send with message param
settler = errors.MessageAlreadySettled
internal_message = c_uamqp.create_message()
internal_message.add_body_data(b"hi")
message_w_message_param = Message(message=internal_message,
settler=settler,
delivery_no=1)
pickled = pickle.loads(pickle.dumps(message_w_message_param))
message_data = str(message_w_message_param.get_data())
pickled_data = str(pickled.get_data())
assert message_data == pickled_data
assert message_w_message_param.footer == pickled.footer
assert message_w_message_param.state == pickled.state
assert message_w_message_param.application_properties == pickled.application_properties
assert message_w_message_param.annotations == pickled.annotations
assert message_w_message_param.delivery_annotations == pickled.delivery_annotations
assert message_w_message_param.settled == pickled.settled
assert pickled.delivery_no == 1
assert type(pickled._settler()) == type(settler()) # pylint: disable=protected-access
