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()