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)
async def setUp(self) -> None:
self.rpc_port = helpers.get_free_port()
self.rpc_url = f"http://{constants.LOCALHOST}:{self.rpc_port}"
self.rpc_user = "******"
self.rpc_password = "******"
await super().setUp()
self.rpc_server = GatewayHttpRpcServer(self.gateway_node)
await self.rpc_server.start()
def setUp(self):
self.main_port = helpers.get_free_port()
self.peer_port = helpers.get_free_port()
sdn_http_service.fetch_gateway_peers = MagicMock(return_value=[])
self.main_opts = gateway_helpers.get_gateway_opts(
self.main_port, node_id="main",
peer_gateways=[OutboundPeerModel(LOCALHOST, self.peer_port, node_type=NodeType.EXTERNAL_GATEWAY)],
non_ssl_port=helpers.get_free_port()
)
self.main_gateway = NullGatewayNode(self.main_opts)
self.main_event_loop = NodeEventLoop(self.main_gateway)
self.peer_opts = gateway_helpers.get_gateway_opts(self.peer_port, node_id="peer", non_ssl_port=helpers.get_free_port())
self.peer_gateway = NullGatewayNode(self.peer_opts)
self.peer_event_loop = NodeEventLoop(self.peer_gateway)
def test_multiplexing__delayed_connect(self):
receiver_port = helpers.get_free_port()
receiver_node = TestNode(receiver_port, [], 0.01)
receiver_event_loop = create_event_loop(receiver_node)
receiver_thread = Thread(target=receiver_event_loop.run)
send_bytes = generate_bytearray(1000)
sender_port = helpers.get_free_port()
sender_node = TestNode(sender_port, [], 0.01, send_bytes)
sender_event_loop = create_event_loop(sender_node)
sender_thread = Thread(target=sender_event_loop.run)
try:
print("Starting event loop on receiver")
receiver_thread.start()
print("Starting event loop on sender")
sender_thread.start()
# let threads run for 0.1 sec
time.sleep(0.1)
self.assertEqual(len(receiver_node.connections), 0)
self.assertEqual(len(sender_node.connections), 0)
# request connection while clients are running
sender_node.enqueue_connection('0.0.0.0', receiver_node.port)
receiver_thread.join()
sender_thread.join()
self._validate_successful_run(send_bytes, sender_node,
receiver_node, sender_event_loop,
receiver_event_loop)
finally:
if receiver_thread.is_alive():
receiver_thread.join()
if sender_thread.is_alive():
sender_thread.join()
receiver_event_loop.close()
sender_event_loop.close()
def test_multiplexing__disconnect(self):
receiver_port = helpers.get_free_port()
receiver_node = TestNode(receiver_port, [], 0.01)
receiver_event_loop = create_event_loop(receiver_node)
receiver_thread = Thread(name="receiver",
target=receiver_event_loop.run)
sender_port = helpers.get_free_port()
sender_node = TestNode(sender_port, [receiver_port], 0.01)
sender_event_loop = create_event_loop(sender_node)
sender_thread = Thread(name="sender", target=sender_event_loop.run)
try:
print("Starting event loop on receiver")
receiver_thread.start()
sender_thread.start()
# let threads run for 0.1 sec
time.sleep(0.1)
self.assertEqual(len(receiver_node.connections), 1)
self.assertEqual(len(sender_node.connections), 1)
# request disconnect while clients are running
sender_node.enqueue_disconnect(sender_node.connections[0][0],
False)
# sender and receiver have to disconnect and exit
receiver_thread.join()
sender_thread.join()
finally:
if receiver_thread.is_alive():
receiver_thread.join()
if sender_thread.is_alive():
sender_thread.join()
receiver_event_loop.close()
sender_event_loop.close()
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)
}
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)
}