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))
class BtcBlockQueuingServiceTest(AbstractTestCase):
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000, max_block_interval=0)
)
self.node_connection = Mock()
self.node_connection.is_active = MagicMock(return_value=True)
self.node.set_known_total_difficulty = MagicMock()
self.node.node_conn = self.node_connection
self.block_queuing_service = BtcBlockQueuingService(self.node)
self.node.block_queuing_service = self.block_queuing_service
self.node.block_cleanup_service = BtcNormalBlockCleanupService(self.node, 1)
self.block_hashes = []
self.block_msg = self._get_sample_block()
self.block_queuing_service.store_block_data(self.block_msg.block_hash(), self.block_msg)
self.node.get_tx_service().track_seen_short_ids(self.block_msg.block_hash(), [])
def _get_sample_block(self, file_path=__file__):
root_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(file_path))))
with open(os.path.join(root_dir, "btc_sample_block.txt")) as sample_file:
btc_block = sample_file.read().strip("\n")
buf = bytearray(convert.hex_to_bytes(btc_block))
parsed_block = BlockBtcMessage(buf=buf)
return parsed_block
def test_tracked_block_cleanup(self):
tx_service = self.node.get_tx_service()
self.assertEqual(1, len(tx_service.get_tracked_blocks()))
self.node.block_cleanup_service.block_cleanup_request(self.block_msg.block_hash())
time.time = MagicMock(return_value=time.time() + constants.MIN_SLEEP_TIMEOUT)
self.node.alarm_queue.fire_alarms()
self.assertEqual(0, len(tx_service.get_tracked_blocks()))
def setUp(self) -> None:
opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True)
self.node = MockGatewayNode(opts)
self.connection = MagicMock(spec=AbstractGatewayBlockchainConnection)
self.connection.node = self.node
self.connection.is_active = MagicMock(return_value=True)
self.connection.network_num = 5
self.connection.format_connection_desc = "127.0.0.1:12345 - B"
self.node.set_known_total_difficulty = MagicMock()
self.node.node_conn = self.connection
self.node.message_converter = EthNormalMessageConverter()
self.cleanup_service = EthNormalBlockCleanupService(
self.node, NETWORK_NUM
)
self.node.block_cleanup_service = self.cleanup_service
self.node.block_processing_service = EthBlockProcessingService(
self.node
)
self.node.block_processing_service.queue_block_for_processing = MagicMock()
self.node.block_queuing_service = EthBlockQueuingService(self.node)
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111)
)
dummy_public_key = crypto_utils.private_to_public_key(dummy_private_key)
self.sut = EthNodeConnectionProtocol(
self.connection, True, dummy_private_key, dummy_public_key
)
self.sut._waiting_checkpoint_headers_request = False
async def setUp(self) -> None:
self.gateway_node = MockGatewayNode(self.get_gateway_opts())
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service",
self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S
)
self.gateway_node.requester.start()
self.gateway_node.account_id = ACCOUNT_ID
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000, max_block_interval_s=0))
self.node.block_parts_storage = ExpiringDict(
self.node.alarm_queue,
gateway_constants.MAX_BLOCK_CACHE_TIME_S,
"eth_block_queue_parts",
)
self.node_connection = Mock()
self.node_connection.is_active = MagicMock(return_value=True)
self.node.set_known_total_difficulty = MagicMock()
self.node_conn = self.node_connection
self.block_queuing_service = EthBlockQueuingService(
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.block_hashes = []
self.block_messages = []
self.block_headers = []
self.block_bodies = []
# block numbers: 1000-1019
prev_block_hash = None
for i in range(20):
block_message = InternalEthBlockInfo.from_new_block_msg(
mock_eth_messages.new_block_eth_protocol_message(
i, i + 1000, prev_block_hash=prev_block_hash))
block_hash = block_message.block_hash()
self.block_hashes.append(block_hash)
self.block_messages.append(block_message)
block_parts = block_message.to_new_block_parts()
self.block_headers.append(
BlockHeadersEthProtocolMessage.from_header_bytes(
block_parts.block_header_bytes).get_block_headers()[0])
self.block_bodies.append(
BlockBodiesEthProtocolMessage.from_body_bytes(
block_parts.block_body_bytes).get_blocks()[0])
self.node.block_queuing_service_manager.push(
block_hash, block_message)
prev_block_hash = block_hash
for block_hash in self.block_hashes:
self.block_queuing_service.remove_from_queue(block_hash)
self.block_queuing_service.best_sent_block = (1019,
self.block_hashes[-1],
time.time())
self.block_queuing_service.best_accepted_block = (
1019, self.block_hashes[-1])
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 = []
async def setUp(self) -> None:
self.gateway_node = MockGatewayNode(self.get_gateway_opts())
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service", self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S)
self.gateway_node.requester.start()
self.gateway_node.account_id = ACCOUNT_ID
self.node_endpoint_1 = IpEndpoint("127.0.0.1", 7000)
self.blockchain_connection_1 = EthBaseConnection(
MockSocketConnection(node=self.gateway_node,
ip_address="127.0.0.1",
port=7000),
cast(EthGatewayNode, self.gateway_node))
self.blockchain_connection_1.state = ConnectionState.ESTABLISHED
async def setUp(self) -> None:
self.feed_service_model = FeedServiceModelBase(
allow_filtering=True, available_fields=["all"])
self.base_feed_service_model = BdnFeedServiceModelConfigBase(
expire_date="2999-01-01", feed=self.feed_service_model)
account_model = BdnAccountModelBase(
"account_id",
"account_name",
"fake_certificate",
tier_name="Developer",
new_transaction_streaming=self.base_feed_service_model,
new_pending_transaction_streaming=self.base_feed_service_model,
on_block_feed=self.base_feed_service_model,
transaction_receipts_feed=self.base_feed_service_model)
gateway_opts = gateway_helpers.get_gateway_opts(8000, ws=True)
gateway_opts.set_account_options(account_model)
self.gateway_node = MockGatewayNode(gateway_opts)
self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY
self.transaction_streamer_peer = OutboundPeerModel(
"127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY)
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service",
self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S,
)
self.gateway_node.requester.start()
self.server = WsServer(constants.LOCALHOST, 8005,
self.gateway_node.feed_manager,
self.gateway_node)
self.ws_uri = f"ws://{constants.LOCALHOST}:8005"
await self.server.start()
self.gateway_node.get_ws_server_status = MagicMock(return_value=True)
def setUp(self):
self.node = MockGatewayNode(gateway_helpers.get_gateway_opts(
8000,
include_default_btc_args=True,
compact_block_min_tx_count=5
))
self.node.block_processing_service = MagicMock()
self.connection = BtcNodeConnection(
MockSocketConnection(node=self.node, ip_address=LOCALHOST, port=123), self.node
)
self.connection.node = self.node
self.connection.peer_ip = LOCALHOST
self.connection.peer_port = 8001
self.connection.network_num = 2
self.sut = BtcNodeConnectionProtocol(self.connection)
full_block_msg = BlockBtcMessage(
buf=bytearray(convert.hex_to_bytes(self.FULL_BLOCK_BYTES_HEX))
)
if self.node.opts.use_extensions:
transaction_service = ExtensionTransactionService(self.node, 0)
else:
transaction_service = TransactionService(self.node, 0)
short_id = 1
for tx in full_block_msg.txns():
tx_hash = btc_common_utils.get_txid(tx)
transaction_service.set_transaction_contents(tx_hash, tx)
transaction_service.assign_short_id(tx_hash, short_id)
short_id += 1
self.sut.connection.node._tx_service = transaction_service
async def setUp(self) -> None:
account_model = BdnAccountModelBase(
"account_id", "account_name", "fake_certificate",
new_transaction_streaming=BdnServiceModelConfigBase(
expire_date=date(2999, 1, 1).isoformat()
)
)
gateway_opts = gateway_helpers.get_gateway_opts(8000, ws=True)
gateway_opts.set_account_options(account_model)
self.gateway_node = MockGatewayNode(gateway_opts)
self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY
self.transaction_streamer_peer = OutboundPeerModel("127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY)
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service",
self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S
)
self.gateway_node.requester.start()
self.server = WsServer(
constants.LOCALHOST, 8005, self.gateway_node.feed_manager, self.gateway_node
)
self.ws_uri = f"ws://{constants.LOCALHOST}:8005"
await self.server.start()
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000,
include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockGatewayNode(opts)
self.node.neutrality_service = MagicMock()
self.connection = BtcNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=LOCALHOST,
port=123), self.node)
gateway_helpers.add_blockchain_peer(self.node, self.connection)
self.tx_hash = BtcObjectHash(buf=helpers.generate_bytearray(32),
length=BTC_SHA_HASH_LEN)
self.block_hash = BtcObjectHash(buf=helpers.generate_bytearray(32),
length=BTC_SHA_HASH_LEN)
self.sut = BtcNodeConnectionProtocol(self.connection)
while self.connection.outputbuf.length > 0:
initial_bytes = self.connection.get_bytes_to_send()
self.connection.advance_sent_bytes(len(initial_bytes))
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000,
include_default_btc_args=True,
include_default_eth_args=True))
self.neutrality_service = NeutralityService(self.node)
self.node.neutrality_service = self.neutrality_service
def setUp(self) -> None:
self._account_model = BdnAccountModelBase(
account_id="",
logical_account_name="",
certificate="",
expire_date=utils_constants.DEFAULT_EXPIRATION_DATE.isoformat(),
cloud_api=BdnServiceModelConfigBase(
msg_quota=None,
permit=BdnServiceModelBase(service_type=BdnServiceType.PERMIT),
expire_date=utils_constants.DEFAULT_EXPIRATION_DATE.isoformat(
),
),
blockchain_protocol="Ethereum",
blockchain_network="Mainnet",
)
self.rpc_port = helpers.get_free_port()
opts = gateway_helpers.get_gateway_opts(
8000,
rpc_port=self.rpc_port,
account_model=self._account_model,
blockchain_protocol="Ethereum",
)
self.node = MockGatewayNode(opts)
self.node.eth_ws_proxy_publisher = MockEthWsProxyPublisher(
None, None, None, self.node)
self.node.eth_ws_proxy_publisher.call_rpc = AsyncMock(
return_value=JsonRpcResponse(request_id=1))
self.sut = EthOnBlockFeed(self.node)
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):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000, max_block_interval_s=0)
)
self.node_connection = Mock()
self.node_connection.is_active = MagicMock(return_value=True)
self.node.set_known_total_difficulty = MagicMock()
self.node.node_conn = self.node_connection
self.block_queuing_service = OntBlockQueuingService(self.node)
self.block_hashes = []
self.block_msg = self._get_sample_block()
self.block_queuing_service.store_block_data(self.block_msg.block_hash(), self.block_msg)
def setUp(self) -> None:
opts = gateway_helpers.get_gateway_opts(8000)
self.node = MockGatewayNode(opts)
self.node.message_converter = EthNormalMessageConverter()
self.connection = helpers.create_connection(EthRelayConnection,
self.node)
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000,
include_default_btc_args=True,
include_default_eth_args=True))
self.relay_connection = AbstractRelayConnection(
MockSocketConnection(node=self.node,
ip_address="127.0.0.1",
port=12345), self.node)
self.blockchain_connection = EthBaseConnection(
MockSocketConnection(node=self.node,
ip_address="127.0.0.1",
port=12345), self.node)
self.node.message_converter = converter_factory.create_eth_message_converter(
self.node.opts)
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
self.blockchain_connection_protocol = EthNodeConnectionProtocol(
self.blockchain_connection, True, dummy_private_key,
dummy_public_key)
self.blockchain_connection.network_num = 0
self.blockchain_connection_protocol.publish_transaction = MagicMock()
self.relay_connection.state = ConnectionState.INITIALIZED
gateway_transaction_stats_service.set_node(self.node)
def setUp(self):
opts = gateway_helpers.get_gateway_opts(
8000,
include_default_eth_args=True,
track_detailed_sent_messages=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockGatewayNode(opts)
self.node.block_processing_service = MagicMock()
self.connection = MagicMock()
gateway_helpers.add_blockchain_peer(self.node, self.connection)
self.connection.node = self.node
self.connection.peer_ip = LOCALHOST
self.connection.peer_port = 8001
self.connection.network_num = 2
self.connection.endpoint = IpEndpoint(self.connection.peer_ip,
self.connection.peer_port)
self.node.blockchain_peers.add(
BlockchainPeerInfo(self.connection.peer_ip,
self.connection.peer_port))
gateway_bdn_performance_stats_service.set_node(self.node)
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
self.sut = EthNodeConnectionProtocol(self.connection, True,
dummy_private_key,
dummy_public_key)
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.block_queuing_service = TestPushBlockQueuingService(self.node)
def setUp(self) -> None:
self.mock_gateway = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000,
rpc_user="******",
rpc_password="******"))
self.rpc_server = GatewayHttpRpcServer(self.mock_gateway)
self.encoded_auth = base64.b64encode(
"user:password".encode("utf-8")).decode("utf-8")
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000, max_block_interval=0)
)
self.node_connection = Mock()
self.node_connection.is_active = MagicMock(return_value=True)
self.node.set_known_total_difficulty = MagicMock()
self.node.node_conn = self.node_connection
self.block_queuing_service = BtcBlockQueuingService(self.node)
self.node.block_queuing_service = self.block_queuing_service
self.node.block_cleanup_service = BtcNormalBlockCleanupService(self.node, 1)
self.block_hashes = []
self.block_msg = self._get_sample_block()
self.block_queuing_service.store_block_data(self.block_msg.block_hash(), self.block_msg)
self.node.get_tx_service().track_seen_short_ids(self.block_msg.block_hash(), [])
async def setUp(self) -> None:
crypto_utils.recover_public_key = MagicMock(return_value=bytes(32))
account_model = BdnAccountModelBase(
"account_id",
"account_name",
"fake_certificate",
new_transaction_streaming=BdnServiceModelConfigBase(
expire_date=date(2999, 1, 1).isoformat()))
self.eth_ws_port = helpers.get_free_port()
self.eth_ws_uri = f"ws://127.0.0.1:{self.eth_ws_port}"
self.eth_ws_server_message_queue = asyncio.Queue()
await self.start_server()
gateway_opts = gateway_helpers.get_gateway_opts(
8000, eth_ws_uri=self.eth_ws_uri, ws=True)
gateway_opts.set_account_options(account_model)
self.gateway_node = MockGatewayNode(gateway_opts)
self.gateway_node.transaction_streamer_peer = OutboundPeerModel(
"127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY)
self.gateway_node.feed_manager.register_feed(
EthPendingTransactionFeed(self.gateway_node.alarm_queue))
self.eth_ws_proxy_publisher = EthWsProxyPublisher(
self.eth_ws_uri, self.gateway_node.feed_manager,
self.gateway_node.get_tx_service(), self.gateway_node)
self.subscriber: Subscriber[
RawTransactionFeedEntry] = self.gateway_node.feed_manager.subscribe_to_feed(
EthPendingTransactionFeed.NAME, {})
self.assertIsNotNone(self.subscriber)
await self.eth_ws_proxy_publisher.start()
await asyncio.sleep(0.01)
self.assertEqual(len(self.eth_ws_proxy_publisher.receiving_tasks), 2)
self.assertEqual(0, self.subscriber.messages.qsize())
self.sample_transactions = {
i: mock_eth_messages.get_dummy_transaction(i)
for i in range(10)
}
class OntBlockQueuingServiceTest(AbstractTestCase):
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000, max_block_interval=0))
self.node_connection = Mock()
self.node_connection.is_active = MagicMock(return_value=True)
self.node.set_known_total_difficulty = MagicMock()
self.node.node_conn = self.node_connection
self.block_queuing_service = OntBlockQueuingService(self.node)
self.block_hashes = []
self.block_msg = self._get_sample_block()
self.block_queuing_service.store_block_data(
self.block_msg.block_hash(), self.block_msg)
def test_get_recent_blocks(self):
recent_blocks = list(
self.block_queuing_service.iterate_recent_block_hashes(10))
self.assertEqual(len(recent_blocks), 1)
self.assertEqual(recent_blocks[0], self.block_msg.block_hash())
def _get_sample_block(self, file_path=__file__):
root_dir = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(file_path))))
with open(os.path.join(root_dir,
"ont_sample_block.txt")) as sample_file:
ont_block = sample_file.read().strip("\n")
buf = bytearray(convert.hex_to_bytes(ont_block))
parsed_block = BlockOntMessage(buf=buf)
return parsed_block
def test_tracked_block_cleanup(self):
self.node.block_queuing_service = self.block_queuing_service
tx_service = self.node.get_tx_service()
for block_hash in self.block_queuing_service.iterate_recent_block_hashes(
10):
tx_service.track_seen_short_ids(block_hash, [])
self.node._tracked_block_cleanup()
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)
async def setUp(self) -> None:
account_model = BdnAccountModelBase(
"account_id", "account_name", "fake_certificate",
new_transaction_streaming=BdnServiceModelConfigBase(
expire_date=date(2999, 1, 1).isoformat()
)
)
self.eth_ws_port = helpers.get_free_port()
self.eth_ws_uri = f"ws://127.0.0.1:{self.eth_ws_port}"
self.eth_ws_server_message_queue = asyncio.Queue()
self.eth_subscription_id = "sub_id"
await self.start_server()
gateway_opts = gateway_helpers.get_gateway_opts(
8000, eth_ws_uri=self.eth_ws_uri, ws=True)
gateway_opts.set_account_options(account_model)
self.gateway_node = MockGatewayNode(gateway_opts)
self.gateway_node.feed_manager.register_feed(
EthPendingTransactionFeed(self.gateway_node.alarm_queue)
)
self.eth_ws_subscriber = EthWsSubscriber(
self.eth_ws_uri, self.gateway_node.feed_manager, self.gateway_node.get_tx_service()
)
self.subscriber: Subscriber[
RawTransactionFeedEntry
] = self.gateway_node.feed_manager.subscribe_to_feed(EthPendingTransactionFeed.NAME, {})
self.assertIsNotNone(self.subscriber)
await self.eth_ws_subscriber.start()
await asyncio.sleep(0.01)
self.assertIsNotNone(self.eth_ws_subscriber.receiving_task)
self.assertEqual(0, self.subscriber.messages.qsize())
self.sample_transactions = {
i: mock_eth_messages.get_dummy_transaction(i) for i in range(10)
}
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(
8000,
max_block_interval=gateway_constants.
MAX_INTERVAL_BETWEEN_BLOCKS_S,
blockchain_message_ttl=TTL))
self.node_connection = Mock()
self.node_connection.is_active = MagicMock(return_value=True)
self.node.node_conn = self.node_connection
self.block_queuing_service = TestPushBlockQueuingService(self.node)
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000,
include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockGatewayNode(opts)
self.node.block_processing_service = MagicMock()
self.connection = MagicMock()
self.connection.node = self.node
self.connection.peer_ip = LOCALHOST
self.connection.peer_port = 8001
self.connection.network_num = 2
self.sut = BtcBaseConnectionProtocol(self.connection)
def setUp(self) -> None:
self.gateway_node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000, split_relays=True))
self.gateway_node.alarm_queue = AlarmQueue()
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service", self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S)
self.gateway_node.requester.start()
self.outbound_peer_models = [
OutboundPeerModel("1.1.1.1", 1609, node_type=NodeType.RELAY_BLOCK),
OutboundPeerModel("1.1.1.2", 1609, node_type=NodeType.RELAY_BLOCK),
OutboundPeerModel("1.1.1.3", 1609, node_type=NodeType.RELAY_BLOCK),
]
sdn_http_service.fetch_potential_relay_peers_by_network = MagicMock(
side_effect=lambda *args: self.outbound_peer_models)
sdn_http_service.submit_peer_connection_error_event = MagicMock()
self.latencies = [10, 20, 30]
ping_latency.get_ping_latencies = MagicMock(side_effect=lambda *args: [
NodeLatencyInfo(self.outbound_peer_models[0], self.latencies[0]),
NodeLatencyInfo(self.outbound_peer_models[1], self.latencies[1]),
NodeLatencyInfo(self.outbound_peer_models[2], self.latencies[2]),
])
self.gateway_node.enqueue_connection = MagicMock()
def setUp(self) -> None:
self.block_confirmations_count = 3
opts = gateway_helpers.get_gateway_opts(
8000,
block_confirmations_count=self.block_confirmations_count - 1,
include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockGatewayNode(opts)
self.transaction_service = self._get_transaction_service()
self.cleanup_service = self._get_cleanup_service()
self.node._tx_service = self.transaction_service
self.node.block_cleanup_service = self.cleanup_service
self.node.post_block_cleanup_tasks = MagicMock()
self.tx_hashes = []
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(
8000,
include_default_btc_args=True,
include_default_eth_args=True,
split_relays=True,
)
)
self.connection = AbstractRelayConnection(
MockSocketConnection(node=self.node, ip_address=constants.LOCALHOST, port=12345), self.node
)
self.connection.state = ConnectionState.INITIALIZED
self.blockchain_connecton = AbstractGatewayBlockchainConnection(
MockSocketConnection(node=self.node, ip_address=constants.LOCALHOST, port=333), self.node)
self.blockchain_connecton.state = ConnectionState.ESTABLISHED
