def start_transaction_recovery( self, unknown_sids: Iterable[int], unknown_hashes: Iterable[Sha256Hash], block_hash: Sha256Hash, connection: Optional[AbstractRelayConnection] = None) -> None: all_unknown_sids = [] all_unknown_sids.extend(unknown_sids) tx_service = self._node.get_tx_service() # retrieving sids of txs with unknown contents for tx_hash in unknown_hashes: transaction_key = tx_service.get_transaction_key(tx_hash) tx_sid = tx_service.get_short_id_by_key(transaction_key) all_unknown_sids.append(tx_sid) if not self._node.opts.request_recovery: if connection is not None: network_num = connection.network_num else: network_num = self._node.network_num # log recovery started to match with recovery completing block_stats.add_block_event_by_block_hash( block_hash, BlockStatEventType.BLOCK_RECOVERY_STARTED, network_num=network_num, txs_count=len(all_unknown_sids), more_info="recovery from relay is disabled", ) return get_txs_message = GetTxsMessage(short_ids=all_unknown_sids) self._node.broadcast( get_txs_message, connection_types=(ConnectionType.RELAY_TRANSACTION, )) if connection is not None: tx_stats.add_txs_by_short_ids_event( all_unknown_sids, TransactionStatEventType. TX_UNKNOWN_SHORT_IDS_REQUESTED_BY_GATEWAY_FROM_RELAY, network_num=self._node.network_num, peers=[connection], block_hash=convert.bytes_to_hex(block_hash.binary)) block_stats.add_block_event_by_block_hash( block_hash, BlockStatEventType.BLOCK_RECOVERY_STARTED, network_num=connection.network_num, txs_count=len(all_unknown_sids), request_hash=convert.bytes_to_hex( crypto.double_sha256(get_txs_message.rawbytes()))) else: block_stats.add_block_event_by_block_hash( block_hash, BlockStatEventType.BLOCK_RECOVERY_REPEATED, network_num=self._node.network_num, txs_count=len(all_unknown_sids), request_hash=convert.bytes_to_hex( crypto.double_sha256(get_txs_message.rawbytes())))
def compare_gettxs_old_to_current( self, converted_current_message: GetTxsMessage, original_current_message: GetTxsMessage, ): self.assertEqual( original_current_message.rawbytes(), converted_current_message.rawbytes(), )
def test_recover_multiple_iterations(self): for tx_message in self.transactions: helpers.receive_node_message(self.node1, self.relay_fileno, tx_message.rawbytes()) helpers.clear_node_buffer(self.node1, self.blockchain_fileno) get_txs_message = self._send_compressed_block_to_node_1() txs_message = self._build_txs_message( get_txs_message.get_short_ids()[:5]) helpers.receive_node_message(self.node1, self.relay_fileno, txs_message.rawbytes()) bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[0]) self.node1.alarm_queue.fire_alarms() get_txs_bytes_2 = helpers.get_queued_node_bytes( self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE) get_txs_message_2 = GetTxsMessage(buf=get_txs_bytes_2.tobytes()) self.assertEqual(5, len(get_txs_message_2.get_short_ids())) txs_message = self._build_txs_message( get_txs_message_2.get_short_ids()[:-1]) helpers.receive_node_message(self.node1, self.relay_fileno, txs_message.rawbytes()) # retry again in a longer interval bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[0]) self.node1.alarm_queue.fire_alarms() bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[1]) self.node1.alarm_queue.fire_alarms() get_txs_bytes_3 = helpers.get_queued_node_bytes( self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE) get_txs_message_3 = GetTxsMessage(buf=get_txs_bytes_3.tobytes()) self.assertEqual(1, len(get_txs_message_3.get_short_ids())) txs_message = self._build_txs_message( get_txs_message_3.get_short_ids()) helpers.receive_node_message(self.node1, self.relay_fileno, txs_message.rawbytes()) self._assert_sent_block_node_1()
def start_transaction_recovery( self, unknown_sids: Iterable[int], unknown_hashes: Iterable[Sha256Hash], block_hash: Sha256Hash, connection: Optional[AbstractRelayConnection] = None): all_unknown_sids = [] all_unknown_sids.extend(unknown_sids) tx_service = self._node.get_tx_service() # retrieving sids of txs with unknown contents for tx_hash in unknown_hashes: tx_sid = tx_service.get_short_id(tx_hash) all_unknown_sids.append(tx_sid) get_txs_message = GetTxsMessage(short_ids=all_unknown_sids) self._node.broadcast( get_txs_message, connection_types=[ConnectionType.RELAY_TRANSACTION]) if connection is not None: tx_stats.add_txs_by_short_ids_event( all_unknown_sids, TransactionStatEventType. TX_UNKNOWN_SHORT_IDS_REQUESTED_BY_GATEWAY_FROM_RELAY, network_num=self._node.network_num, peer=connection.peer_desc, block_hash=convert.bytes_to_hex(block_hash.binary)) block_stats.add_block_event_by_block_hash( block_hash, BlockStatEventType.BLOCK_RECOVERY_STARTED, network_num=connection.network_num, request_hash=convert.bytes_to_hex( crypto.double_sha256(get_txs_message.rawbytes()))) else: block_stats.add_block_event_by_block_hash( block_hash, BlockStatEventType.BLOCK_RECOVERY_REPEATED, network_num=self._node.network_num, request_hash=convert.bytes_to_hex( crypto.double_sha256(get_txs_message.rawbytes())))
def _send_compressed_block_to_node_1(self): for tx_message_with_short_id in self.transactions_with_short_ids: helpers.receive_node_message(self.node2, self.relay_fileno, tx_message_with_short_id.rawbytes()) helpers.clear_node_buffer(self.node1, self.blockchain_fileno) helpers.receive_node_message(self.node2, self.blockchain_fileno, self.block.rawbytes()) broadcast_bytes = helpers.get_queued_node_bytes( self.node2, self.relay_fileno, BroadcastMessage.MESSAGE_TYPE) helpers.receive_node_message(self.node1, self.relay_fileno, broadcast_bytes) get_txs_bytes = helpers.get_queued_node_bytes( self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE) get_txs_message = GetTxsMessage(buf=get_txs_bytes.tobytes()) self._assert_no_block_node_1() return get_txs_message
def test_message_preview_success_all_types(self): self.get_message_preview_successfully(HelloMessage(protocol_version=1, network_num=2), HelloMessage.MESSAGE_TYPE, VersionMessage.VERSION_MESSAGE_LENGTH + UL_INT_SIZE_IN_BYTES + NODE_ID_SIZE_IN_BYTES - UL_INT_SIZE_IN_BYTES) self.get_message_preview_successfully(AckMessage(), AckMessage.MESSAGE_TYPE, constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully(PingMessage(), PingMessage.MESSAGE_TYPE, 9) self.get_message_preview_successfully(PongMessage(), PongMessage.MESSAGE_TYPE, 9) blob = bytearray(1 for _ in range(4)) self.get_message_preview_successfully(BroadcastMessage(self.HASH, 1, self.NODE_ID, True, blob), BroadcastMessage.MESSAGE_TYPE, SHA256_HASH_LEN + NETWORK_NUM_LEN + BLOCK_ENCRYPTED_FLAG_LEN + constants.NODE_ID_SIZE_IN_BYTES + len(blob) + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully(TxMessage(self.HASH, 1, self.NODE_ID, 12, blob), TxMessage.MESSAGE_TYPE, SHA256_HASH_LEN + NETWORK_NUM_LEN + UL_INT_SIZE_IN_BYTES + constants.NODE_ID_SIZE_IN_BYTES + len(blob) + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully(KeyMessage(self.HASH, 1, self.NODE_ID, bytearray(1 for _ in range(KEY_SIZE))), KeyMessage.MESSAGE_TYPE, SHA256_HASH_LEN + KEY_SIZE + NETWORK_NUM_LEN + constants.NODE_ID_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully(BlockHoldingMessage(self.HASH, 1, self.NODE_ID), BlockHoldingMessage.MESSAGE_TYPE, SHA256_HASH_LEN + NETWORK_NUM_LEN + constants.NODE_ID_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN) get_txs = [1, 2, 3] self.get_message_preview_successfully(GetTxsMessage(get_txs), GetTxsMessage.MESSAGE_TYPE, UL_INT_SIZE_IN_BYTES + UL_INT_SIZE_IN_BYTES * len( get_txs) + constants.CONTROL_FLAGS_LEN) txs = [TransactionInfo(crypto.double_sha256(b"123"), bytearray(4), 1), TransactionInfo(crypto.double_sha256(b"234"), bytearray(8), 2)] expected_length = (UL_INT_SIZE_IN_BYTES + sum(UL_INT_SIZE_IN_BYTES + SHA256_HASH_LEN + UL_INT_SIZE_IN_BYTES + len(tx.contents) for tx in txs) + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully(TxsMessage(txs), TxsMessage.MESSAGE_TYPE, expected_length)
def test_get_txs_with_short_ids_message(self): short_ids = [23, 99, 192, 1089, 3000500] msg = GetTxsMessage(short_ids=short_ids) msg_bytes = msg.rawbytes() self.assertTrue(msg_bytes) parsed_msg = GetTxsMessage(buf=msg_bytes) self.assertTrue(parsed_msg) parsed_short_ids = parsed_msg.get_short_ids() self.assertEqual(len(parsed_short_ids), len(short_ids)) for index in range(len(short_ids)): self.assertEqual(parsed_short_ids[index], short_ids[index])
def test_recover_give_up(self): gateway_constants.BLOCK_RECOVERY_MAX_RETRY_ATTEMPTS = 3 for tx_message in self.transactions: helpers.receive_node_message(self.node1, self.relay_fileno, tx_message.rawbytes()) helpers.clear_node_buffer(self.node1, self.blockchain_fileno) self._send_compressed_block_to_node_1() txs_message = self._build_txs_message([]) helpers.receive_node_message(self.node1, self.relay_fileno, txs_message.rawbytes()) # retry, first attempt bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[0]) self.node1.alarm_queue.fire_alarms() get_txs_bytes_2 = helpers.get_queued_node_bytes( self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE) get_txs_message_2 = GetTxsMessage(buf=get_txs_bytes_2.tobytes()) self.assertEqual(10, len(get_txs_message_2.get_short_ids())) txs_message = self._build_txs_message([]) helpers.receive_node_message(self.node1, self.relay_fileno, txs_message.rawbytes()) # retry, attempt 2 bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[1]) self.node1.alarm_queue.fire_alarms() get_txs_bytes_3 = helpers.get_queued_node_bytes( self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE) get_txs_message_3 = GetTxsMessage(buf=get_txs_bytes_3.tobytes()) self.assertEqual(10, len(get_txs_message_3.get_short_ids())) txs_message = self._build_txs_message([]) helpers.receive_node_message(self.node1, self.relay_fileno, txs_message.rawbytes()) # retry, attempt 3 bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[2]) self.node1.alarm_queue.fire_alarms() get_txs_bytes_4 = helpers.get_queued_node_bytes( self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE) get_txs_message_4 = GetTxsMessage(buf=get_txs_bytes_4.tobytes()) self.assertEqual(10, len(get_txs_message_4.get_short_ids())) txs_message = self._build_txs_message([]) helpers.receive_node_message(self.node1, self.relay_fileno, txs_message.rawbytes()) # retry given up bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[3] * 20) self.node1.alarm_queue.fire_alarms() # no bytes, even after timeout bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno) self.assertEqual(0, len(bytes_to_send)) self._assert_no_block_node_1()
def gettxs_message(self) -> GetTxsMessage: return GetTxsMessage(list(range(1, 50)))
def test_get_txs_message(self): self._test_to_old_version(GetTxsMessage(short_ids=[1, 2, 3])) self._test_to_new_version(GetTxsMessageV4(short_ids=[1, 2, 3]))
def test_message_preview_success_all_types(self): self.get_message_preview_successfully( HelloMessage(protocol_version=1, network_num=2), HelloMessage.MESSAGE_TYPE, VersionMessage.VERSION_MESSAGE_LENGTH + UL_INT_SIZE_IN_BYTES + NODE_ID_SIZE_IN_BYTES - UL_INT_SIZE_IN_BYTES) self.get_message_preview_successfully(AckMessage(), AckMessage.MESSAGE_TYPE, constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully(PingMessage(), PingMessage.MESSAGE_TYPE, 9) self.get_message_preview_successfully(PongMessage(), PongMessage.MESSAGE_TYPE, 17) blob = bytearray(1 for _ in range(4)) self.get_message_preview_successfully( BroadcastMessage(self.HASH, 1, self.NODE_ID, self.BROADCAST_TYPE, True, blob), BroadcastMessage.MESSAGE_TYPE, SHA256_HASH_LEN + NETWORK_NUM_LEN + constants.BROADCAST_TYPE_LEN + BLOCK_ENCRYPTED_FLAG_LEN + constants.NODE_ID_SIZE_IN_BYTES + len(blob) + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully( TxMessage(self.HASH, 1, self.NODE_ID, 12, blob), TxMessage.MESSAGE_TYPE, SHA256_HASH_LEN + NETWORK_NUM_LEN + UL_INT_SIZE_IN_BYTES + TRANSACTION_FLAG_LEN + constants.NODE_ID_SIZE_IN_BYTES + len(blob) + constants.DOUBLE_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully( KeyMessage(self.HASH, 1, self.NODE_ID, bytearray(1 for _ in range(KEY_SIZE))), KeyMessage.MESSAGE_TYPE, SHA256_HASH_LEN + KEY_SIZE + NETWORK_NUM_LEN + constants.NODE_ID_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully( BlockHoldingMessage(self.HASH, 1, self.NODE_ID), BlockHoldingMessage.MESSAGE_TYPE, SHA256_HASH_LEN + NETWORK_NUM_LEN + constants.NODE_ID_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN) get_txs = [1, 2, 3] self.get_message_preview_successfully( GetTxsMessage(get_txs), GetTxsMessage.MESSAGE_TYPE, UL_INT_SIZE_IN_BYTES + UL_INT_SIZE_IN_BYTES * len(get_txs) + constants.CONTROL_FLAGS_LEN) txs = [ TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")), bytearray(4), 1), TransactionInfo(Sha256Hash(crypto.double_sha256(b"234")), bytearray(8), 2) ] expected_length = (UL_INT_SIZE_IN_BYTES + sum(UL_INT_SIZE_IN_BYTES + SHA256_HASH_LEN + UL_INT_SIZE_IN_BYTES + len(tx.contents) for tx in txs) + constants.CONTROL_FLAGS_LEN) self.get_message_preview_successfully(TxsMessage(txs), TxsMessage.MESSAGE_TYPE, expected_length) expected_length = (2 * constants.DOUBLE_SIZE_IN_BYTES) + (5 * constants.UL_SHORT_SIZE_IN_BYTES) + \ (7 * constants.UL_INT_SIZE_IN_BYTES) + constants.IP_ADDR_SIZE_IN_BYTES + \ constants.CONTROL_FLAGS_LEN node_stats = {} helpers.add_stats_to_node_stats(node_stats, "127.0.0.1", 8001, 200, 300, 400, 500, 600, 700, 800, 100, 50) self.get_message_preview_successfully( BdnPerformanceStatsMessage(datetime.utcnow(), datetime.utcnow(), 100, node_stats), BdnPerformanceStatsMessage.MESSAGE_TYPE, expected_length) # multi node bdn stats message expected_length = ( constants.CONTROL_FLAGS_LEN + (2 * constants.DOUBLE_SIZE_IN_BYTES) + # start/end time constants.UL_SHORT_SIZE_IN_BYTES + # memory constants.UL_SHORT_SIZE_IN_BYTES + # num blockchain peers ( 3 * # num blockchain peers ( constants.IP_ADDR_SIZE_IN_BYTES + # ip constants.UL_SHORT_SIZE_IN_BYTES + # port (2 * constants.UL_SHORT_SIZE_IN_BYTES) + # original block stats (7 * constants.UL_INT_SIZE_IN_BYTES)))) # rest of stats node_stats = {} helpers.add_stats_to_node_stats(node_stats, "127.0.0.1", 8001, 200, 300, 400, 500, 600, 700, 800, 100, 50) helpers.add_stats_to_node_stats(node_stats, "127.0.0.2", 8002, 200, 300, 400, 500, 600, 700, 800, 100, 50) helpers.add_stats_to_node_stats(node_stats, "127.0.0.3", 8003, 200, 300, 400, 500, 600, 700, 800, 100, 50) self.get_message_preview_successfully( BdnPerformanceStatsMessage(datetime.utcnow(), datetime.utcnow(), 100, node_stats), BdnPerformanceStatsMessage.MESSAGE_TYPE, expected_length) tx_info = TransactionInfo(crypto.double_sha256(b"123"), bytearray(4), 1) expected_length = constants.NETWORK_NUM_LEN + constants.SID_LEN + SHA256_HASH_LEN + \ constants.UL_INT_SIZE_IN_BYTES + constants.CONTROL_FLAGS_LEN + len(tx_info.contents) self.get_message_preview_successfully(TxContentsMessage(5, tx_info), TxContentsMessage.MESSAGE_TYPE, expected_length) expected_length = constants.NETWORK_NUM_LEN + constants.SID_LEN + constants.CONTROL_FLAGS_LEN self.get_message_preview_successfully( GetTxContentsMessage(1, 2), GetTxContentsMessage.MESSAGE_TYPE, expected_length)
def test_create_message_success_all_types(self): test_network_num = 10 test_protocol_version = bloxroute_version_manager.CURRENT_PROTOCOL_VERSION hello_message = self.create_message_successfully( HelloMessage(protocol_version=test_protocol_version, network_num=test_network_num, node_id=self.NODE_ID), HelloMessage) self.assertEqual(test_protocol_version, hello_message.protocol_version()) self.assertEqual(test_network_num, hello_message.network_num()) self.assertEqual(self.NODE_ID, hello_message.node_id()) self.create_message_successfully(AckMessage(), AckMessage) self.create_message_successfully(PingMessage(), PingMessage) self.create_message_successfully(PongMessage(), PongMessage) blob = bytearray(4) broadcast_message = self.create_message_successfully( BroadcastMessage(self.HASH, network_num=test_network_num, is_encrypted=True, source_id=self.NODE_ID, blob=blob), BroadcastMessage) self.assertEqual(self.HASH, broadcast_message.block_hash()) self.assertEqual(test_network_num, broadcast_message.network_num()) self.assertEqual(self.NODE_ID, broadcast_message.source_id()) self.assertTrue(broadcast_message.is_encrypted()) self.assertEqual(blob, broadcast_message.blob().tobytes()) sid = 12 tx_val = bytes(1 for _ in range(5)) tx_message = self.create_message_successfully( TxMessage(self.HASH, network_num=test_network_num, source_id=self.NODE_ID, short_id=sid, tx_val=tx_val), TxMessage) self.assertEqual(self.HASH, tx_message.tx_hash()) self.assertEqual(self.NODE_ID, tx_message.source_id()) self.assertEqual(sid, tx_message.short_id()) self.assertEqual(test_network_num, tx_message.network_num()) self.assertEqual(tx_val, tx_message.tx_val()) key = bytearray(1 for _ in range(KEY_SIZE)) key_message = self.create_message_successfully( KeyMessage(self.HASH, test_network_num, self.NODE_ID, bytearray(1 for _ in range(KEY_SIZE))), KeyMessage) self.assertEqual(key, key_message.key()) self.assertEqual(self.NODE_ID, key_message.source_id()) self.assertEqual(test_network_num, key_message.network_num()) self.assertEqual(self.HASH, key_message.block_hash()) block_holding_message = self.create_message_successfully( BlockHoldingMessage(self.HASH, test_network_num, self.NODE_ID), BlockHoldingMessage) self.assertEqual(self.NODE_ID, block_holding_message.source_id()) self.assertEqual(test_network_num, block_holding_message.network_num()) self.assertEqual(self.HASH, block_holding_message.block_hash()) get_txs = [1, 2, 3] get_txs_message = self.create_message_successfully( GetTxsMessage(get_txs), GetTxsMessage) self.assertEqual(get_txs, get_txs_message.get_short_ids()) txs = [ TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")), bytearray(4), 1), TransactionInfo(Sha256Hash(crypto.double_sha256(b"234")), bytearray(8), 2) ] txs_message = self.create_message_successfully(TxsMessage(txs), TxsMessage) result_txs = txs_message.get_txs() for i, result_tx in enumerate(result_txs): self.assertEqual(txs[i].hash, result_tx.hash) self.assertEqual(txs[i].contents, result_tx.contents) self.assertEqual(txs[i].short_id, result_tx.short_id) get_tx_contents_message = self.create_message_successfully( GetTxContentsMessage(test_network_num, sid), GetTxContentsMessage) self.assertEqual(sid, get_tx_contents_message.get_short_id()) self.assertEqual(test_network_num, get_tx_contents_message.network_num()) tx_info = TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")), bytearray(4), 1) tx_contents_message = self.create_message_successfully( TxContentsMessage(test_network_num, tx_info), TxContentsMessage) self.assertEqual(test_network_num, tx_contents_message.network_num()) result_tx_info = tx_contents_message.get_tx_info() self.assertEqual(tx_info.hash, result_tx_info.hash) self.assertEqual(tx_info.contents, result_tx_info.contents) self.assertEqual(tx_info.short_id, result_tx_info.short_id) short_ids = [1, 2, 33, 4444, 1234] block_hash = Sha256Hash(helpers.generate_bytearray(32)) get_block_txs_message: GetCompressedBlockTxsMessage = self.create_message_successfully( GetCompressedBlockTxsMessage(self.NETWORK_NUM, block_hash, short_ids), GetCompressedBlockTxsMessage) self.assertEqual(self.NETWORK_NUM, get_block_txs_message.network_num()) self.assertEqual(block_hash, get_block_txs_message.block_hash()) self.assertEqual(len(short_ids), len(get_block_txs_message)) self.assertEqual(short_ids, get_block_txs_message.get_short_ids()) txs_info = [ TransactionInfo(Sha256Hash(helpers.generate_bytearray(32)), helpers.generate_bytearray(200), 111), TransactionInfo(Sha256Hash(helpers.generate_bytearray(32)), helpers.generate_bytearray(300), 222), TransactionInfo(Sha256Hash(helpers.generate_bytearray(32)), helpers.generate_bytearray(400), 333) ] block_txs_message: CompressedBlockTxsMessage = self.create_message_successfully( CompressedBlockTxsMessage(self.NETWORK_NUM, block_hash, txs_info), CompressedBlockTxsMessage) self.assertEqual(self.NETWORK_NUM, block_txs_message.network_num()) self.assertEqual(block_hash, block_txs_message.block_hash()) self.assertEqual(len(txs_info), len(block_txs_message)) parsed_txs = block_txs_message.get_txs() for index in range(len(txs_info)): self.assertEqual(parsed_txs[index].short_id, txs_info[index].short_id) self.assertEqual(parsed_txs[index].contents, txs_info[index].contents) self.assertEqual(parsed_txs[index].hash, txs_info[index].hash)
def test_create_message_success_all_types(self): test_network_num = 10 test_protocol_version = bloxroute_version_manager.CURRENT_PROTOCOL_VERSION hello_message = self.create_message_successfully(HelloMessage(protocol_version=test_protocol_version, network_num=test_network_num, node_id=self.NODE_ID ), HelloMessage) self.assertEqual(test_protocol_version, hello_message.protocol_version()) self.assertEqual(test_network_num, hello_message.network_num()) self.assertEqual(self.NODE_ID, hello_message.node_id()) self.create_message_successfully(AckMessage(), AckMessage) self.create_message_successfully(PingMessage(), PingMessage) self.create_message_successfully(PongMessage(), PongMessage) blob = bytearray(4) broadcast_message = self.create_message_successfully(BroadcastMessage(self.HASH, network_num=test_network_num, is_encrypted=True, source_id=self.NODE_ID, blob=blob), BroadcastMessage) self.assertEqual(self.HASH, broadcast_message.block_hash()) self.assertEqual(test_network_num, broadcast_message.network_num()) self.assertEqual(self.NODE_ID, broadcast_message.source_id()) self.assertTrue(broadcast_message.is_encrypted()) self.assertEqual(blob, broadcast_message.blob().tobytes()) sid = 12 tx_val = bytes(1 for _ in range(5)) tx_message = self.create_message_successfully(TxMessage(self.HASH, network_num=test_network_num, source_id=self.NODE_ID, short_id=sid, tx_val=tx_val), TxMessage) self.assertEqual(self.HASH, tx_message.tx_hash()) self.assertEqual(self.NODE_ID, tx_message.source_id()) self.assertEqual(sid, tx_message.short_id()) self.assertEqual(test_network_num, tx_message.network_num()) self.assertEqual(tx_val, tx_message.tx_val()) key = bytearray(1 for _ in range(KEY_SIZE)) key_message = self.create_message_successfully( KeyMessage(self.HASH, test_network_num, self.NODE_ID, bytearray(1 for _ in range(KEY_SIZE))), KeyMessage ) self.assertEqual(key, key_message.key()) self.assertEqual(self.NODE_ID, key_message.source_id()) self.assertEqual(test_network_num, key_message.network_num()) self.assertEqual(self.HASH, key_message.block_hash()) block_holding_message = self.create_message_successfully( BlockHoldingMessage(self.HASH, test_network_num, self.NODE_ID), BlockHoldingMessage ) self.assertEqual(self.NODE_ID, block_holding_message.source_id()) self.assertEqual(test_network_num, block_holding_message.network_num()) self.assertEqual(self.HASH, block_holding_message.block_hash()) get_txs = [1, 2, 3] get_txs_message = self.create_message_successfully(GetTxsMessage(get_txs), GetTxsMessage) self.assertEqual(get_txs, get_txs_message.get_short_ids()) txs = [TransactionInfo(Sha256Hash(crypto.double_sha256(b"123")), bytearray(4), 1), TransactionInfo(Sha256Hash(crypto.double_sha256(b"234")), bytearray(8), 2)] txs_message = self.create_message_successfully(TxsMessage(txs), TxsMessage) result_txs = txs_message.get_txs() for i, result_tx in enumerate(result_txs): self.assertEqual(txs[i].hash, result_tx.hash) self.assertEqual(txs[i].contents, result_tx.contents) self.assertEqual(txs[i].short_id, result_tx.short_id)