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.connect(self.ws_uri) 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_blxr_eth_call(self):
self.gateway_node.eth_ws_proxy_publisher = MockEthWsProxyPublisher(
None, None, None, None)
self.gateway_node.eth_ws_proxy_publisher.call_rpc = AsyncMock(
return_value=JsonRpcResponse(request_id=1))
result = await self.request(
BxJsonRpcRequest(
"1", RpcRequestType.BLXR_ETH_CALL, {
rpc_constants.TRANSACTION_JSON_PARAMS_KEY:
TRANSACTION_JSON,
rpc_constants.TAG_PARAMS_KEY: "latest"
}))
self.gateway_node.eth_ws_proxy_publisher.call_rpc.mock.assert_called_with(
"eth_call", [TRANSACTION_JSON, "latest"])
self.assertIsNone(result.error)
async def test_add_blockchain_peer(self):
self.gateway_node.enqueue_connection = MagicMock()
result = await self.request(
BxJsonRpcRequest(
"8", RpcRequestType.ADD_BLOCKCHAIN_PEER, {
"peer":
"enode://d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396@127.0.0.1:30302"
}))
self.gateway_node.enqueue_connection.assert_called_once_with(
"127.0.0.1", 30302, ConnectionType.BLOCKCHAIN_NODE)
self.assertIn(BlockchainPeerInfo("127.0.0.1", 30302),
self.gateway_node.blockchain_peers)
self.assertEqual("8", result.id)
self.assertIsNone(result.error)
self.assertEqual({"new_peer": "127.0.0.1:30302"}, result.result)
async def test_unsubscribe(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)
result = await rpc_handler.process_request()
subscriber_id = result.result
# message is received
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())
unsubscribe_request = BxJsonRpcRequest("1", RpcRequestType.UNSUBSCRIBE,
[subscriber_id])
rpc_handler = self.rpc.get_request_handler(unsubscribe_request)
result = await rpc_handler.process_request()
self.assertTrue(result.result)
next_message_task: Future[BxJsonRpcRequest] = asyncio.ensure_future(
self.rpc.get_next_subscribed_message())
feed.publish("foobar_not_received")
feed.publish("foobar_not_received_2")
await asyncio.sleep(0) # publish to subscriber
await asyncio.sleep(0) # subscriber publishes to queue
self.assertFalse(next_message_task.done()) # no message
self.assertEqual(0, len(self.rpc.subscriptions))
self.assertEqual(0, self.feed_manager.feeds["foo"].subscriber_count())
async def test_gateway_status(self):
result_summary = await self.request(BxJsonRpcRequest(
"2",
RpcRequestType.GATEWAY_STATUS,
None
))
self.assertEqual("2", result_summary.id)
self.assertIsNone(result_summary.error)
self.assertEqual(constants.LOCALHOST, result_summary.result["ip_address"])
self.assertEqual("NA", result_summary.result["continent"])
self.assertEqual("United States", result_summary.result["country"])
result_detailed = await self.request(BxJsonRpcRequest(
"2.5",
RpcRequestType.GATEWAY_STATUS,
{
rpc_constants.DETAILS_LEVEL_PARAMS_KEY: GatewayStatusDetailsLevel.DETAILED.name
}
))
self.assertEqual("2.5", result_detailed.id)
self.assertIsNone(result_detailed.error)
self.assertEqual(constants.LOCALHOST, result_detailed.result["summary"]["ip_address"])
self.assertEqual("NA", result_detailed.result["summary"]["continent"])
self.assertEqual("United States", result_detailed.result["summary"]["country"])
async def handle_subscription(self, subscriber: Subscriber) -> None:
while True:
notification = await subscriber.receive()
# subscription notifications are sent as JSONRPC requests
next_message = BxJsonRpcRequest(None, RpcRequestType.SUBSCRIBE, {
"subscription": subscriber.subscription_id,
"result": notification
})
if self.subscribed_messages.full():
logger.warning(log_messages.BAD_RPC_SUBSCRIBER,
self.subscribed_messages.qsize(),
list(self.subscriptions.keys()))
asyncio.create_task(self.async_close())
return
else:
await self.subscribed_messages.put(next_message)
async def test_subscribe_to_feed_with_filters_all(self):
feed = TestFeed("bar")
feed.FILTERS = ["field1", "field2"]
self.feed_manager.register_feed(feed)
subscribe_request1 = BxJsonRpcRequest(
"1",
RpcRequestType.SUBSCRIBE,
["bar", {
"filters": "field1 == 2"
}],
)
rpc_handler = self.rpc.get_request_handler(subscribe_request1)
result = await rpc_handler.process_request()
self.assertTrue(result)
async def test_blxr_tx(self):
result = await self.request(
BxJsonRpcRequest(
"1", RpcRequestType.BLXR_TX, {
rpc_constants.TRANSACTION_PARAMS_KEY: RAW_TRANSACTION_HEX,
"quota_type": "paid_daily_quota"
}))
self.assertEqual("1", result.id)
self.assertIsNone(result.error)
self.assertEqual(TRANSACTION_HASH, result.result["tx_hash"])
self.assertEqual(ACCOUNT_ID, result.result["account_id"])
self.assertEqual("paid_daily_quota", result.result["quota_type"])
self.assertEqual(1, len(self.gateway_node.broadcast_messages))
self.assertEqual(Sha256Hash(convert.hex_to_bytes(TRANSACTION_HASH)),
self.gateway_node.broadcast_messages[0][0].tx_hash())
async def test_blxr_tx_from_json(self):
tx_json = {
'from':
'0xc165599b5e418bb9d8a19090696ea2403b2927ed',
'gas':
"0x5208",
'gasPrice':
"0xc1b759d70",
'hash':
'0xd569674ad9fcaaedcb6867b7896067b445d4a838316be4292c474df17bf4bd50',
'input':
'0x',
'nonce':
"0x14",
'to':
'0xdb5f0c1f4198bc6ffa98b35f7188f82740b8caf7',
'value':
"0x3e871b540c000",
'v':
'0x26',
'r':
'0x484bc950fb2d595500baa604774cb8d156a677198e087801936f38ca0b27049',
's':
'0x7ca82ef7b6938c2e96966dd940b186c9cdc0c7f42b2843adbc0751bb6e67a2d4'
}
result = await self.request(
BxJsonRpcRequest(
"1", RpcRequestType.BLXR_TX, {
rpc_constants.TRANSACTION_JSON_PARAMS_KEY: tx_json,
}))
self.assertEqual("1", result.id)
self.assertIsNone(result.error)
self.assertEqual(
"ad6f9332384194f80d8e49af8f093ad019b3f6b7173eb2956a46c9a0d8c4d03c",
result.result["tx_hash"])
self.assertEqual(ACCOUNT_ID, result.result["account_id"])
self.assertEqual(TransactionFlag.PAID_TX.name.lower(),
result.result["transaction_flag"].lower())
self.assertEqual(1, len(self.gateway_node.broadcast_messages))
self.assertEqual(
Sha256Hash(
convert.hex_to_bytes(
"ad6f9332384194f80d8e49af8f093ad019b3f6b7173eb2956a46c9a0d8c4d03c"
)), self.gateway_node.broadcast_messages[0][0].tx_hash())
async def test_blxr_tx(self):
result = await self.request(
BxJsonRpcRequest(
"1", RpcRequestType.BLXR_TX, {
rpc_constants.TRANSACTION_PARAMS_KEY: RAW_TRANSACTION_HEX,
rpc_constants.STATUS_TRACK_PARAMS_KEY: "True"
}))
self.assertEqual("1", result.id)
self.assertIsNone(result.error)
self.assertEqual(TRANSACTION_HASH, result.result["tx_hash"])
self.assertEqual(ACCOUNT_ID, result.result["account_id"])
self.assertEqual(TransactionFlag.PAID_TX.name.lower(),
result.result["transaction_flag"].lower())
self.assertEqual(1, len(self.gateway_node.broadcast_messages))
self.assertEqual(Sha256Hash(convert.hex_to_bytes(TRANSACTION_HASH)),
self.gateway_node.broadcast_messages[0][0].tx_hash())
async def test_bdn_performance(self):
gateway_bdn_performance_stats_service.set_node(self.gateway_node)
gateway_bdn_performance_stats_service.log_block_from_bdn()
gateway_bdn_performance_stats_service.log_block_from_bdn()
gateway_bdn_performance_stats_service.log_block_from_blockchain_node()
gateway_bdn_performance_stats_service.log_tx_from_bdn()
gateway_bdn_performance_stats_service.log_tx_from_blockchain_node()
gateway_bdn_performance_stats_service.log_tx_from_blockchain_node()
gateway_bdn_performance_stats_service.close_interval_data()
result = await self.request(
BxJsonRpcRequest("6", RpcRequestType.BDN_PERFORMANCE, None))
self.assertEqual("6", result.id)
self.assertIsNone(result.error)
self.assertEqual("66.67%", result.result["blocks_from_bdn_percentage"])
self.assertEqual("33.33%",
result.result["transactions_from_bdn_percentage"])
async def test_bdn_performance_multi_node(self):
self.gateway_node.connection_pool.add(20,
self.node_endpoint_1.ip_address,
self.node_endpoint_1.port,
self.blockchain_connection_1)
blockchain_connection_2 = EthNodeConnection(
MockSocketConnection(1,
node=self.gateway_node,
ip_address="127.0.0.1",
port=333), self.gateway_node)
blockchain_connection_2.on_connection_established()
self.gateway_node.mock_add_blockchain_peer(blockchain_connection_2)
node_endpoint_2 = IpEndpoint("127.0.0.1", 333)
self.gateway_node.connection_pool.add(21, node_endpoint_2.ip_address,
node_endpoint_2.port,
blockchain_connection_2)
gateway_bdn_performance_stats_service.set_node(self.gateway_node)
gateway_bdn_performance_stats_service.log_block_from_bdn()
gateway_bdn_performance_stats_service.log_block_from_bdn()
gateway_bdn_performance_stats_service.log_block_from_blockchain_node(
self.node_endpoint_1)
gateway_bdn_performance_stats_service.log_tx_from_bdn()
gateway_bdn_performance_stats_service.log_tx_from_blockchain_node(
self.node_endpoint_1)
gateway_bdn_performance_stats_service.log_tx_from_blockchain_node(
self.node_endpoint_1)
gateway_bdn_performance_stats_service.close_interval_data()
result = await self.request(
BxJsonRpcRequest("6", RpcRequestType.BDN_PERFORMANCE, None))
self.assertEqual("6", result.id)
self.assertIsNone(result.error)
node_stats = result.result[str(self.node_endpoint_1)]
self.assertEqual("66.67%", node_stats["blocks_from_bdn_percentage"])
self.assertEqual("33.33%",
node_stats["transactions_from_bdn_percentage"])
self.assertEqual(3, node_stats["total_blocks_seen"])
node_stats_2 = result.result[str(node_endpoint_2)]
self.assertEqual("100.00%", node_stats_2["blocks_from_bdn_percentage"])
self.assertEqual("100.00%",
node_stats_2["transactions_from_bdn_percentage"])
self.assertEqual(3, node_stats_2["total_blocks_seen"])
async def test_subscribe_to_feed_with_specific_available_field(self):
feed_service_model = FeedServiceModelBase(
allow_filtering=True, available_fields=["tx_contents.nonce"])
base_feed_service_model = BdnFeedServiceModelConfigBase(
expire_date="2999-01-01", feed=feed_service_model)
self.node.account_model.new_transaction_streaming = base_feed_service_model
subscribe_request1 = BxJsonRpcRequest(
"1",
RpcRequestType.SUBSCRIBE,
[self.feed_name, {
"include": ["tx_contents.nonce"]
}],
)
rpc_handler = self.rpc.get_request_handler(subscribe_request1)
result = await rpc_handler.process_request()
self.assertTrue(result)
async def test_remove_blockchain_peer_not_in_pool(self):
self.gateway_node.alarm_queue.register_alarm = MagicMock()
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)
self.gateway_node.alarm_queue.register_alarm.assert_called()
self.assertEqual("9", result.id)
self.assertIsNone(result.error)
self.assertEqual({"removed_peer": "127.0.0.1:30302"}, result.result)
async def test_close_bad_subscribers(self):
self.rpc.subscribed_messages = asyncio.Queue(5)
close_listener = asyncio.create_task(self.rpc.wait_for_close())
feed1 = TestFeed("foo1")
self.feed_manager.register_feed(feed1)
rpc_request = BxJsonRpcRequest("1", RpcRequestType.SUBSCRIBE,
["foo1", {}])
await self.rpc.get_request_handler(rpc_request).process_request()
for i in range(10):
feed1.publish(i)
await asyncio.sleep(0.1)
self.assertTrue(self.rpc.disconnect_event.is_set())
self.assertTrue(close_listener.done())
async def test_subscribe_to_feed_with_filters2(self):
feed = TestFeed("bar")
feed.FILTERS = ["to", "field2"]
self.feed_manager.register_feed(feed)
subscribe_request1 = BxJsonRpcRequest(
"1",
RpcRequestType.SUBSCRIBE,
[
"bar", {
"filters":
"to = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
}
],
)
rpc_handler = self.rpc.get_request_handler(subscribe_request1)
result = await rpc_handler.process_request()
self.assertTrue(result)
async def test_camel_case(self):
self.gateway_node.account_model.get_feed_service_config_by_name = MagicMock(
return_value=self.gateway_node.account_model.
new_transaction_streaming)
await self.server.stop()
self.server = WsServer(constants.LOCALHOST, 8005, self.feed_manager,
self.gateway_node, Case.CAMEL)
await self.server.start()
feed = TestFeed("foo")
self.feed_manager.register_feed(feed)
@dataclass
class DataEntry:
field_one: str
def publish():
feed.publish(DataEntry("123"))
feed.publish(DataEntry("234"))
async with websockets.connect(self.ws_uri) 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({"fieldOne": "123"}, subscriber_id, await
ws.recv())
self._assert_notification({"fieldOne": "234"}, subscriber_id, await
ws.recv())
async def test_remove_blockchain_peer(self):
conn = MockConnection(
MockSocketConnection(9, 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(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.get_feed(FeedKey("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 test_peers(self):
result = await self.request(
BxJsonRpcRequest("5", RpcRequestType.PEERS, None))
self.assertEqual("5", result.id)
self.assertIsNone(result.error)
self.assertEqual([], result.result)
class WsServerTest(AbstractGatewayRpcIntegrationTest):
@async_test
async def setUp(self) -> None:
await super().setUp()
self.feed_manager = FeedManager(self.gateway_node)
self.server = WsServer(constants.LOCALHOST, 8005, self.feed_manager,
self.gateway_node, Case.SNAKE)
self.ws_uri = f"ws://{constants.LOCALHOST}:8005"
await self.server.start()
def get_gateway_opts(self) -> GatewayOpts:
super().get_gateway_opts()
return gateway_helpers.get_gateway_opts(
8000,
blockchain_protocol="Ethereum",
account_model=self._account_model,
)
async def request(self, req: BxJsonRpcRequest) -> JsonRpcResponse:
async with websockets.connect(self.ws_uri) as ws:
await ws.send(req.to_jsons())
response = await ws.recv()
return JsonRpcResponse.from_jsons(response)
@async_test
async def test_startup(self):
async with websockets.connect(self.ws_uri) as _ws:
await asyncio.sleep(0.01)
self.assertEqual(1, len(self.server._connections))
connection = self.server._connections[0]
self.assertFalse(connection.request_handler.done())
self.assertFalse(connection.publish_handler.done())
@async_test
async def test_subscribe_and_unsubscribe(self):
self.gateway_node.account_model.get_feed_service_config_by_name = MagicMock(
return_value=self.gateway_node.account_model.
new_transaction_streaming)
feed = TestFeed("foo")
self.feed_manager.register_feed(feed)
def publish():
feed.publish(1)
feed.publish(2)
feed.publish(3)
async with websockets.connect(self.ws_uri) 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_test
async def test_camel_case(self):
self.gateway_node.account_model.get_feed_service_config_by_name = MagicMock(
return_value=self.gateway_node.account_model.
new_transaction_streaming)
await self.server.stop()
self.server = WsServer(constants.LOCALHOST, 8005, self.feed_manager,
self.gateway_node, Case.CAMEL)
await self.server.start()
feed = TestFeed("foo")
self.feed_manager.register_feed(feed)
@dataclass
class DataEntry:
field_one: str
def publish():
feed.publish(DataEntry("123"))
feed.publish(DataEntry("234"))
async with websockets.connect(self.ws_uri) 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({"fieldOne": "123"}, subscriber_id, await
ws.recv())
self._assert_notification({"fieldOne": "234"}, subscriber_id, await
ws.recv())
@skip("Reenable this when orjson library upgraded")
@async_test
async def test_serialization_caching(self):
old_to_json_bytes_split = BxJsonRpcRequest.to_json_bytes_split_serialization
old_to_json_bytes_cached = BxJsonRpcRequest.to_json_bytes_with_cached_result
# cache hit, cache miss
byte_serialize_count = [0, 0]
def to_json_bytes_split(calling_self, case):
byte_serialize_count[0] += 1
return old_to_json_bytes_split(calling_self, case)
def to_json_bytes_cached(calling_self, case, cached):
byte_serialize_count[1] += 1
return old_to_json_bytes_cached(calling_self, case, cached)
BxJsonRpcRequest.to_json_bytes_split_serialization = to_json_bytes_split
BxJsonRpcRequest.to_json_bytes_with_cached_result = to_json_bytes_cached
self.gateway_node.account_model.get_feed_service_config_by_name = MagicMock(
return_value=self.gateway_node.account_model.
new_transaction_streaming)
feed = TestFeed("foo")
feed.FIELDS = ["foo", "bar"]
feed.ALL_FIELDS = ["foo", "bar"]
self.feed_manager.register_feed(feed)
def publish():
feed.publish({"foo": 1, "bar": 2})
ws = await websockets.connect(self.ws_uri)
ws_same = await websockets.connect(self.ws_uri)
ws_same_2 = await websockets.connect(self.ws_uri)
ws_diff = await websockets.connect(self.ws_uri)
try:
asyncio.get_event_loop().call_later(0.1, publish)
# subscribe all clients
await ws.send(
BxJsonRpcRequest("2", RpcRequestType.SUBSCRIBE,
["foo", {
"include": ["foo"]
}]).to_jsons())
await ws_same.send(
BxJsonRpcRequest("2", RpcRequestType.SUBSCRIBE,
["foo", {
"include": ["foo"]
}]).to_jsons())
await ws_same_2.send(
BxJsonRpcRequest("2", RpcRequestType.SUBSCRIBE,
["foo", {
"include": ["foo"]
}]).to_jsons())
await ws_diff.send(
BxJsonRpcRequest("2", RpcRequestType.SUBSCRIBE,
["foo", {
"include": ["bar"]
}]).to_jsons())
# receive all subscription responses
ws_subscription_id = self._get_subscription_id(await ws.recv())
ws_same_subscription_id = self._get_subscription_id(await
ws_same.recv())
ws_same_2_subscription_id = self._get_subscription_id(
await ws_same_2.recv())
ws_diff_subscription_id = self._get_subscription_id(await
ws_diff.recv())
byte_serialize_count[0] = 0
self._assert_notification({"foo": 1}, ws_subscription_id, await
ws.recv())
self._assert_notification({"foo": 1}, ws_same_subscription_id,
await ws_same.recv())
self._assert_notification({"foo": 1}, ws_same_2_subscription_id,
await ws_same_2.recv())
self._assert_notification({"bar": 2}, ws_diff_subscription_id,
await ws_diff.recv())
self.assertEqual(2, byte_serialize_count[0])
self.assertEqual(2, byte_serialize_count[1])
finally:
await ws.close()
await ws_same.close()
await ws_diff.close()