def setUp(self): self.node = MockGatewayNode(gateway_helpers.get_gateway_opts(8000)) self.node_conn = cast( AbstractGatewayBlockchainConnection, MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8002), self.node)) self.node.blockchain_peers.add( BlockchainPeerInfo(self.node_conn.peer_ip, self.node_conn.peer_port)) self.node_conn_2 = cast( AbstractGatewayBlockchainConnection, MockConnection( MockSocketConnection(2, self.node, ip_address=LOCALHOST, port=8003), self.node)) self.node.blockchain_peers.add( BlockchainPeerInfo(self.node_conn_2.peer_ip, self.node_conn_2.peer_port)) self.node_conn_3 = cast( AbstractGatewayBlockchainConnection, MockConnection( MockSocketConnection(3, self.node, ip_address=LOCALHOST, port=8004), self.node)) self.node.blockchain_peers.add( BlockchainPeerInfo(self.node_conn_3.peer_ip, self.node_conn_3.peer_port))
def test_delete_removes_multiple_types(self): class TestConnectionType(SerializableFlag): A = auto() B = auto() AB = A | B conn = MockConnection( MockSocketConnection(1, node=self.node1, ip_address=LOCALHOST, port=8000), self.node1) conn.CONNECTION_TYPE = TestConnectionType.AB self.conn_pool1.add(self.fileno1, LOCALHOST, 8000, conn) self.assertIn( conn, self.conn_pool1.get_by_connection_types([TestConnectionType.A])) self.assertIn( conn, self.conn_pool1.get_by_connection_types([TestConnectionType.B])) self.conn_pool1.delete(conn) self.assertNotIn( conn, self.conn_pool1.get_by_connection_types([TestConnectionType.A])) self.assertNotIn( conn, self.conn_pool1.get_by_connection_types([TestConnectionType.B]))
async def test_remove_blockchain_peer(self): conn = MockConnection( MockSocketConnection(9, self.gateway_node, ip_address="127.0.0.1", port=30302), self.gateway_node) conn.mark_for_close = MagicMock() self.gateway_node.connection_pool.add(9, "127.0.0.1", 30302, conn) self.gateway_node.blockchain_peers.add( BlockchainPeerInfo( "127.0.0.1", 30302, "d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396" )) result = await self.request( BxJsonRpcRequest( "9", RpcRequestType.REMOVE_BLOCKCHAIN_PEER, { "peer": "enode://d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396@127.0.0.1:30302" })) self.assertNotIn(BlockchainPeerInfo("127.0.0.1", 30302), self.gateway_node.blockchain_peers) conn.mark_for_close.assert_called_once_with(False) self.assertEqual("9", result.id) self.assertIsNone(result.error) self.assertEqual({"removed_peer": "127.0.0.1:30302"}, result.result)
def setUp(self): self.conn_pool1 = ConnectionPool() self.fileno1 = 1 self.ip1 = "123.123.123.123" self.port1 = 1000 self.node1 = MockNode( helpers.get_common_opts(1001, external_ip="128.128.128.128")) self.node_id1 = str(uuid.uuid1()) self.conn1 = MockConnection( MockSocketConnection(self.fileno1, ip_address=self.ip1, port=self.port1), self.node1) self.fileno2 = 5 self.ip2 = "234.234.234.234" self.port2 = 2000 self.node2 = MockNode( helpers.get_common_opts(1003, external_ip="321.321.321.321")) self.node_id2 = str(uuid.uuid1()) self.conn2 = MockConnection( MockSocketConnection(self.fileno2, ip_address=self.ip2, port=self.port2), self.node2) self.fileno3 = 6 self.ip3 = "234.234.234.234" self.port3 = 3000 self.node3 = MockNode( helpers.get_common_opts(1003, external_ip="213.213.213.213.")) self.node_id3 = str(uuid.uuid1()) self.conn3 = MockConnection( MockSocketConnection(self.fileno3, ip_address=self.ip3, port=self.port3), self.node3)
def setUp(self): self.node = MockGatewayNode( gateway_helpers.get_gateway_opts( 8000, max_block_interval_s=gateway_constants.MAX_INTERVAL_BETWEEN_BLOCKS_S, blockchain_message_ttl=TTL ) ) self.node_conn = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8002), self.node ) self.node.blockchain_peers.add(BlockchainPeerInfo(self.node_conn.peer_ip, self.node_conn.peer_port)) self.block_queuing_service = TestPushBlockQueuingService(self.node, self.node_conn) self.node.block_queuing_service_manager.add_block_queuing_service(self.node_conn, self.block_queuing_service) self.node_conn.enqueue_msg = MagicMock() self.node_conn_2 = MockConnection( MockSocketConnection(2, self.node, ip_address=LOCALHOST, port=8003), self.node ) self.node.blockchain_peers.add(BlockchainPeerInfo(self.node_conn_2.peer_ip, self.node_conn_2.peer_port)) self.block_queuing_service_2 = TestPushBlockQueuingService(self.node, self.node_conn_2) self.node.block_queuing_service_manager.add_block_queuing_service(self.node_conn_2, self.block_queuing_service_2) self.node_conn_2.enqueue_msg = MagicMock() self.blockchain_connections = [self.node_conn, self.node_conn_2] self.block_queuing_services = [self.block_queuing_service, self.block_queuing_service_2]
def setUp(self): opts = gateway_helpers.get_gateway_opts(8000, include_default_btc_args=True) if opts.use_extensions: helpers.set_extensions_parallelism(opts.thread_pool_parallelism_degree) node_ssl_service = MockNodeSSLService(BtcGatewayNode.NODE_TYPE, MagicMock()) self.gateway_node = BtcGatewayNode(opts, node_ssl_service) self.gateway_node.opts.has_fully_updated_tx_service = True self.sut = BtcRelayConnection( MockSocketConnection(1, node=self.gateway_node, ip_address=LOCALHOST, port=8001), self.gateway_node ) self.gateway_node.message_converter = converter_factory.create_btc_message_converter( 12345, self.gateway_node.opts ) self.node_conn = MockConnection( MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8002), self.gateway_node ) self.gateway_node.connection_pool.add(1, LOCALHOST, 8002, self.node_conn) gateway_helpers.add_blockchain_peer(self.gateway_node, self.node_conn) self.node_conn_2 = MockConnection( MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8003), self.gateway_node ) self.gateway_node.connection_pool.add(1, LOCALHOST, 8003, self.node_conn_2) gateway_helpers.add_blockchain_peer(self.gateway_node, self.node_conn_2) self.blockchain_connections = [self.node_conn, self.node_conn_2] self.node_conn.enqueue_msg = MagicMock() self.node_conn_2.enqueue_msg = MagicMock() self.gateway_node.broadcast = MagicMock() self.sut.enqueue_msg = MagicMock() gateway_transaction_stats_service.set_node(self.gateway_node) self.gateway_node.has_active_blockchain_peer = MagicMock(return_value=True)
def test_make_sync_request(self): other_connections = [] for i in range(2, 5): fileno = i port = 8000 + i connection = MockConnection(fileno, (LOCALHOST, port), self.node) connection.state |= ConnectionState.ESTABLISHED connection.enqueue_msg = MagicMock() self.node.connection_pool.add(fileno, LOCALHOST, port, connection) other_connections.append(connection) preferred_connection = other_connections[0] self.node.peer_gateways.add(OutboundPeerModel(LOCALHOST, 8002)) request = GetHeadersBtcMessage(self.MAGIC, self.VERSION, self.HASHES, self.HASH2) self.blockchain_sync_service.make_sync_request(request.command(), request) request_message = BlockchainSyncRequestMessage(request.command(), request.rawbytes()) preferred_connection.enqueue_msg.assert_called_once_with( request_message, prepend=True) time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCKCHAIN_SYNC_BROADCAST_DELAY_S) self.node.alarm_queue.fire_alarms() self.assertIn(request_message, self.node.broadcast_messages)
def _add_connection( self, fileno: int, port: int, network_num: int, connection_type=MockConnection.CONNECTION_TYPE) -> MockConnection: conn = MockConnection(MockSocketConnection(fileno), (LOCALHOST, port), self.node) conn.network_num = network_num conn.state = ConnectionState.ESTABLISHED conn.CONNECTION_TYPE = connection_type self.connection_pool.add(fileno, LOCALHOST, port, conn) return conn
def test_delete_removes_multiple_types(self): class TestConnectionType(Flag): A = auto() B = auto() AB = A | B conn = MockConnection(MockSocketConnection(), (LOCALHOST, 8000), self.node1) conn.CONNECTION_TYPE = TestConnectionType.AB self.conn_pool1.add(self.fileno1, LOCALHOST, 8000, conn) self.assertIn(conn, self.conn_pool1.get_by_connection_type(TestConnectionType.A)) self.assertIn(conn, self.conn_pool1.get_by_connection_type(TestConnectionType.B)) self.conn_pool1.delete(conn) self.assertNotIn(conn, self.conn_pool1.get_by_connection_type(TestConnectionType.A)) self.assertNotIn(conn, self.conn_pool1.get_by_connection_type(TestConnectionType.B))
def test_propagate_block_to_network_unencrypted_block(self): self.node.opts.encrypt_blocks = False block_message = helpers.generate_bytearray(50) block_info = BlockInfo( Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN)), [], datetime.datetime.utcnow(), datetime.datetime.utcnow(), 0, 1, helpers.generate_bytearray(crypto.SHA256_HASH_LEN), helpers.generate_bytearray(crypto.SHA256_HASH_LEN), 0, 0, 0, []) connection = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=9000), self.node) self.neutrality_service.propagate_block_to_network( block_message, connection, block_info) self.assertEqual(1, len(self.node.broadcast_messages)) broadcast_message, connection_types = self.node.broadcast_messages[0] # self.assertTrue(any(ConnectionType.RELAY_BLOCK & connection_type for connection_type in connection_types)) self.assertTrue( all(ConnectionType.RELAY_BLOCK in connection_type for connection_type in connection_types)) self.assertEqual(block_info.block_hash, broadcast_message.block_hash()) self.assertNotIn(block_info.block_hash, self.node.in_progress_blocks._cache) self.assertNotIn(broadcast_message.block_hash(), self.neutrality_service._receipt_tracker)
def test_add_special_objects(self): node1 = MockNode(get_common_opts(1001, external_ip="128.128.128.128")) conn1 = MockConnection( MockSocketConnection(1, node1, ip_address="123.123.123.123", port=1000), node1) conn1.inputbuf.add_bytes(bytearray(b"0000" * 10)) conn1.outputbuf.prepend_msgbytes(bytearray(b"1111" * 100)) total_special_size, ids = memory_utils.get_special_size(conn1) self.assertTrue(ids) self.assertTrue(id(conn1.inputbuf.input_list) in ids) self.assertTrue(id(conn1.outputbuf.output_msgs) in ids) expected_special_size = memory_utils.get_special_size( conn1.inputbuf.input_list).size expected_special_size += memory_utils.get_special_size( conn1.outputbuf.output_msgs).size self.assertEqual(total_special_size, expected_special_size) s, s_id = memory_utils.get_special_size(conn1.outputbuf.output_msgs) self.assertNotEqual(s, 0) s, ids = memory_utils.get_special_size(conn1.outputbuf.output_msgs, ids) self.assertEqual(s, 0)
def setUp(self): opts = gateway_helpers.get_gateway_opts(8000, include_default_ont_args=True) if opts.use_extensions: helpers.set_extensions_parallelism( opts.thread_pool_parallelism_degree) node_ssl_service = MockNodeSSLService(OntGatewayNode.NODE_TYPE, MagicMock()) self.gateway_node = OntGatewayNode(opts, node_ssl_service) self.gateway_node.opts.has_fully_updated_tx_service = True self.gateway_node.opts.is_consensus = False self.sut = OntRelayConnection( MockSocketConnection(node=self.gateway_node, ip_address=LOCALHOST, port=8001), self.gateway_node) self.gateway_node.node_conn = MockConnection( MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8002), self.gateway_node) self.gateway_node_sut = OntNodeConnectionProtocol( self.gateway_node.node_conn) self.gateway_node.message_converter = converter_factory.create_ont_message_converter( 12345, self.gateway_node.opts) self.gateway_node.node_conn.state = ConnectionState.ESTABLISHED self.gateway_node.send_msg_to_node = MagicMock() self.sut.enqueue_msg = MagicMock() gateway_transaction_stats_service.set_node(self.gateway_node)
def test_remove_blockchain_connection_and_add_new(self): self._add_connections() new_desc6 = "1.1.1.1 80" new_ip6 = new_desc6.split()[0] new_port6 = new_desc6.split()[1] new_fileno6 = "10" new_node6 = MockNode(helpers.get_common_opts(1004, external_ip="214.215.216.217")) new_conn6 = MockConnection( MockSocketConnection(new_fileno6, new_node6, ip_address=new_ip6, port=int(new_port6)), new_node6 ) self.conn_pool.delete(self.conn3) self.blockchain_peers.add(BlockchainPeerInfo(new_ip6, int(new_port6))) self.conn_pool.add(int(new_fileno6), new_ip6, int(new_port6), new_conn6) update(self.conn_pool, True, self.source_version, self.ip_address, self.continent, self.country, False, self.blockchain_peers, self.account_id, self.quota_level) summary_loaded, _, _, network_loaded = self._load_status_file() self.assertEqual(summary_loaded, network_loaded.get_summary(self.ip_address, self.continent, self.country, False, self.account_id, self.quota_level)) self.assertEqual(summary_loaded.gateway_status, GatewayStatus.WITH_ERRORS) self.assertEqual(summary_loaded.account_info, summary.gateway_status_get_account_info(None)) self.assertEqual(summary_loaded.quota_level, summary.gateway_status_get_quota_level(self.quota_level)) self.assertEqual( summary_loaded.blockchain_node_connection_states, { f"{new_ip6} {new_port6}": ConnectionState.ESTABLISHED, f"{self.ip3} {self.port3}": ConnectionState.DISCONNECTED, f"{self.ip5} {self.port5}": ConnectionState.ESTABLISHED, } )
def setUp(self): self.node = MockGatewayNode(gateway_helpers.get_gateway_opts(8000)) self.node.connection_pool = ConnectionPool() self.blockchain_sync_service = BlockchainSyncService( self.node, {BtcMessageType.GET_HEADERS: BtcMessageType.HEADERS}) self.blockchain_connection = MockConnection(1, (LOCALHOST, 8001), self.node) self.blockchain_connection.state |= ConnectionState.ESTABLISHED self.node.node_conn = self.blockchain_connection self.alarms = []
def setUp(self): self.node = MockGatewayNode( gateway_helpers.get_gateway_opts( 8000, max_block_interval_s=BLOCK_INTERVAL)) self.node.block_parts_storage = ExpiringDict( self.node.alarm_queue, gateway_constants.MAX_BLOCK_CACHE_TIME_S, "eth_block_queue_parts", ) self.node.alarm_queue = AlarmQueue() self.node.set_known_total_difficulty = MagicMock() self.block_processing_service = EthBlockProcessingService(self.node) self.node.block_processing_service = self.block_processing_service self.node_connection = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8002), self.node) self.node_connection.is_active = MagicMock(return_value=True) self.block_queuing_service = EthBlockQueuingService( self.node, self.node_connection) self.node.block_queuing_service_manager.add_block_queuing_service( self.node_connection, self.block_queuing_service) self.node_connection.enqueue_msg = MagicMock() self.node_connection_2 = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8003), self.node) self.node_connection_2.is_active = MagicMock(return_value=True) self.block_queuing_service_2 = EthBlockQueuingService( self.node, self.node_connection_2) self.node.block_queuing_service_manager.add_block_queuing_service( self.node_connection_2, self.block_queuing_service_2) self.node_connection_2.enqueue_msg = MagicMock() self.blockchain_connections = [ self.node_connection, self.node_connection_2 ] self.block_queuing_services = [ self.block_queuing_service, self.block_queuing_service_2 ] time.time = MagicMock(return_value=time.time())
def test_remote_sync_request(self): self.node.send_msg_to_node = MagicMock() remote_caller_connection1 = MockConnection(1, (LOCALHOST, 8001), self.node) remote_caller_connection1.enqueue_msg = MagicMock() remote_caller_connection2 = MockConnection(2, (LOCALHOST, 8002), self.node) remote_caller_connection2.enqueue_msg = MagicMock() remote_blockchain_message = GetHeadersBtcMessage( self.MAGIC, self.VERSION, self.HASHES, self.HASH2) self.blockchain_sync_service.process_remote_sync_request( remote_blockchain_message.command(), remote_blockchain_message, remote_caller_connection1) self.blockchain_sync_service.process_remote_sync_request( remote_blockchain_message.command(), remote_blockchain_message, remote_caller_connection2) self.node.send_msg_to_node.assert_called_once_with( remote_blockchain_message) local_blockchain_message = HeadersBtcMessage(self.MAGIC, headers=[]) self.blockchain_sync_service.process_local_sync_response( local_blockchain_message.command(), local_blockchain_message) local_response = BlockchainSyncResponseMessage( local_blockchain_message.command(), local_blockchain_message.rawbytes()) remote_caller_connection1.enqueue_msg.assert_called_once_with( local_response)
def setUp(self): self.node = MockGatewayNode(gateway_helpers.get_gateway_opts(8000)) self.sut = BlockProcessingService(self.node) self.node.block_processing_service = self.sut self.node.neutrality_service = MagicMock(spec=NeutralityService) self.node.block_recovery_service = MagicMock(spec=BlockRecoveryService) self.node.block_queuing_service = MagicMock( spec=PushBlockQueuingService) self.dummy_connection = MockConnection( MockSocketConnection(0, self.node, ip_address=LOCALHOST, port=9000), self.node)
def _add_connection(self, fileno: int, port: int, network_num: int, connection_type=MockConnection.CONNECTION_TYPE) -> MockConnection: conn = MockConnection(MockSocketConnection(fileno, self.node, ip_address=LOCALHOST, port=port), self.node) conn.network_num = network_num conn.on_connection_established() conn.CONNECTION_TYPE = connection_type self.connection_pool.add(fileno, LOCALHOST, port, conn) return conn
def broadcast(self, msg, broadcasting_conn=None, prepend_to_queue=False, connection_types=None): if connection_types is None: connection_types = [ConnectionType.RELAY_ALL] if len(connection_types) == 1 and connection_types[ 0] == ConnectionType.BLOCKCHAIN_NODE: self.broadcast_to_nodes_messages.append(msg) else: self.broadcast_messages.append((msg, connection_types)) return [ MockConnection( MockSocketConnection(1, ip_address="123.123.123.123", port=1000), self) ]
def test_propagate_block_to_network_encrypted_block(self): self.node.opts.encrypt_blocks = True block_message = helpers.generate_bytearray(50) connection = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=9000), self.node) self.neutrality_service.propagate_block_to_network( block_message, connection) self.assertEqual(1, len(self.node.broadcast_messages)) broadcast_message, connection_types = self.node.broadcast_messages[0] self.assertTrue(ConnectionType.RELAY_BLOCK in connection_types[0]) raw_block_hash = bytes(broadcast_message.block_hash().binary) cache_item = self.node.in_progress_blocks._cache.get(raw_block_hash) self.assertEqual( cache_item.payload, crypto.symmetric_decrypt(cache_item.key, broadcast_message.blob().tobytes())) self.assertIn(broadcast_message.block_hash(), self.neutrality_service._receipt_tracker)
def setUp(self) -> None: crypto_utils.recover_public_key = MagicMock(return_value=bytes(32)) pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True, pub_key=pub_key) if opts.use_extensions: helpers.set_extensions_parallelism() node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.node_conn = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8002), self.node) self.node.connection_pool.add(1, LOCALHOST, 8002, self.node_conn) gateway_helpers.add_blockchain_peer(self.node, self.node_conn) self.block_queuing_service = self.node.block_queuing_service_manager.get_designated_block_queuing_service( ) self.sut = EthNewBlockFeed(self.node)
def test_get_by_connection_types_performance(self): log_config.set_level([ "bxcommon.connections.abstract_node", "bxcommon.services.transaction_service" ], LogLevel.INFO) conn_pool = ConnectionPool() self.conn1.CONNECTION_TYPE = ConnectionType.EXTERNAL_GATEWAY self.conn2.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK self.conn3.CONNECTION_TYPE = ConnectionType.RELAY_ALL number_of_iteration = 100 for i in range(40): ip = f"{i}.{i}.{i}.{i}" node = MockNode(helpers.get_common_opts(i, external_ip=ip)) conn = MockConnection( MockSocketConnection(i, ip_address=ip, port=i), node) if i % 7 == 0: conn.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK elif i % 5 == 0: conn.CONNECTION_TYPE = ConnectionType.RELAY_TRANSACTION elif i % 3 == 0: conn.CONNECTION_TYPE = ConnectionType.INTERNAL_GATEWAY else: conn.CONNECTION_TYPE = ConnectionType.EXTERNAL_GATEWAY conn_pool.add(i, ip, i, conn) timeit_get_by_connections_types_one_type = timeit.timeit( lambda: conn_pool.get_by_connection_types([ConnectionType.GATEWAY] ), number=number_of_iteration) timeit_get_by_connections_types_two_types = timeit.timeit( lambda: conn_pool.get_by_connection_types( [ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION]), number=number_of_iteration) print( f"\ntimeit_get_by_connections_types_one_type # 2: {timeit_get_by_connections_types_one_type * 1000 / number_of_iteration:.4f}ms, " f"#connections: {len(list(conn_pool.get_by_connection_types([ConnectionType.GATEWAY])))}" f"\ntimeit_get_by_connections_types_two_types # 2: {timeit_get_by_connections_types_two_types * 1000 / number_of_iteration:.4f}ms, " f"#connections: {len(list(conn_pool.get_by_connection_types([ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION])))}" ) print("*****") for c in conn_pool.get_by_connection_types( [ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION]): print(f"connection: {c}, connection type: {c.CONNECTION_TYPE}")
def _test_mark_blocks_and_request_cleanup(self): node_conn = MockConnection( MockSocketConnection(0, self.node, ip_address=LOCALHOST, port=9000), self.node) self.node.get_any_active_blockchain_connection = MagicMock( return_value=node_conn) marked_block = BtcObjectHash( binary=helpers.generate_bytearray(btc_constants.BTC_SHA_HASH_LEN)) prev_block = BtcObjectHash( binary=helpers.generate_bytearray(btc_constants.BTC_SHA_HASH_LEN)) tracked_blocks = [] self.cleanup_service.on_new_block_received(marked_block, prev_block) self.transaction_service.track_seen_short_ids(marked_block, []) for _ in range(self.block_confirmations_count - 1): tracked_block = BtcObjectHash(binary=helpers.generate_bytearray( btc_constants.BTC_SHA_HASH_LEN)) self.transaction_service.track_seen_short_ids(tracked_block, []) tracked_blocks.append(tracked_block) unmarked_block = BtcObjectHash( binary=helpers.generate_bytearray(btc_constants.BTC_SHA_HASH_LEN)) self.assertIsNone(self.cleanup_service.last_confirmed_block) self.cleanup_service.mark_blocks_and_request_cleanup( [marked_block, *tracked_blocks]) self.assertEqual(marked_block, self.cleanup_service.last_confirmed_block) self.assertTrue( self.cleanup_service.is_marked_for_cleanup(marked_block)) self.assertFalse( self.cleanup_service.is_marked_for_cleanup(unmarked_block)) self.assertEqual(marked_block, self.cleanup_service.last_confirmed_block) msg = node_conn.enqueued_messages[0] self.assertEqual(1, msg.count()) self.assertEqual((InventoryType.MSG_BLOCK, marked_block), next(iter(msg)))
def setUp(self): self.conn_pool = ConnectionPool() self.source_version = "v1.0.0" self.ip_address = "0.0.0.0" self.continent = "NA" self.country = "United States" self.account_id = None self.fileno1 = 1 self.ip1 = "123.123.123.123" self.port1 = 1000 self.node1 = MockNode( helpers.get_common_opts(1001, external_ip="128.128.128.128")) self.node_id1 = str(uuid.uuid1()) self.conn1 = MockConnection( MockSocketConnection(self.fileno1, self.node1, ip_address=self.ip1, port=self.port1), self.node1) self.conn1.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK self.fileno2 = 5 self.ip2 = "234.234.234.234" self.port2 = 2000 self.node2 = MockNode( helpers.get_common_opts(1003, external_ip="321.321.321.321")) self.node_id2 = str(uuid.uuid1()) self.conn2 = MockConnection( MockSocketConnection(self.fileno2, self.node2, ip_address=self.ip2, port=self.port2), self.node2) self.conn2.CONNECTION_TYPE = ConnectionType.RELAY_TRANSACTION self.fileno3 = 6 self.ip3 = "234.234.234.234" self.port3 = 3000 self.node3 = MockNode( helpers.get_common_opts(1003, external_ip="213.213.213.213")) self.node_id3 = str(uuid.uuid1()) self.conn3 = MockConnection( MockSocketConnection(self.fileno3, self.node3, ip_address=self.ip3, port=self.port3), self.node3) self.conn3.CONNECTION_TYPE = ConnectionType.BLOCKCHAIN_NODE self.fileno4 = 8 self.ip4 = "111.222.111.222" self.port4 = 3000 self.node4 = MockNode( helpers.get_common_opts(1003, external_ip="101.101.101.101")) self.node_id4 = str(uuid.uuid1()) self.conn4 = MockConnection( MockSocketConnection(self.fileno4, self.node4, ip_address=self.ip4, port=self.port4), self.node4) self.conn4.CONNECTION_TYPE = ConnectionType.REMOTE_BLOCKCHAIN_NODE self.quota_level = 0 initialize(False, self.source_version, self.ip_address, self.continent, self.country, False, self.account_id, self.quota_level) path = config.get_data_file(STATUS_FILE_NAME) self.addCleanup(os.remove, path)
def broadcast(self, msg, broadcasting_conn=None, prepend_to_queue=False, connection_types=None): if connection_types is None: connection_types = [ConnectionType.RELAY_ALL] self.broadcast_messages.append((msg, connection_types)) return [MockConnection(MockSocketConnection(1, ip_address="123.123.123.123", port=1000), self)]
def build_connection(self, socket_connection): return MockConnection(socket_connection, self)
def setUp(self) -> None: self.node = MockNode( helpers.get_common_opts(1001, external_ip="128.128.128.128")) self.tracker = MessageTracker( MockConnection(MockSocketConnection(), self.node)) self.output_buffer = OutputBuffer(enable_buffering=True)
def build_connection(self, socket_connection, ip, port, from_me=False): return MockConnection(socket_connection, (ip, port), self, from_me)