def convert_message_to_older_version(self, convert_to_version: int,
msg: AbstractBloxrouteMessage):
"""
Converts message from current version to provided version
:param convert_to_version: version to convert to
:param msg: message
:return: converted message
"""
if not convert_to_version:
raise ValueError("convert_to_version is required")
if not msg:
raise ValueError("msg is required")
if convert_to_version not in self.protocol_to_converter_factory_mapping:
raise ValueError(
"Conversion for version {} is not supported".format(
convert_to_version))
if isinstance(
msg,
TxMessage) and convert_to_version in msg.converted_message:
converted_msg = msg.converted_message[convert_to_version]
else:
msg_converter = self._get_message_converter(
convert_to_version, msg.msg_type())
converted_msg = msg_converter.convert_to_older_version(msg)
msg.converted_message[convert_to_version] = converted_msg
return converted_msg
def test_ping_pong(self):
hello_msg = HelloMessage(protocol_version=protocol_version.PROTOCOL_VERSION, network_num=1)
self.connection.add_received_bytes(hello_msg.rawbytes())
self.connection.process_message()
hello_msg_bytes = self.connection.get_bytes_to_send()
self.assertTrue(len(hello_msg_bytes) > 0)
self.connection.advance_sent_bytes(len(hello_msg_bytes))
ack_msg = AckMessage()
self.connection.add_received_bytes(ack_msg.rawbytes())
self.connection.process_message()
ack_msg_bytes = self.connection.get_bytes_to_send()
self.assertTrue(len(ack_msg_bytes) > 0)
self.connection.advance_sent_bytes(len(ack_msg_bytes))
ping_msg = PingMessage(nonce=12345)
self.connection.add_received_bytes(ping_msg.rawbytes())
self.connection.process_message()
pong_msg_bytes = self.connection.get_bytes_to_send()
self.assertTrue(len(pong_msg_bytes) > 0)
msg_type, payload_len = AbstractBloxrouteMessage.unpack(pong_msg_bytes[:AbstractBloxrouteMessage.HEADER_LENGTH])
self.assertEqual(BloxrouteMessageType.PONG, msg_type)
self.connection.advance_sent_bytes(len(pong_msg_bytes))
time.time = MagicMock(return_value=time.time() + constants.PING_INTERVAL_S)
self.node.alarm_queue.fire_alarms()
ping_msg_bytes = self.connection.get_bytes_to_send()
self.assertTrue(len(ping_msg_bytes) > 0)
msg_type, payload_len = AbstractBloxrouteMessage.unpack(ping_msg_bytes[:AbstractBloxrouteMessage.HEADER_LENGTH])
self.assertEqual(BloxrouteMessageType.PING, msg_type)
def setUp(self):
self.buf1 = bytearray([i for i in range(40)])
self.payload_len1 = 20
self.msg_type1 = b"example"
self.message1 = AbstractBloxrouteMessage(msg_type=self.msg_type1,
payload_len=self.payload_len1,
buf=self.buf1)
self.buf2 = bytearray([i for i in range(24)])
self.payload_len2 = 50
self.msg_type2 = b"hello"
self.message2 = AbstractBloxrouteMessage(msg_type=self.msg_type2,
payload_len=self.payload_len2,
buf=self.buf2)
def convert_to_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_OLD_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected new message type to v6: {msg_type}"
)
old_version_msg_class = self._MSG_TYPE_TO_OLD_MSG_CLASS_MAPPING[
msg_type]
old_version_payload_len = (msg.payload_len() -
constants.TRANSACTION_FLAG_LEN -
constants.DOUBLE_SIZE_IN_BYTES)
old_version_msg_bytes = bytearray(
self._LEFT_BREAKPOINT +
len(msg.rawbytes()[self._RIGHT_BREAKPOINT:]))
old_version_msg_bytes[:self._LEFT_BREAKPOINT] = msg.rawbytes(
)[:self._LEFT_BREAKPOINT]
old_version_msg_bytes[self._LEFT_BREAKPOINT:] = msg.rawbytes(
)[self._RIGHT_BREAKPOINT:]
struct.pack_into(
"<12sL",
old_version_msg_bytes,
AbstractBloxrouteMessage.STARTING_BYTES_LEN,
msg_type,
old_version_payload_len,
)
return AbstractBloxrouteMessage.initialize_class(
old_version_msg_class,
old_version_msg_bytes,
(msg_type, old_version_payload_len),
)
def convert_from_older_version(
self, msg: AbstractInternalMessage
) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected old message type to "
f"v7: {msg_type}"
)
new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type]
new_payload_len = (
msg.payload_len() +
constants.QUOTA_FLAG_LEN +
constants.UL_INT_SIZE_IN_BYTES
)
new_msg_bytes = bytearray(
AbstractBloxrouteMessage.HEADER_LENGTH + new_payload_len
)
new_msg_bytes[: self._LEFT_BREAKPOINT] = msg.rawbytes()[
: self._LEFT_BREAKPOINT
]
struct.pack_into("<B", new_msg_bytes, self._LEFT_BREAKPOINT, 0)
struct.pack_into("<L", new_msg_bytes, self._LEFT_BREAKPOINT, 0)
new_msg_bytes[self._RIGHT_BREAKPOINT :] = msg.rawbytes()[
self._LEFT_BREAKPOINT :
]
return AbstractBloxrouteMessage.initialize_class(
new_msg_class, new_msg_bytes, (msg_type, new_payload_len)
)
def convert_from_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected old message type to v9: {msg_type}"
)
new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type]
new_payload_len = msg.payload_len() + constants.BROADCAST_TYPE_LEN
new_msg_bytes = bytearray(AbstractBloxrouteMessage.HEADER_LENGTH +
new_payload_len)
new_msg_bytes[:self._BASE_LENGTH] = msg.rawbytes()[:self._BASE_LENGTH]
struct.pack_into(
"<4s",
new_msg_bytes,
self._BASE_LENGTH,
# pylint: disable=no-member
BroadcastMessageType.BLOCK.value.encode(
constants.DEFAULT_TEXT_ENCODING))
new_msg_bytes[self._BREAKPOINT:] = msg.rawbytes()[self._BASE_LENGTH:]
return AbstractBloxrouteMessage.initialize_class(
new_msg_class, new_msg_bytes, (msg_type, new_payload_len))
def convert_to_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_OLD_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected new message type to v8: {msg_type}"
)
old_version_msg_class = self._MSG_TYPE_TO_OLD_MSG_CLASS_MAPPING[
msg_type]
old_version_payload_len = msg.payload_len(
) - constants.BROADCAST_TYPE_LEN
old_version_msg_bytes = bytearray(
self._BASE_LENGTH + len(msg.rawbytes()[self._BREAKPOINT:]))
old_version_msg_bytes[:self._BASE_LENGTH] = msg.rawbytes(
)[:self._BASE_LENGTH]
old_version_msg_bytes[self._BASE_LENGTH:] = msg.rawbytes(
)[self._BREAKPOINT:]
return AbstractBloxrouteMessage.initialize_class(
old_version_msg_class,
old_version_msg_bytes,
(msg_type, old_version_payload_len),
)
def convert_from_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected old message type to v6: {msg_type}"
)
new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type]
new_payload_len = msg.payload_len() + constants.NODE_ID_SIZE_IN_BYTES
new_msg_bytes = bytearray(AbstractBloxrouteMessage.HEADER_LENGTH +
new_payload_len)
new_msg_bytes[:self._LEFT_BREAKPOINT] = msg.rawbytes(
)[:self._LEFT_BREAKPOINT]
new_msg_bytes[self._RIGHT_BREAKPOINT:] = msg.rawbytes(
)[self._LEFT_BREAKPOINT:]
# pack empty source id for old gateways, since message converters are singletons
# and source ids for gateway don't matter anyway
struct.pack_into("<16s", new_msg_bytes, self._LEFT_BREAKPOINT,
uuid_pack.to_bytes(""))
return AbstractBloxrouteMessage.initialize_class(
new_msg_class, new_msg_bytes, (msg_type, new_payload_len))
def compare_old_to_current(
self,
converted_current_message: AbstractBloxrouteMessage,
original_current_message: AbstractBloxrouteMessage,
):
"""
This method is run on every message comparision, when comparing
the old version converted to the current version.
Override this if a change is made that affects every message.
"""
self.assertEqual(
constants.STARTING_SEQUENCE_BYTES,
converted_current_message.rawbytes()
[:constants.STARTING_SEQUENCE_BYTES_LEN],
)
self.assertEqual(
original_current_message.msg_type(),
converted_current_message.msg_type(),
)
self.assertEqual(
original_current_message.payload_len(),
converted_current_message.payload_len(),
)
self.assertEqual(
original_current_message.get_control_flags(),
converted_current_message.get_control_flags(),
)
def convert_from_older_version(
self, msg: AbstractInternalMessage
) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected old message type from v16: {msg_type}"
)
new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type]
new_payload_len = msg.payload_len() + self._LENGTH_DIFFERENCE
new_msg_bytes = bytearray(self._NEW_MESSAGE_LEN)
new_msg_bytes[:self._INTERVAL_TIMES_BREAKPOINT] = msg.rawbytes()[:self._INTERVAL_TIMES_BREAKPOINT]
off = self._BASE_LENGTH + self._INTERVAL_TIMES_LENGTH
new_msg_bytes[off:off + self._MEMORY_UTILIZATION_LENGTH] = \
msg.rawbytes()[
self._FIRST_STATS_SETS_BREAKPOINT:self._FIRST_STATS_SETS_BREAKPOINT + self._MEMORY_UTILIZATION_LENGTH
]
off += self._MEMORY_UTILIZATION_LENGTH
# single blockchain peer
struct.pack_into("<H", new_msg_bytes, off, 1)
off += constants.UL_SHORT_SIZE_IN_BYTES
# placeholder ip/port
message_utils.pack_ip_port(new_msg_bytes, off, "0.0.0.0", 0)
off += constants.IP_ADDR_SIZE_IN_BYTES + constants.UL_SHORT_SIZE_IN_BYTES
new_msg_bytes[off:off + self._FIRST_STATS_SETS_LENGTH] = \
msg.rawbytes()[
self._INTERVAL_TIMES_BREAKPOINT:self._INTERVAL_TIMES_BREAKPOINT + self._FIRST_STATS_SETS_LENGTH
]
off += self._FIRST_STATS_SETS_LENGTH
new_msg_bytes[off:off + self._SECOND_STATS_SET_LENGTH] = \
msg.rawbytes()[
self._MEMORY_UTILIZATION_BREAKPOINT:self._MEMORY_UTILIZATION_BREAKPOINT + self._SECOND_STATS_SET_LENGTH
]
off += self._SECOND_STATS_SET_LENGTH
default_new_stats = 0
struct.pack_into("<I", new_msg_bytes, off, default_new_stats)
off += constants.UL_INT_SIZE_IN_BYTES
struct.pack_into("<I", new_msg_bytes, off, default_new_stats)
off += constants.UL_INT_SIZE_IN_BYTES
new_msg_bytes[off:] = msg.rawbytes()[self._SECOND_STATS_SET_BREAKPOINT:]
return AbstractBloxrouteMessage.initialize_class(
new_msg_class,
new_msg_bytes,
(msg_type, new_payload_len)
)
def test_broadcast_message_cut_through_from_old(self):
block_hash = Sha256Hash(helpers.generate_bytes(crypto.SHA256_HASH_LEN))
blob = helpers.generate_bytes(250)
network_num = 1234
old_message = BroadcastMessageV5(network_num=network_num,
msg_hash=block_hash,
blob=blob)
old_message_bytes = old_message.rawbytes()
new_message_bytes = bloxroute_version_manager.convert_message_first_bytes_from_older_version(
5, BroadcastMessage.MESSAGE_TYPE, old_message_bytes)
new_message_bytes = bloxroute_version_manager.convert_message_last_bytes_from_older_version(
5, BroadcastMessage.MESSAGE_TYPE, new_message_bytes)
msg_type, payload_length = AbstractBloxrouteMessage.unpack(
new_message_bytes)
new_msg = AbstractBloxrouteMessage.initialize_class(
BroadcastMessage, bytearray(new_message_bytes.tobytes()),
(msg_type, payload_length))
self._validate_messages_match(old_message, new_msg)
self.assertEqual(EMPTY_SOURCE_ID_STR, new_msg.source_id())
def test_init(self):
with self.assertRaises(struct.error):
AbstractBloxrouteMessage(msg_type=None,
payload_len=20,
buf=bytearray([i for i in range(40)]))
with self.assertRaises(ValueError):
AbstractBloxrouteMessage(msg_type=b"hello",
payload_len=-5,
buf=bytearray([i for i in range(40)]))
with self.assertRaises(ValueError):
AbstractBloxrouteMessage(msg_type=b"hello",
payload_len=20,
buf=bytearray([i for i in range(10)]))
self.assertEqual(self.buf1, self.message1.buf)
self.assertEqual(self.buf1, self.message1._memoryview)
self.assertEqual(self.msg_type1, self.message1._msg_type)
self.assertIsNone(self.message1._payload)
self.assertEqual(self.payload_len1, self.message1._payload_len)
def convert_first_bytes_to_older_version(self, first_msg_bytes: memoryview) -> memoryview:
v5_bytes = broadcast_message_converter_v5.convert_first_bytes_to_older_version(first_msg_bytes)
command, payload_len = AbstractBloxrouteMessage.unpack(v5_bytes)
result_bytes = bytearray(len(v5_bytes) - constants.STARTING_SEQUENCE_BYTES_LEN)
result_bytes[:] = v5_bytes[constants.STARTING_SEQUENCE_BYTES_LEN:]
struct.pack_into("<12sL", result_bytes, 0, command, payload_len - constants.CONTROL_FLAGS_LEN)
return memoryview(result_bytes)
def test_process_message_quit_on_bad_message(self):
bad_message = AbstractBloxrouteMessage(
b"badtype", 0,
bytearray(constants.STARTING_SEQUENCE_BYTES_LEN +
constants.BX_HDR_COMMON_OFF +
constants.CONTROL_FLAGS_LEN)).rawbytes()
self.connection.inputbuf.add_bytes(bad_message)
self.connection.inputbuf.add_bytes(bad_message)
self.connection.inputbuf.add_bytes(bad_message)
self.connection.inputbuf.add_bytes(bad_message)
self.connection.process_message()
self.assertFalse(self.connection.is_alive())
def convert_from_older_version(
self, msg: AbstractInternalMessage
) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected old message type from v18: {msg_type}"
)
if len(msg.rawbytes()) == self._MESSAGE_LEN_WITHOUT_NODE_STATS:
# per Endpoint Stats is not available
length_difference = 0
new_message_len = self._MESSAGE_LEN_WITHOUT_NODE_STATS
num_blockchain_peers = 0
else:
num_blockchain_peers, = struct.unpack_from("<I", msg.rawbytes(), self._MEMORY_UTILIZATION_BREAKPOINT)
length_difference = self._NODE_STATS_LENGTH_DIFFERENCE * num_blockchain_peers
new_message_len = self._MESSAGE_LEN_WITHOUT_NODE_STATS + \
(num_blockchain_peers * self._NEW_MESSAGE_NODE_STATS_LEN)
new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type]
new_payload_len = msg.payload_len() + length_difference
new_msg_bytes = bytearray(new_message_len)
new_msg_bytes[:self._NUM_BLOCKCHAIN_PEERS_BREAKPOINT] = msg.rawbytes()[:self._NUM_BLOCKCHAIN_PEERS_BREAKPOINT]
new_msg_off = self._NUM_BLOCKCHAIN_PEERS_BREAKPOINT
old_msg_off = self._NUM_BLOCKCHAIN_PEERS_BREAKPOINT
default_new_stats = 0
for _ in range(num_blockchain_peers):
new_msg_bytes[new_msg_off:new_msg_off + self._OLD_MESSAGE_NODE_STATS_LEN] = \
msg.rawbytes()[old_msg_off:old_msg_off + self._OLD_MESSAGE_NODE_STATS_LEN]
new_msg_off += self._OLD_MESSAGE_NODE_STATS_LEN
old_msg_off += self._OLD_MESSAGE_NODE_STATS_LEN
struct.pack_into("<I", new_msg_bytes, new_msg_off, default_new_stats)
new_msg_off += constants.UL_INT_SIZE_IN_BYTES
struct.pack_into("<I", new_msg_bytes, new_msg_off, default_new_stats)
new_msg_off += constants.UL_INT_SIZE_IN_BYTES
new_msg_bytes[new_msg_off:] = msg.rawbytes()[old_msg_off:]
return AbstractBloxrouteMessage.initialize_class(
new_msg_class,
new_msg_bytes,
(msg_type, new_payload_len)
)
def convert_to_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
if not isinstance(msg, GatewayHelloMessageV2):
raise TypeError("GatewayHelloMessage is expected")
msg_bytes = msg.rawbytes()
mem_view = memoryview(msg_bytes)
result_bytes = bytearray(
len(msg_bytes) - GatewayHelloMessageV2.ADDITIONAL_LENGTH)
payload_len = GatewayHelloMessageV1.PAYLOAD_LENGTH
result_bytes[:] = mem_view[:len(msg_bytes) -
GatewayHelloMessageV2.ADDITIONAL_LENGTH]
return AbstractBloxrouteMessage.initialize_class(
GatewayHelloMessageV1, result_bytes,
(GatewayMessageType.HELLO, payload_len))
def convert_from_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
if not isinstance(msg, GatewayHelloMessageV1):
raise TypeError("GatewayHelloMessageV1 is expected")
msg_bytes = msg.rawbytes()
mem_view = memoryview(msg_bytes)
result_bytes = bytearray(
len(msg_bytes) + constants.NODE_ID_SIZE_IN_BYTES)
payload_len = GatewayHelloMessageV2.PAYLOAD_LENGTH
off = 0
result_bytes[off:len(msg_bytes)] = mem_view[:]
off = len(msg_bytes)
struct.pack_into("%ss" % constants.NODE_ID_SIZE_IN_BYTES, result_bytes,
off, b'')
return AbstractBloxrouteMessage.initialize_class(
GatewayHelloMessageV2, result_bytes,
(GatewayMessageType.HELLO, payload_len))
def convert_from_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected old message type from v10: {msg_type}"
)
new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type]
new_payload_len = msg.payload_len() + self._LENGTH_DIFFERENCE
new_msg_bytes = bytearray(self._NEW_MESSAGE_LEN)
new_msg_bytes[:self._BREAKPOINT] = msg.rawbytes()[:self._BREAKPOINT]
new_msg_bytes[self._BREAKPOINT +
self._LENGTH_DIFFERENCE:] = msg.rawbytes()[self.
_BREAKPOINT:]
return AbstractBloxrouteMessage.initialize_class(
new_msg_class, new_msg_bytes, (msg_type, new_payload_len))
def convert_to_older_version(
self, msg: AbstractInternalMessage
) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_OLD_MSG_CLASS_MAPPING:
raise ValueError(
f"Tried to convert unexpected new "
f"message type to v7: {msg_type}"
)
old_version_msg_class = self._MSG_TYPE_TO_OLD_MSG_CLASS_MAPPING[
msg_type
]
old_version_payload_len = (
msg.payload_len()
- constants.QUOTA_FLAG_LEN
- constants.UL_INT_SIZE_IN_BYTES
)
old_version_msg_bytes = bytearray(
self._LEFT_BREAKPOINT
+ len(msg.rawbytes()[self._RIGHT_BREAKPOINT :])
)
old_version_msg_bytes[: self._LEFT_BREAKPOINT] = msg.rawbytes()[
: self._LEFT_BREAKPOINT
]
old_version_msg_bytes[self._LEFT_BREAKPOINT :] = msg.rawbytes()[
self._RIGHT_BREAKPOINT :
]
return AbstractBloxrouteMessage.initialize_class(
old_version_msg_class,
old_version_msg_bytes,
(msg_type, old_version_payload_len),
)
def convert_from_older_version(
self, msg: AbstractInternalMessage) -> AbstractInternalMessage:
msg_type = msg.MESSAGE_TYPE
if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING:
raise ValueError(
f"Unexpected got message of type {msg_type}. Could not convert to current version."
)
new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type]
new_payload_len = msg.payload_len() + constants.CONTROL_FLAGS_LEN
new_msg_bytes = bytearray(AbstractBloxrouteMessage.HEADER_LENGTH +
new_payload_len)
new_msg_bytes[:constants.
STARTING_SEQUENCE_BYTES_LEN] = constants.STARTING_SEQUENCE_BYTES
struct.pack_into("<12sL", new_msg_bytes,
constants.STARTING_SEQUENCE_BYTES_LEN, msg_type,
new_payload_len)
new_msg_bytes[constants.STARTING_SEQUENCE_BYTES_LEN:-constants.
CONTROL_FLAGS_LEN] = msg.rawbytes()
new_msg_bytes[-1] = BloxrouteMessageControlFlags.VALID
return AbstractBloxrouteMessage.initialize_class(
new_msg_class, new_msg_bytes, (msg_type, new_payload_len))
def test_asbstract_bloxroute_message(self):
total_msg_len = 1000
msg_type = b"dummy_msg"
payload_len = total_msg_len - constants.BX_HDR_COMMON_OFF - constants.STARTING_SEQUENCE_BYTES_LEN
buffer = bytearray(total_msg_len)
message = AbstractBloxrouteMessage(msg_type=msg_type, payload_len=payload_len, buf=buffer)
raw_bytes = message.rawbytes()
self.assertEqual(total_msg_len, len(raw_bytes))
self.assertEqual(msg_type, message.msg_type())
self.assertEqual(payload_len, message.payload_len())
self.assertEqual(payload_len, len(message.payload()))
self.assertTrue(message.get_control_flags() & BloxrouteMessageControlFlags.VALID)
message.remove_control_flag(BloxrouteMessageControlFlags.VALID)
self.assertFalse(message.get_control_flags() & BloxrouteMessageControlFlags.VALID)
message.set_control_flag(BloxrouteMessageControlFlags.VALID)
self.assertTrue(message.get_control_flags() & BloxrouteMessageControlFlags.VALID)
# Trying set already set flag
message.set_control_flag(BloxrouteMessageControlFlags.VALID)
self.assertTrue(message.get_control_flags() & BloxrouteMessageControlFlags.VALID)
class MessageTest(AbstractTestCase):
def setUp(self):
self.buf1 = bytearray([i for i in range(40)])
self.payload_len1 = 20
self.msg_type1 = b"example"
self.message1 = AbstractBloxrouteMessage(msg_type=self.msg_type1,
payload_len=self.payload_len1,
buf=self.buf1)
self.buf2 = bytearray([i for i in range(24)])
self.payload_len2 = 50
self.msg_type2 = b"hello"
self.message2 = AbstractBloxrouteMessage(msg_type=self.msg_type2,
payload_len=self.payload_len2,
buf=self.buf2)
def test_init(self):
with self.assertRaises(struct.error):
AbstractBloxrouteMessage(msg_type=None,
payload_len=20,
buf=bytearray([i for i in range(40)]))
with self.assertRaises(ValueError):
AbstractBloxrouteMessage(msg_type=b"hello",
payload_len=-5,
buf=bytearray([i for i in range(40)]))
with self.assertRaises(ValueError):
AbstractBloxrouteMessage(msg_type=b"hello",
payload_len=20,
buf=bytearray([i for i in range(10)]))
self.assertEqual(self.buf1, self.message1.buf)
self.assertEqual(self.buf1, self.message1._memoryview)
self.assertEqual(self.msg_type1, self.message1._msg_type)
self.assertIsNone(self.message1._payload)
self.assertEqual(self.payload_len1, self.message1._payload_len)
def test_rawbytes(self):
self.assertIsInstance(self.message1.rawbytes(), memoryview)
self.assertEqual(self.payload_len1, self.message1._payload_len)
message2_rawbytes = self.message2.rawbytes()
self.assertEqual(self.payload_len2, self.message2._payload_len)
self.assertEqual(message2_rawbytes,
memoryview(self.message2._memoryview))
def test_msg_type(self):
self.assertEqual(self.msg_type1, self.message1.msg_type())
def test_payload_len(self):
self.assertEqual(self.payload_len1, self.message1.payload_len())
def test_payload(self):
self.assertIsNone(self.message1._payload)
self.assertEqual(
self.
buf1[AbstractBloxrouteMessage.HEADER_LENGTH:self.payload_len1 +
AbstractBloxrouteMessage.HEADER_LENGTH],
self.message1.payload())
self.assertEqual(
self.
buf1[AbstractBloxrouteMessage.HEADER_LENGTH:self.payload_len1 +
AbstractBloxrouteMessage.HEADER_LENGTH],
self.message1._payload)
