async def test_subscribe_to_multiple_feeds(self): feed1 = TestFeed("foo1") feed2 = TestFeed("foo2") feed3 = TestFeed("foo3") for feed in [feed1, feed2, feed3]: self.feed_manager.register_feed(feed) subscribe_requests = [ BxJsonRpcRequest("1", RpcRequestType.SUBSCRIBE, ["foo1", {}]), BxJsonRpcRequest("1", RpcRequestType.SUBSCRIBE, ["foo2", {}]), BxJsonRpcRequest("1", RpcRequestType.SUBSCRIBE, ["foo3", {}]) ] subscriber_ids = [] for subscribe_request in subscribe_requests: rpc_handler = self.rpc.get_request_handler(subscribe_request) result = await rpc_handler.process_request() subscriber_ids.append(result.result) next_message_task: Future[BxJsonRpcRequest] = asyncio.ensure_future( self.rpc.get_next_subscribed_message()) await asyncio.sleep(0) self.assertFalse(next_message_task.done()) feed2.publish("message 1") await asyncio.sleep(0) feed1.publish("message 2") await asyncio.sleep(0) feed2.publish("message 3") await asyncio.sleep(0) feed3.publish("message 4") await asyncio.sleep(0) self.assertTrue(next_message_task.done()) message_1 = next_message_task.result() self.assertEqual(subscriber_ids[1], message_1.params["subscription"]) self.assertEqual("message 1", message_1.params["result"]) message_2 = await self.rpc.get_next_subscribed_message() self.assertEqual(subscriber_ids[0], message_2.params["subscription"]) self.assertEqual("message 2", message_2.params["result"]) message_3 = await self.rpc.get_next_subscribed_message() self.assertEqual(subscriber_ids[1], message_3.params["subscription"]) self.assertEqual("message 3", message_3.params["result"]) message_4 = await self.rpc.get_next_subscribed_message() self.assertEqual(subscriber_ids[2], message_4.params["subscription"]) self.assertEqual("message 4", message_4.params["result"])
async def test_subscribe_to_feed_with_invalid_filters(self): feed = TestFeed("foo") feed.FILTERS = ["filter1", "filter2"] self.feed_manager.register_feed(feed) subscribe_request1 = BxJsonRpcRequest( "1", RpcRequestType.SUBSCRIBE, ["foo", { "filters": [{ "field1": [] }, "AND", { "field2": [] }] }], ) with self.assertRaises(RpcInvalidParams): rpc_handler = self.rpc.get_request_handler(subscribe_request1) await rpc_handler.process_request() subscribe_request2 = BxJsonRpcRequest( "1", RpcRequestType.SUBSCRIBE, ["foo", { "filters": [True, False, 1, 2] }]) with self.assertRaises(RpcInvalidParams): rpc_handler = self.rpc.get_request_handler(subscribe_request2) await rpc_handler.process_request() subscribe_request3 = BxJsonRpcRequest("1", RpcRequestType.SUBSCRIBE, ["foo", { "filters": { "a": 1 } }]) with self.assertRaises(RpcInvalidParams): rpc_handler = self.rpc.get_request_handler(subscribe_request3) await rpc_handler.process_request() subscribe_request4 = BxJsonRpcRequest( "1", RpcRequestType.SUBSCRIBE, ["foo", { "filters": "hello === r and i" }], ) with self.assertRaises(RpcInvalidParams): rpc_handler = self.rpc.get_request_handler(subscribe_request4) await rpc_handler.process_request()
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)
async def test_subscribe_to_feed_with_fields(self): feed = TestFeed("foo") feed.FIELDS = ["field1", "field2", "field3"] self.feed_manager.register_feed(feed) subscribe_request = BxJsonRpcRequest( "1", RpcRequestType.SUBSCRIBE, ["foo", { "include": ["field1", "field2"] }]) rpc_handler = self.rpc.get_request_handler(subscribe_request) result = await rpc_handler.process_request() subscriber_id = result.result next_message_task: Future[BxJsonRpcRequest] = asyncio.ensure_future( self.rpc.get_next_subscribed_message()) feed.publish({"field1": "foo", "field2": "bar", "field3": "baz"}) await asyncio.sleep(0) # publish to subscriber await asyncio.sleep(0) # subscriber publishes to queue self.assertTrue(next_message_task.done()) next_message = next_message_task.result() self.assertEqual("2.0", next_message.json_rpc_version) self.assertEqual(RpcRequestType.SUBSCRIBE, next_message.method) self.assertEqual(subscriber_id, next_message.params["subscription"]) expected_result = { "field1": "foo", "field2": "bar", } self.assertEqual(expected_result, next_message.params["result"])
async def test_subscribe_to_feed(self): feed = TestFeed("foo") self.feed_manager.register_feed(feed) subscribe_request = BxJsonRpcRequest("1", RpcRequestType.SUBSCRIBE, ["foo", {}]) rpc_handler = self.rpc.get_request_handler(subscribe_request) self.assertIsInstance(rpc_handler, SubscribeRpcRequest) result = await rpc_handler.process_request() self.assertIsNotNone(result.result) self.assertIsNone(result.error) subscriber_id = result.result self.assertEqual(1, self.feed_manager.feeds["foo"].subscriber_count()) self.assertEqual(1, len(self.rpc.subscriptions)) self.assertIn(subscriber_id, self.rpc.subscriptions) next_message_task: Future[BxJsonRpcRequest] = asyncio.ensure_future( self.rpc.get_next_subscribed_message()) await asyncio.sleep(0) self.assertFalse(next_message_task.done()) feed.publish("foobar") await asyncio.sleep(0) # publish to subscriber await asyncio.sleep(0) # subscriber publishes to queue self.assertTrue(next_message_task.done()) next_message = next_message_task.result() self.assertEqual("2.0", next_message.json_rpc_version) self.assertEqual(RpcRequestType.SUBSCRIBE, next_message.method) self.assertEqual(subscriber_id, next_message.params["subscription"]) self.assertEqual("foobar", next_message.params["result"])
async def request(self, req: BxJsonRpcRequest): headers = { rpc_constants.CONTENT_TYPE_HEADER_KEY: ContentType.JSON.value } async with ClientSession() as session: async with session.post(self.rpc_url, data=req.to_jsons(), headers=headers) as response: return JsonRpcResponse.from_json(await response.json())
async def test_blxr_tx_ethereum_berlin(self): self.gateway_node.message_converter = EthNormalMessageConverter() self.gateway_node.network_num = 5 # legacy result = await self.request( BxJsonRpcRequest( "1", RpcRequestType.BLXR_TX, { rpc_constants.TRANSACTION_PARAMS_KEY: convert.bytes_to_hex(eth_fixtures.LEGACY_TRANSACTION), rpc_constants.STATUS_TRACK_PARAMS_KEY: "True" })) self.assertEqual("1", result.id) self.assertIsNone(result.error) self.assertEqual(eth_fixtures.LEGACY_TRANSACTION_HASH, result.result["tx_hash"]) self.assertEqual(1, len(self.gateway_node.broadcast_messages)) self.assertEqual( Sha256Hash( convert.hex_to_bytes(eth_fixtures.LEGACY_TRANSACTION_HASH)), self.gateway_node.broadcast_messages[0][0].tx_hash()) # access list result = await self.request( BxJsonRpcRequest( "1", RpcRequestType.BLXR_TX, { rpc_constants.TRANSACTION_PARAMS_KEY: convert.bytes_to_hex(eth_fixtures.ACL_TRANSACTION), rpc_constants.STATUS_TRACK_PARAMS_KEY: "True" })) self.assertEqual("1", result.id) self.assertIsNone(result.error) self.assertEqual(eth_fixtures.ACL_TRANSACTION_HASH, result.result["tx_hash"]) self.assertEqual(2, len(self.gateway_node.broadcast_messages)) self.assertEqual( Sha256Hash(convert.hex_to_bytes( eth_fixtures.ACL_TRANSACTION_HASH)), self.gateway_node.broadcast_messages[1][0].tx_hash())
async def test_subscribe_to_feed_with_all_available_fields(self): subscribe_request1 = BxJsonRpcRequest( "1", RpcRequestType.SUBSCRIBE, [self.feed_name, {"include": ["tx_hash", "tx_contents.gas_price"]}], ) rpc_handler = self.rpc.get_request_handler(subscribe_request1) result = await rpc_handler.process_request() self.assertTrue(result)
async def test_subscribe_and_unsubscribe(self): feed = TestFeed("foo") self.feed_manager.register_feed(feed) def publish(): feed.publish(1) feed.publish(2) feed.publish(3) async with websockets.unix_connect(self.ipc_path) as ws: asyncio.get_event_loop().call_later( 0.1, publish ) await ws.send( BxJsonRpcRequest( "2", RpcRequestType.SUBSCRIBE, ["foo", {}] ).to_jsons() ) response = await ws.recv() parsed_response = JsonRpcResponse.from_jsons(response) self.assertEqual("2", parsed_response.id) self.assertIsNotNone("1", parsed_response.result) subscriber_id = parsed_response.result self._assert_notification(1, subscriber_id, await ws.recv()) self._assert_notification(2, subscriber_id, await ws.recv()) self._assert_notification(3, subscriber_id, await ws.recv()) await ws.send( BxJsonRpcRequest( "3", RpcRequestType.UNSUBSCRIBE, [subscriber_id] ).to_jsons() ) response = await ws.recv() parsed_response = JsonRpcResponse.from_jsons(response) self.assertEqual("3", parsed_response.id) self.assertTrue(parsed_response.result) publish() with self.assertRaises(TimeoutError): await asyncio.wait_for(ws.recv(), 0.1)
async def test_subscribe_to_feed_validation(self): feed = TestFeed("foo") feed.FIELDS = ["field1", "field2", "field3"] self.feed_manager.register_feed(feed) subscribe_request = BxJsonRpcRequest( "1", RpcRequestType.SUBSCRIBE, ["foo", { "include": ["field1", "field4"] }]) with self.assertRaises(RpcInvalidParams): rpc_handler = self.rpc.get_request_handler(subscribe_request) await rpc_handler.process_request()