def test_listen_for_user_stream_sends_ping_message_before_ping_interval_finishes(
self,
mock_api,
time_mock,
id_mock,
ws_connect_mock):
id_mock.side_effect = [1, 2, 3, 4]
time_mock.side_effect = [1000, 1100, 1101, 1102] # Simulate first ping interval is already due
url = web_utils.private_rest_url(path_url=CONSTANTS.PRIVATE_WS_DATA_PATH_URL)
resp = {
"code": "200000",
"data": {
"instanceServers": [
{
"endpoint": "wss://test.url/endpoint",
"protocol": "websocket",
"encrypt": True,
"pingInterval": 20000,
"pingTimeout": 10000
}
],
"token": "testToken"
}
}
mock_api.post(url, body=json.dumps(resp))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
result_subscribe_trades = {
"type": "ack",
"id": 1
}
result_subscribe_diffs = {
"type": "ack",
"id": 2
}
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(result_subscribe_trades))
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(result_subscribe_diffs))
output_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(self.data_source.listen_for_user_stream(output=output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
sent_messages = self.mocking_assistant.json_messages_sent_through_websocket(
websocket_mock=ws_connect_mock.return_value)
expected_ping_message = {
"id": 3,
"type": "ping",
}
self.assertEqual(expected_ping_message, sent_messages[-1])
def test_listen_for_user_stream_connection_failed(self, mock_api, sleep_mock, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.PRIVATE_WS_DATA_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = self.get_listen_key_mock()
mock_api.post(regex_url, body=json.dumps(mock_response))
mock_ws.side_effect = Exception("TEST ERROR.")
sleep_mock.side_effect = asyncio.CancelledError # to finish the task execution
msg_queue = asyncio.Queue()
try:
self.async_run_with_timeout(self.data_source.listen_for_user_stream(msg_queue))
except asyncio.CancelledError:
pass
self.assertTrue(
self._is_logged("ERROR",
"Unexpected error while listening to user stream. Retrying after 5 seconds..."))
async def _connected_websocket_assistant(self) -> WSAssistant:
rest_assistant = await self._api_factory.get_rest_assistant()
connection_info = await rest_assistant.execute_request(
url=web_utils.private_rest_url(
path_url=CONSTANTS.PRIVATE_WS_DATA_PATH_URL,
domain=self._domain),
method=RESTMethod.POST,
throttler_limit_id=CONSTANTS.PRIVATE_WS_DATA_PATH_URL,
is_auth_required=True,
)
ws_url = connection_info["data"]["instanceServers"][0]["endpoint"]
self._ping_interval = int(connection_info["data"]["instanceServers"][0]
["pingInterval"]) * 0.8 * 1e-3
token = connection_info["data"]["token"]
ws: WSAssistant = await self._api_factory.get_ws_assistant()
await ws.connect(ws_url=f"{ws_url}?token={token}",
message_timeout=self._ping_interval)
return ws
def test_listen_for_user_stream_get_listen_key_successful_with_user_update_event(self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.PRIVATE_WS_DATA_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = self.get_listen_key_mock()
mock_api.post(regex_url, body=json.dumps(mock_response))
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
order_event = {
"type": "message",
"topic": "/spotMarket/tradeOrders",
"subject": "orderChange",
"channelType": "private",
"data": {
"symbol": "KCS-USDT",
"orderType": "limit",
"side": "buy",
"orderId": "5efab07953bdea00089965d2",
"type": "open",
"orderTime": 1593487481683297666,
"size": "0.1",
"filledSize": "0",
"price": "0.937",
"clientOid": "1593487481000906",
"remainSize": "0.1",
"status": "open",
"ts": 1593487481683297666
}
}
self.mocking_assistant.add_websocket_aiohttp_message(mock_ws.return_value, json.dumps(order_event))
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue)
)
msg = self.async_run_with_timeout(msg_queue.get())
self.assertEqual(order_event, msg)
mock_ws.return_value.ping.assert_called()
def test_listen_for_user_stream_does_not_queue_pong_payload(self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.PRIVATE_WS_DATA_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = self.get_listen_key_mock()
mock_pong = {
"id": "1545910590801",
"type": "pong"
}
mock_api.post(regex_url, body=json.dumps(mock_response))
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
self.mocking_assistant.add_websocket_aiohttp_message(mock_ws.return_value, json.dumps(mock_pong))
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue)
)
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(mock_ws.return_value)
self.assertEqual(0, msg_queue.qsize())
def test_listen_for_user_stream_subscribes_to_orders_and_balances_events(self, mock_api, id_mock, ws_connect_mock):
id_mock.side_effect = [1, 2]
url = web_utils.private_rest_url(path_url=CONSTANTS.PRIVATE_WS_DATA_PATH_URL)
resp = {
"code": "200000",
"data": {
"instanceServers": [
{
"endpoint": "wss://test.url/endpoint",
"protocol": "websocket",
"encrypt": True,
"pingInterval": 50000,
"pingTimeout": 10000
}
],
"token": "testToken"
}
}
mock_api.post(url, body=json.dumps(resp))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
result_subscribe_trades = {
"type": "ack",
"id": 1
}
result_subscribe_diffs = {
"type": "ack",
"id": 2
}
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(result_subscribe_trades))
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(result_subscribe_diffs))
output_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(self.data_source.listen_for_user_stream(output=output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
sent_subscription_messages = self.mocking_assistant.json_messages_sent_through_websocket(
websocket_mock=ws_connect_mock.return_value)
self.assertEqual(2, len(sent_subscription_messages))
expected_orders_subscription = {
"id": 1,
"type": "subscribe",
"topic": "/spotMarket/tradeOrders",
"privateChannel": True,
"response": False
}
self.assertEqual(expected_orders_subscription, sent_subscription_messages[0])
expected_balances_subscription = {
"id": 2,
"type": "subscribe",
"topic": "/account/balance",
"privateChannel": True,
"response": False
}
self.assertEqual(expected_balances_subscription, sent_subscription_messages[1])
self.assertTrue(self._is_logged(
"INFO",
"Subscribed to private order changes and balance updates channels..."
))