class AltmarketsWebsocketTests(TestCase):
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = asyncio.get_event_loop().run_until_complete(asyncio.wait_for(coroutine, timeout))
return ret
@patch("websockets.connect", new_callable=AsyncMock)
@patch("hummingbot.connector.exchange.altmarkets.altmarkets_websocket.AltmarketsWebsocket.generate_request_id")
def test_send_subscription_message(self, request_id_mock, ws_connect_mock):
request_id_mock.return_value = 1234567899
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
throttler = AsyncThrottler(Constants.RATE_LIMITS)
websocket = AltmarketsWebsocket(throttler=throttler)
message = [Constants.WS_SUB["TRADES"].format(trading_pair="btcusdt")]
self.async_run_with_timeout(websocket.connect())
self.async_run_with_timeout(websocket.subscribe(message))
self.async_run_with_timeout(websocket.unsubscribe(message))
sent_requests = self.mocking_assistant.text_messages_sent_through_websocket(ws_connect_mock.return_value)
expected_subscribe_message = {"event": "subscribe", "id": 1234567899, "streams": ['btcusdt.trades']}
self.assertTrue(any(
(expected_subscribe_message == json.loads(sent_request) for sent_request in sent_requests)))
expected_unsubscribe_message = {"event": "unsubscribe", "id": 1234567899, "streams": ['btcusdt.trades']}
self.assertTrue(any(
(expected_unsubscribe_message == json.loads(sent_request) for sent_request in sent_requests)))
class BitmartUserStreamTrackerTests(TestCase):
def setUp(self) -> None:
super().setUp()
self.listening_task = None
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
auth_assistant = BitmartAuth(api_key='testAPIKey',
secret_key='testSecret',
memo="hbot")
self.tracker = BitmartUserStreamTracker(throttler, auth_assistant)
self.mocking_assistant = NetworkMockingAssistant()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_authenticates_and_subscribes_to_events(
self, ws_connect_mock):
mock_response: Dict[Any] = {
"data": [{
"symbol": "BTC_USDT",
"side": "buy",
"type": "market",
"notional": "",
"size": "1.0000000000",
"ms_t": "1609926028000",
"price": "46100.0000000000",
"filled_notional": "46100.0000000000",
"filled_size": "1.0000000000",
"margin_trading": "0",
"state": "2",
"order_id": "2147857398",
"order_type": "0",
"last_fill_time": "1609926039226",
"last_fill_price": "46100.00000",
"last_fill_count": "1.00000"
}],
"table":
"spot/user/order"
}
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps({"event": "login"}))
self.listening_task = asyncio.get_event_loop().create_task(
self.tracker.start())
# Add a dummy message for the websocket to read and include in the "messages" queue
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(mock_response))
first_received_message = asyncio.get_event_loop().run_until_complete(
self.tracker.user_stream.get())
self.assertEqual(mock_response, first_received_message)
class MexcUserStreamTrackerTests(TestCase):
def setUp(self) -> None:
super().setUp()
self.ws_sent_messages = []
self.ws_incoming_messages = asyncio.Queue()
self.listening_task = None
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
auth_assistant = MexcAuth(
api_key='testAPIKey',
secret_key='testSecret',
)
self.tracker = MexcUserStreamTracker(throttler=throttler,
mexc_auth=auth_assistant)
self.mocking_assistant = NetworkMockingAssistant()
self.ev_loop = asyncio.get_event_loop()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listening_process_authenticates_and_subscribes_to_events(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.listening_task = asyncio.get_event_loop().create_task(
self.tracker.start())
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
ujson.dumps({'channel': 'push.personal.order'}))
first_received_message = self.async_run_with_timeout(
self.tracker.user_stream.get())
self.assertEqual({'channel': 'push.personal.order'},
first_received_message)
class CoinzoomWebsocketTests(TestCase):
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = asyncio.get_event_loop().run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
@patch("websockets.connect", new_callable=AsyncMock)
def test_send_subscription_message(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
throttler = AsyncThrottler(Constants.RATE_LIMITS)
websocket = CoinzoomWebsocket(throttler=throttler)
message = {Constants.WS_SUB["TRADES"]: {'symbol': "BTC/USDT"}}
self.async_run_with_timeout(websocket.connect())
self.async_run_with_timeout(websocket.subscribe(message))
self.async_run_with_timeout(websocket.unsubscribe(message))
sent_requests = self.mocking_assistant.text_messages_sent_through_websocket(
ws_connect_mock.return_value)
sent_subscribe_message = json.loads(sent_requests[0])
expected_subscribe_message = {
"TradeSummaryRequest": {
"action": "subscribe",
"symbol": "BTC/USDT"
}
}
self.assertEquals(expected_subscribe_message, sent_subscribe_message)
sent_unsubscribe_message = json.loads(sent_requests[0])
expected_unsubscribe_message = {
"TradeSummaryRequest": {
"action": "subscribe",
"symbol": "BTC/USDT"
}
}
self.assertEquals(expected_unsubscribe_message,
sent_unsubscribe_message)
class BinanceAPIOrderBookDataSourceUnitTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ex_trading_pair = cls.base_asset + cls.quote_asset
cls.domain = "com"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = BinanceAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
throttler=self.throttler,
domain=self.domain)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.resume_test_event = asyncio.Event()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def _successfully_subscribed_event(self):
resp = {"result": None, "id": 1}
return resp
def _trade_update_event(self):
resp = {
"e": "trade",
"E": 123456789,
"s": self.ex_trading_pair,
"t": 12345,
"p": "0.001",
"q": "100",
"b": 88,
"a": 50,
"T": 123456785,
"m": True,
"M": True
}
return resp
def _order_diff_event(self):
resp = {
"e": "depthUpdate",
"E": 123456789,
"s": self.ex_trading_pair,
"U": 157,
"u": 160,
"b": [["0.0024", "10"]],
"a": [["0.0026", "100"]]
}
return resp
def _snapshot_response(self):
resp = {
"lastUpdateId": 1027024,
"bids": [["4.00000000", "431.00000000"]],
"asks": [["4.00000200", "12.00000000"]]
}
return resp
@aioresponses()
def test_get_last_trade_prices(self, mock_api):
url = utils.public_rest_url(
path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# Truncated Response
"lastPrice": "100",
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result: Dict[str, float] = self.ev_loop.run_until_complete(
self.data_source.get_last_traded_prices(
trading_pairs=[self.trading_pair], throttler=self.throttler))
self.assertEqual(1, len(result))
self.assertEqual(100, result[self.trading_pair])
@aioresponses()
@patch(
"hummingbot.connector.exchange.binance.binance_utils.convert_from_exchange_trading_pair"
)
def test_get_all_mid_prices(self, mock_api, mock_utils):
# Mocks binance_utils for BinanceOrderBook.diff_message_from_exchange()
mock_utils.return_value = self.trading_pair
url = utils.public_rest_url(
path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: List[Dict[str, Any]] = [{
# Truncated Response
"symbol": self.ex_trading_pair,
"bidPrice": "99",
"askPrice": "101",
}]
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result: Dict[str, float] = self.ev_loop.run_until_complete(
self.data_source.get_all_mid_prices())
self.assertEqual(1, len(result))
self.assertEqual(100, result[self.trading_pair])
@aioresponses()
@patch(
"hummingbot.connector.exchange.binance.binance_utils.convert_from_exchange_trading_pair"
)
def test_fetch_trading_pairs(self, mock_api, mock_utils):
# Mocks binance_utils for BinanceOrderBook.diff_message_from_exchange()
mock_utils.return_value = self.trading_pair
url = utils.public_rest_url(path_url=CONSTANTS.EXCHANGE_INFO_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# Truncated Response
"symbols": [
{
"symbol": self.ex_trading_pair,
"status": "TRADING",
"baseAsset": self.base_asset,
"quoteAsset": self.quote_asset,
},
]
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result: Dict[str] = self.ev_loop.run_until_complete(
self.data_source.fetch_trading_pairs())
self.assertEqual(1, len(result))
self.assertTrue(self.trading_pair in result)
@aioresponses()
@patch(
"hummingbot.connector.exchange.binance.binance_utils.convert_from_exchange_trading_pair"
)
def test_fetch_trading_pairs_exception_raised(self, mock_api, mock_utils):
# Mocks binance_utils for BinanceOrderBook.diff_message_from_exchange()
mock_utils.return_value = self.trading_pair
url = utils.public_rest_url(path_url=CONSTANTS.EXCHANGE_INFO_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=Exception)
result: Dict[str] = self.ev_loop.run_until_complete(
self.data_source.fetch_trading_pairs())
self.assertEqual(0, len(result))
def test_get_throttler_instance(self):
self.assertIsInstance(
BinanceAPIOrderBookDataSource._get_throttler_instance(),
AsyncThrottler)
@aioresponses()
def test_get_snapshot_successful(self, mock_api):
url = utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, body=ujson.dumps(self._snapshot_response()))
result: Dict[str, Any] = self.ev_loop.run_until_complete(
self.data_source.get_snapshot(self.trading_pair))
self.assertEqual(self._snapshot_response(), result)
@aioresponses()
def test_get_snapshot_catch_exception(self, mock_api):
url = utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=400)
with self.assertRaises(IOError):
self.ev_loop.run_until_complete(
self.data_source.get_snapshot(self.trading_pair))
@aioresponses()
def test_get_new_order_book(self, mock_api):
url = utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
"lastUpdateId": 1,
"bids": [["4.00000000", "431.00000000"]],
"asks": [["4.00000200", "12.00000000"]]
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result: OrderBook = self.ev_loop.run_until_complete(
self.data_source.get_new_order_book(self.trading_pair))
self.assertEqual(1, result.snapshot_uid)
@patch("aiohttp.ClientSession.ws_connect")
def test_create_websocket_connection_cancelled_when_connecting(
self, mock_ws):
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.ev_loop.run_until_complete(
self.data_source._create_websocket_connection())
@patch("aiohttp.ClientSession.ws_connect")
def test_create_websocket_connection_exception_raised(self, mock_ws):
mock_ws.side_effect = Exception("TEST ERROR.")
with self.assertRaises(Exception):
self.ev_loop.run_until_complete(
self.data_source._create_websocket_connection())
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occured when connecting to WebSocket server. Error: TEST ERROR."
))
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect")
def test_listen_for_trades_cancelled_when_connecting(
self, mock_ws, _: AsyncMock):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_exception_raised_when_connecting(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.side_effect = lambda **_: self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR."))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occured when connecting to WebSocket server. Error: TEST ERROR."
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with WebSocket connection. Retrying after 30 seconds..."
))
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_cancelled_when_listening(
self, mock_ws, _: AsyncMock):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive_json.side_effect = lambda: (
self._raise_exception(asyncio.CancelledError))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_logs_exception(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
incomplete_resp = {
"m": 1,
"i": 2,
}
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, incomplete_resp)
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
with self.assertRaises(asyncio.TimeoutError):
self.ev_loop.run_until_complete(
asyncio.wait_for(self.listening_task, 1))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with WebSocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_iter_message_throws_exception(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive_json.side_effect = lambda: self._raise_exception(
Exception("TEST ERROR"))
mock_ws.close.return_value = None
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
with self.assertRaises(asyncio.TimeoutError):
self.ev_loop.run_until_complete(
asyncio.wait_for(self.listening_task, 1))
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occured when parsing websocket payload. Error: TEST ERROR"
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with WebSocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_successful(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._successfully_subscribed_event())
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._trade_update_event())
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
msg: OrderBookMessage = self.ev_loop.run_until_complete(
msg_queue.get())
self.assertTrue(12345, msg.trade_id)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect")
def test_listen_for_order_book_diffs_cancelled_when_connecting(
self, mock_ws, _: AsyncMock):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_cancelled_when_listening(
self, mock_ws, _: AsyncMock):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive_json.side_effect = lambda: (
self._raise_exception(asyncio.CancelledError))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_logs_exception(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
incomplete_resp = {
"m": 1,
"i": 2,
}
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, incomplete_resp)
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
with self.assertRaises(asyncio.TimeoutError):
self.ev_loop.run_until_complete(
asyncio.wait_for(self.listening_task, 1))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with WebSocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_successful(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._successfully_subscribed_event())
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._order_diff_event())
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
msg: OrderBookMessage = self.ev_loop.run_until_complete(
msg_queue.get())
self.assertTrue(12345, msg.update_id)
@aioresponses()
def test_listen_for_order_book_snapshots_cancelled_when_fetching_snapshot(
self, mock_api):
url = utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=asyncio.CancelledError)
with self.assertRaises(asyncio.CancelledError):
self.ev_loop.run_until_complete(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, asyncio.Queue()))
@aioresponses()
def test_listen_for_order_book_snapshots_log_exception(self, mock_api):
msg_queue: asyncio.Queue = asyncio.Queue()
url = utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=Exception)
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
with self.assertRaises(asyncio.TimeoutError):
self.ev_loop.run_until_complete(
asyncio.wait_for(self.listening_task, 1))
self.assertTrue(
self._is_logged(
"ERROR",
f"Unexpected error fetching order book snapshot for {self.trading_pair}."
))
@aioresponses()
def test_listen_for_order_book_snapshots_successful(
self,
mock_api,
):
msg_queue: asyncio.Queue = asyncio.Queue()
url = utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, body=ujson.dumps(self._snapshot_response()))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
msg: OrderBookMessage = self.ev_loop.run_until_complete(
msg_queue.get())
self.assertTrue(12345, msg.update_id)
class BinancePerpetualUserStreamDataSourceUnitTests(unittest.TestCase):
# the level is required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ex_trading_pair = cls.base_asset + cls.quote_asset
cls.domain = CONSTANTS.TESTNET_DOMAIN
cls.api_key = "TEST_API_KEY"
cls.listen_key = "TEST_LISTEN_KEY"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task: Optional[asyncio.Task] = None
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = BinancePerpetualUserStreamDataSource(
api_key=self.api_key, domain=self.domain, throttler=self.throttler)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mock_done_event = asyncio.Event()
self.resume_test_event = asyncio.Event()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
def _mock_responses_done_callback(self, *_, **__):
self.mock_done_event.set()
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def _successful_get_listen_key_response(self) -> str:
resp = {"listenKey": self.listen_key}
return ujson.dumps(resp)
def _error_response(self) -> Dict[str, Any]:
resp = {"code": "ERROR CODE", "msg": "ERROR MESSAGE"}
return resp
def _simulate_user_update_event(self):
# Order Trade Update
resp = {
"e": "ORDER_TRADE_UPDATE",
"E": 1591274595442,
"T": 1591274595453,
"i": "SfsR",
"o": {
"s": "BTCUSD_200925",
"c": "TEST",
"S": "SELL",
"o": "TRAILING_STOP_MARKET",
"f": "GTC",
"q": "2",
"p": "0",
"ap": "0",
"sp": "9103.1",
"x": "NEW",
"X": "NEW",
"i": 8888888,
"l": "0",
"z": "0",
"L": "0",
"ma": "BTC",
"N": "BTC",
"n": "0",
"T": 1591274595442,
"t": 0,
"rp": "0",
"b": "0",
"a": "0",
"m": False,
"R": False,
"wt": "CONTRACT_PRICE",
"ot": "TRAILING_STOP_MARKET",
"ps": "LONG",
"cp": False,
"AP": "9476.8",
"cr": "5.0",
"pP": False,
},
}
return ujson.dumps(resp)
def test_last_recv_time(self):
# Initial last_recv_time
self.assertEqual(0, self.data_source.last_recv_time)
def test_get_throttler_instance(self):
self.assertIsInstance(self.data_source._get_throttler_instance(),
AsyncThrottler)
@aioresponses()
def test_get_listen_key_exception_raised(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.post(regex_url,
status=400,
body=ujson.dumps(self._error_response))
with self.assertRaises(IOError):
self.async_run_with_timeout(self.data_source.get_listen_key())
@aioresponses()
def test_get_listen_key_successful(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.post(regex_url,
body=self._successful_get_listen_key_response())
result: str = self.async_run_with_timeout(
self.data_source.get_listen_key())
self.assertEqual(self.listen_key, result)
@aioresponses()
def test_ping_listen_key_failed_log_warning(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.put(regex_url,
status=400,
body=ujson.dumps(self._error_response()))
self.data_source._current_listen_key = self.listen_key
result: bool = self.async_run_with_timeout(
self.data_source.ping_listen_key())
self.assertTrue(
self._is_logged(
"WARNING",
f"Failed to refresh the listen key {self.listen_key}: {self._error_response()}"
))
self.assertFalse(result)
@aioresponses()
def test_ping_listen_key_successful(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.put(regex_url, body=ujson.dumps({}))
self.data_source._current_listen_key = self.listen_key
result: bool = self.async_run_with_timeout(
self.data_source.ping_listen_key())
self.assertTrue(result)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_create_websocket_connection_cancelled_when_connecting(
self, mock_ws):
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source._create_websocket_connection())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_create_websocket_connection_log_exception(self, mock_ws):
mock_ws.side_effect = Exception("TEST ERROR.")
with self.assertRaises(Exception):
self.async_run_with_timeout(
self.data_source._create_websocket_connection())
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occured when connecting to WebSocket server. Error: TEST ERROR."
))
@aioresponses()
def test_manage_listen_key_task_loop_keep_alive_failed(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.put(regex_url,
status=400,
body=ujson.dumps(self._error_response()),
callback=self._mock_responses_done_callback)
self.data_source._current_listen_key = self.listen_key
# Simulate LISTEN_KEY_KEEP_ALIVE_INTERVAL reached
self.data_source._last_listen_key_ping_ts = 0
self.listening_task = self.ev_loop.create_task(
self.data_source._manage_listen_key_task_loop())
self.async_run_with_timeout(self.mock_done_event.wait())
self.assertTrue(
self._is_logged("ERROR", "Error occurred renewing listen key... "))
self.assertIsNone(self.data_source._current_listen_key)
self.assertFalse(
self.data_source._listen_key_initialized_event.is_set())
@aioresponses()
def test_manage_listen_key_task_loop_keep_alive_successful(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.put(regex_url,
body=ujson.dumps({}),
callback=self._mock_responses_done_callback)
self.data_source._current_listen_key = self.listen_key
# Simulate LISTEN_KEY_KEEP_ALIVE_INTERVAL reached
self.data_source._last_listen_key_ping_ts = 0
self.listening_task = self.ev_loop.create_task(
self.data_source._manage_listen_key_task_loop())
self.async_run_with_timeout(self.mock_done_event.wait())
self.assertTrue(
self._is_logged("INFO",
f"Refreshed listen key {self.listen_key}."))
self.assertGreater(self.data_source._last_listen_key_ping_ts, 0)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_create_websocket_connection_failed(
self, mock_api, mock_ws):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.post(regex_url,
body=self._successful_get_listen_key_response())
mock_ws.side_effect = lambda **_: self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR."))
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, msg_queue))
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"INFO", f"Successfully obtained listen key {self.listen_key}"))
self.assertTrue(
self._is_logged(
"INFO",
f"Connecting to {utils.wss_url(CONSTANTS.PRIVATE_WS_ENDPOINT, self.domain)}/{self.listen_key}.",
))
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occured when connecting to WebSocket server. Error: TEST ERROR."
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error while listening to user stream. Retrying after 5 seconds... Error: TEST ERROR.",
))
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.core.data_type.user_stream_tracker_data_source.UserStreamTrackerDataSource._sleep"
)
def test_listen_for_user_stream_iter_message_throws_exception(
self, mock_api, _, mock_ws):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {"listenKey": self.listen_key}
mock_api.post(regex_url, body=ujson.dumps(mock_response))
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive.side_effect = lambda: self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR"))
mock_ws.close.return_value = None
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, msg_queue))
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"INFO", f"Successfully obtained listen key {self.listen_key}"))
self.assertTrue(
self._is_logged(
"INFO",
f"Connecting to {utils.wss_url(CONSTANTS.PRIVATE_WS_ENDPOINT, self.domain)}/{self.listen_key}.",
))
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occurred when parsing websocket payload. Error: TEST ERROR"
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error while listening to user stream. Retrying after 5 seconds... Error: TEST ERROR",
))
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_handle_ping_frame(self, mock_api, mock_ws):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.post(regex_url,
body=self._successful_get_listen_key_response())
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, "", aiohttp.WSMsgType.PING)
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, self._simulate_user_update_event())
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, msg_queue))
msg = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(msg, self._simulate_user_update_event)
self.assertTrue(
self._is_logged("DEBUG",
"Received PING frame. Sending PONG frame..."))
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_handle_pong_frame(self, mock_api, mock_ws):
url = utils.rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_ENDPOINT,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.post(regex_url,
body=self._successful_get_listen_key_response())
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, "", aiohttp.WSMsgType.PONG)
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, self._simulate_user_update_event())
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, msg_queue))
msg = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(msg, self._simulate_user_update_event)
self.assertTrue(self._is_logged("DEBUG", "Received PONG frame."))
class NdaxUserStreamTrackerTests(TestCase):
def setUp(self) -> None:
super().setUp()
self.ws_sent_messages = []
self.ws_incoming_messages = asyncio.Queue()
self.listening_task = None
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
auth_assistant = NdaxAuth(uid='001',
api_key='testAPIKey',
secret_key='testSecret',
account_name="hbot")
self.tracker = NdaxUserStreamTracker(throttler=throttler,
auth_assistant=auth_assistant)
self.mocking_assistant = NetworkMockingAssistant()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def _authentication_response(self, authenticated: bool) -> str:
user = {
"UserId": 492,
"UserName": "******",
"Email": "*****@*****.**",
"EmailVerified": True,
"AccountId": 528,
"OMSId": 1,
"Use2FA": True
}
payload = {
"Authenticated": authenticated,
"SessionToken": "74e7c5b0-26b1-4ca5-b852-79b796b0e599",
"User": user,
"Locked": False,
"Requires2FA": False,
"EnforceEnable2FA": False,
"TwoFAType": None,
"TwoFAToken": None,
"errormsg": None
}
message = {
"m": 1,
"i": 1,
"n": CONSTANTS.AUTHENTICATE_USER_ENDPOINT_NAME,
"o": json.dumps(payload)
}
return json.dumps(message)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listening_process_authenticates_and_subscribes_to_events(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.listening_task = asyncio.get_event_loop().create_task(
self.tracker.start())
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, self._authentication_response(True))
# Add a dummy message for the websocket to read and include in the "messages" queue
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps('dummyMessage'))
first_received_message = asyncio.get_event_loop().run_until_complete(
self.tracker.user_stream.get())
self.assertEqual('dummyMessage', first_received_message)
class AscendExAPIOrderBookDataSourceTests(TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
def setUp(self) -> None:
super().setUp()
self.ev_loop = asyncio.get_event_loop()
self.base_asset = "BTC"
self.quote_asset = "USDT"
self.trading_pair = f"{self.base_asset}-{self.quote_asset}"
self.ex_trading_pair = f"{self.base_asset}/{self.quote_asset}"
self.log_records = []
self.listening_task = None
self.async_task: Optional[asyncio.Task] = None
self.shared_client = None
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.data_source = AscendExAPIOrderBookDataSource(
shared_client=self.shared_client,
throttler=self.throttler,
trading_pairs=[self.trading_pair])
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.data_source._trading_pair_symbol_map = {}
self.mocking_assistant = NetworkMockingAssistant()
self.resume_test_event = asyncio.Event()
def tearDown(self) -> None:
self.async_task and self.async_task.cancel()
self.listening_task and self.listening_task.cancel()
self.data_source._shared_client and self.data_source._shared_client.close(
)
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
@aioresponses()
def test_fetch_trading_pairs(self, api_mock):
mock_response = {
"code":
0,
"data": [
{
"symbol": self.ex_trading_pair,
"open": "0.06777",
"close": "0.06809",
"high": "0.06899",
"low": "0.06708",
"volume": "19823722",
"ask": ["0.0681", "43641"],
"bid": ["0.0676", "443"],
},
{
"symbol": "BTC/USDT",
"open": "0.06777",
"close": "0.06809",
"high": "0.06899",
"low": "0.06708",
"volume": "19823722",
"ask": ["0.0681", "43641"],
"bid": ["0.0676", "443"],
},
{
"symbol": "ETH/USDT",
"open": "0.06777",
"close": "0.06809",
"high": "0.06899",
"low": "0.06708",
"volume": "19823722",
"ask": ["0.0681", "43641"],
"bid": ["0.0676", "443"],
},
],
}
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.TICKER_PATH_URL}"
api_mock.get(url, body=json.dumps(mock_response))
trading_pairs = self.async_run_with_timeout(
self.data_source.fetch_trading_pairs(
client=self.data_source._shared_client,
throttler=self.throttler))
self.assertEqual(3, len(trading_pairs))
self.assertEqual("BTC-USDT", trading_pairs[1])
@aioresponses()
def test_get_last_traded_prices_requests_rest_api_price_when_subscription_price_not_available(
self, api_mock):
mock_response = {
"code": 0,
"data": {
"m":
"trades",
"symbol":
"BTC/USDT",
"data": [
{
"seqnum": 144115191800016553,
"p": "0.06762",
"q": "400",
"ts": 1573165890854,
"bm": False
},
{
"seqnum": 144115191800070421,
"p": "0.06797",
"q": "341",
"ts": 1573166037845,
"bm": True
},
],
},
}
self.data_source._trading_pairs = ["BTC-USDT"]
url = re.escape(
f"{CONSTANTS.REST_URL}/{CONSTANTS.TRADES_PATH_URL}?symbol=")
regex_url = re.compile(f"^{url}")
api_mock.get(regex_url, body=json.dumps(mock_response))
results = self.ev_loop.run_until_complete(
self.data_source.get_last_traded_prices(
trading_pairs=[self.trading_pair],
client=self.data_source._shared_client,
throttler=self.throttler))
self.assertEqual(results[self.trading_pair],
float(mock_response["data"]["data"][1]["p"]))
@aioresponses()
def test_get_order_book_http_error_raises_exception(self, api_mock):
mock_response = "ERROR WITH REQUEST"
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.DEPTH_PATH_URL}"
regex_url = re.compile(f"^{url}")
api_mock.get(regex_url, status=400, body=mock_response)
with self.assertRaises(IOError):
self.async_run_with_timeout(
self.data_source.get_order_book_data(
trading_pair=self.trading_pair, throttler=self.throttler))
@aioresponses()
def test_get_order_book_resp_code_erro_raises_exception(self, api_mock):
mock_response = {
"code": 100001,
"reason": "INVALID_HTTP_INPUT",
"message": "Http request is invalid"
}
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.DEPTH_PATH_URL}"
regex_url = re.compile(f"^{url}")
api_mock.get(regex_url, body=json.dumps(mock_response))
with self.assertRaises(IOError):
self.async_run_with_timeout(
self.data_source.get_order_book_data(
trading_pair=self.trading_pair, throttler=self.throttler))
@aioresponses()
def test_get_order_book_data_successful(self, api_mock):
mock_response = {
"code": 0,
"data": {
"m": "depth-snapshot",
"symbol": self.ex_trading_pair,
"data": {
"seqnum": 5068757,
"ts": 1573165838976,
"asks": [["0.06848", "4084.2"], ["0.0696", "15890.6"]],
"bids": [["0.06703", "13500"], ["0.06615", "24036.9"]],
},
},
}
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.DEPTH_PATH_URL}"
regex_url = re.compile(f"^{url}")
api_mock.get(regex_url, body=json.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source.get_order_book_data(
trading_pair=self.trading_pair, throttler=self.throttler))
self.assertTrue(result.get("symbol") == self.ex_trading_pair)
@aioresponses()
def test_get_new_order_book(self, api_mock):
mock_response = {
"code": 0,
"data": {
"m": "depth-snapshot",
"symbol": "BTC/USDT",
"data": {
"seqnum": 5068757,
"ts": 1573165838976,
"asks": [["0.06848", "4084.2"], ["0.0696", "15890.6"]],
"bids": [["0.06703", "13500"], ["0.06615", "24036.9"]],
},
},
}
self.data_source._trading_pairs = ["BTC-USDT"]
# path_url = ascend_ex_utils.rest_api_path_for_endpoint(CONSTANTS.ORDER_BOOK_ENDPOINT, self.trading_pair)
url = re.escape(
f"{CONSTANTS.REST_URL}/{CONSTANTS.DEPTH_PATH_URL}?symbol=")
regex_url = re.compile(f"^{url}")
api_mock.get(regex_url, body=json.dumps(mock_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.get_new_order_book(self.trading_pair))
order_book = self.ev_loop.run_until_complete(self.listening_task)
bids = list(order_book.bid_entries())
asks = list(order_book.ask_entries())
self.assertEqual(2, len(bids))
self.assertEqual(0.06703, round(bids[0].price, 5))
self.assertEqual(13500, round(bids[0].amount, 1))
self.assertEqual(1573165838976, bids[0].update_id)
self.assertEqual(2, len(asks))
self.assertEqual(0.06848, round(asks[0].price, 5))
self.assertEqual(4084.2, round(asks[0].amount, 1))
self.assertEqual(1573165838976, asks[0].update_id)
@patch("aiohttp.client.ClientSession.ws_connect")
def test_subscribe_to_order_book_streams_raises_exception(
self, ws_connect_mock):
ws_connect_mock.side_effect = Exception("TEST ERROR")
with self.assertRaisesRegex(Exception, "TEST ERROR"):
self.async_run_with_timeout(
self.data_source._subscribe_to_order_book_streams())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred subscribing to order book trading and delta streams..."
))
@patch("aiohttp.client.ClientSession.ws_connect")
def test_subscribe_to_order_book_streams_raises_cancel_exception(
self, ws_connect_mock):
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source._subscribe_to_order_book_streams())
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_subscribe_to_order_book_streams_successful(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(
self.data_source._subscribe_to_order_book_streams())
self.assertTrue(
self._is_logged(
"INFO",
f"Subscribed to ['{self.trading_pair}'] orderbook trading and delta streams..."
))
sent_messages = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value)
stream_topics = [payload["ch"] for payload in sent_messages]
self.assertEqual(2, len(stream_topics))
self.assertTrue(
f"{self.data_source.DIFF_TOPIC_ID}:{self.ex_trading_pair}" in
stream_topics)
self.assertTrue(
f"{self.data_source.TRADE_TOPIC_ID}:{self.ex_trading_pair}" in
stream_topics)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_exception_raised_cancelled_when_connecting(
self, ws_connect_mock):
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_subscriptions())
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_exception_raised_cancelled_when_subscribing(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_subscriptions())
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_exception_raised_cancelled_when_listening(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.receive.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_subscriptions())
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.ascend_ex.ascend_ex_api_order_book_data_source.AscendExAPIOrderBookDataSource._sleep"
)
def test_listen_for_subscription_logs_exception(self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.receive.side_effect = lambda: self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR"))
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred iterating through websocket messages."
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred when listening to order book streams. Retrying in 5 seconds..."
))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_enqueues_diff_and_trade_messages(
self, ws_connect_mock):
diffs_queue = self.data_source._message_queue[
self.data_source.DIFF_TOPIC_ID]
trade_queue = self.data_source._message_queue[
self.data_source.TRADE_TOPIC_ID]
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add diff event message be processed
diff_response = {
"m": "depth",
"symbol": self.ex_trading_pair,
"data": {
"ts": 1573069021376,
"seqnum": 2097965,
"asks": [["0.06844", "10760"]],
"bids": [["0.06777", "562.4"], ["0.05", "221760.6"]],
},
}
# Add trade event message be processed
trade_response = {
"m":
"trades",
"symbol":
"BTC/USDT",
"data": [
{
"seqnum": 144115191800016553,
"p": "0.06762",
"q": "400",
"ts": 1573165890854,
"bm": False
},
{
"seqnum": 144115191800070421,
"p": "0.06797",
"q": "341",
"ts": 1573166037845,
"bm": True
},
],
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(diff_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(trade_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertEqual(1, diffs_queue.qsize())
self.assertEqual(1, trade_queue.qsize())
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_handle_ping_message(
self, ws_connect_mock):
# In AscendEx Ping message is sent as a aiohttp.WSMsgType.TEXT message
mock_response = {"m": "ping", "hp": 3}
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(mock_response),
message_type=aiohttp.WSMsgType.TEXT,
)
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
sent_json = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value)
self.assertTrue(any(["pong" in str(payload) for payload in sent_json]))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diff_raises_cancel_exceptions(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(ev_loop=self.ev_loop,
output=queue))
with self.assertRaises(asyncio.CancelledError):
self.listening_task.cancel()
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.ascend_ex.ascend_ex_api_order_book_data_source.AscendExAPIOrderBookDataSource._sleep"
)
def test_listen_for_order_book_diff_logs_exception_parsing_message(
self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add incomplete diff event message be processed
diff_response = {"m": "depth", "symbol": "incomplete response"}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(diff_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(ev_loop=self.ev_loop,
output=output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with WebSocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diff_successful(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add diff event message be processed
diff_response = {
"m": "depth",
"symbol": self.ex_trading_pair,
"data": {
"ts": 1573069021376,
"seqnum": 2097965,
"asks": [["0.06844", "10760"]],
"bids": [["0.06777", "562.4"], ["0.05", "221760.6"]],
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(diff_response))
diffs_queue = self.data_source._message_queue[
self.data_source.DIFF_TOPIC_ID]
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(ev_loop=self.ev_loop,
output=output_queue))
order_book_message = self.async_run_with_timeout(output_queue.get())
self.assertTrue(diffs_queue.empty())
self.assertEqual(1573069021376, order_book_message.update_id)
self.assertEqual(1573069021376, order_book_message.timestamp)
self.assertEqual(0.06777, order_book_message.bids[0].price)
self.assertEqual(0.05, order_book_message.bids[1].price)
self.assertEqual(0.06844, order_book_message.asks[0].price)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_raises_cancel_exceptions(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=queue))
with self.assertRaises(asyncio.CancelledError):
self.listening_task.cancel()
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.ascend_ex.ascend_ex_api_order_book_data_source.AscendExAPIOrderBookDataSource._sleep"
)
def test_listen_for_trades_logs_exception_parsing_message(
self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add incomplete diff event message be processed
diff_response = {"m": "trades", "symbol": "incomplete response"}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(diff_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with WebSocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_successful(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add trade event message be processed
trade_response = {
"m":
"trades",
"symbol":
"BTC/USDT",
"data": [
{
"seqnum": 144115191800016553,
"p": "0.06762",
"q": "400",
"ts": 1573165890854,
"bm": False
},
{
"seqnum": 144115191800070421,
"p": "0.06797",
"q": "341",
"ts": 1573166037845,
"bm": True
},
],
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(trade_response))
trades_queue = self.data_source._message_queue[
self.data_source.DIFF_TOPIC_ID]
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=output_queue))
first_trade_message = self.async_run_with_timeout(output_queue.get())
second_trade_message = self.async_run_with_timeout(output_queue.get())
self.assertTrue(trades_queue.empty())
self.assertEqual(1573165890854, first_trade_message.timestamp)
self.assertEqual(1573166037845, second_trade_message.timestamp)
@aioresponses()
def test_listen_for_order_book_snapshot_event(self, api_mock):
mock_response = {
"code": 0,
"data": {
"m": "depth-snapshot",
"symbol": self.ex_trading_pair,
"data": {
"seqnum": 5068757,
"ts": 1573165838976,
"asks": [["0.06848", "4084.2"], ["0.0696", "15890.6"]],
"bids": [["0.06703", "13500"], ["0.06615", "24036.9"]],
},
},
}
self.data_source._trading_pairs = ["BTC-USDT"]
# Add trade event message be processed
url = re.escape(
f"{CONSTANTS.REST_URL}/{CONSTANTS.DEPTH_PATH_URL}?symbol=")
regex_url = re.compile(f"^{url}")
api_mock.get(regex_url, body=json.dumps(mock_response))
order_book_messages = asyncio.Queue()
task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
ev_loop=self.ev_loop, output=order_book_messages))
order_book_message = self.ev_loop.run_until_complete(
order_book_messages.get())
try:
task.cancel()
self.ev_loop.run_until_complete(task)
except asyncio.CancelledError:
# The exception will happen when cancelling the task
pass
self.assertTrue(order_book_messages.empty())
self.assertEqual(1573165838976, order_book_message.update_id)
self.assertEqual(1573165838976, order_book_message.timestamp)
self.assertEqual(0.06703, order_book_message.bids[0].price)
self.assertEqual(0.06848, order_book_message.asks[0].price)
class HuobiAPIUserStreamDataSourceTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.auth = HuobiAuth("somKey", "someSecretKey")
cls.ev_loop = asyncio.get_event_loop()
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.async_tasks: List[asyncio.Task] = []
self.api_factory = build_api_factory()
self.data_source = HuobiAPIUserStreamDataSource(
huobi_auth=self.auth, api_factory=self.api_factory)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.resume_test_event = asyncio.Event()
def tearDown(self) -> None:
for task in self.async_tasks:
task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def test_get_ws_assistant(self):
data_source = HuobiAPIUserStreamDataSource(self.auth)
self.assertIsNone(data_source._ws_assistant)
initial_ws_assistant = self.async_run_with_timeout(
data_source._get_ws_assistant())
self.assertIsNotNone(data_source._ws_assistant)
self.assertIsInstance(initial_ws_assistant, WSAssistant)
subsequent_ws_assistant = self.async_run_with_timeout(
data_source._get_ws_assistant())
self.assertEqual(initial_ws_assistant, subsequent_ws_assistant)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_authenticate_client_raises_cancelled(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.receive.side_effect = asyncio.CancelledError
# Initialise WSAssistant and assume connected to websocket server
self.async_run_with_timeout(self.data_source._get_ws_assistant())
self.async_run_with_timeout(
self.data_source._ws_assistant.connect(CONSTANTS.WS_PRIVATE_URL))
self.assertIsNotNone(self.data_source._ws_assistant)
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source._authenticate_client())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_authenticate_client_logs_exception(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Initialise WSAssistant and assume connected to websocket server
self.async_run_with_timeout(self.data_source._get_ws_assistant())
self.async_run_with_timeout(
self.data_source._ws_assistant.connect(CONSTANTS.WS_PRIVATE_URL))
self.assertIsNotNone(self.data_source._ws_assistant)
ws_connect_mock.return_value.send_json.side_effect = Exception(
"TEST ERROR")
with self.assertRaisesRegex(Exception, "TEST ERROR"):
self.async_run_with_timeout(
self.data_source._authenticate_client())
self._is_logged(
"ERROR",
"Error occurred authenticating websocket connection... Error: TEST ERROR"
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_authenticate_client_failed(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Initialise WSAssistant and assume connected to websocket server
self.async_run_with_timeout(self.data_source._get_ws_assistant())
self.async_run_with_timeout(
self.data_source._ws_assistant.connect(CONSTANTS.WS_PRIVATE_URL))
self.assertIsNotNone(self.data_source._ws_assistant)
error_auth_response = {
"action": "req",
"code": 0,
"TEST_ERROR": "ERROR WITH AUTHENTICATION"
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(error_auth_response))
with self.assertRaisesRegex(ValueError,
"User Stream Authentication Fail!"):
self.async_run_with_timeout(
self.data_source._authenticate_client())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_authenticate_client_successful(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Initialise WSAssistant and assume connected to websocket server
self.async_run_with_timeout(self.data_source._get_ws_assistant())
self.async_run_with_timeout(
self.data_source._ws_assistant.connect(CONSTANTS.WS_PRIVATE_URL))
self.assertIsNotNone(self.data_source._ws_assistant)
successful_auth_response = {
"action": "req",
"code": 200,
"ch": "auth",
"data": {}
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_auth_response))
result = self.async_run_with_timeout(
self.data_source._authenticate_client())
self.assertIsNone(result)
self._is_logged("INFO", "Successfully authenticated to user...")
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_subscribe_channels_raises_cancelled(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.receive.side_effect = asyncio.CancelledError
# Initialise WSAssistant and assume connected to websocket server
self.async_run_with_timeout(self.data_source._get_ws_assistant())
self.async_run_with_timeout(
self.data_source._ws_assistant.connect(CONSTANTS.WS_PRIVATE_URL))
self.assertIsNotNone(self.data_source._ws_assistant)
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(self.data_source._subscribe_channels())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_subscribe_channels_subscribe_topic_fail(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Initialise WSAssistant and assume connected to websocket server
self.async_run_with_timeout(self.data_source._get_ws_assistant())
self.async_run_with_timeout(
self.data_source._ws_assistant.connect(CONSTANTS.WS_PRIVATE_URL))
self.assertIsNotNone(self.data_source._ws_assistant)
error_sub_response = {
"action": "sub",
"code": 0,
"TEST_ERROR": "ERROR SUBSCRIBING TO USER STREAM TOPIC"
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(error_sub_response))
with self.assertRaisesRegex(ValueError,
"Error subscribing to topic: "):
self.async_run_with_timeout(self.data_source._subscribe_channels())
self._is_logged(
"ERROR",
f"Cannot subscribe to user stream topic: {CONSTANTS.HUOBI_ORDER_UPDATE_TOPIC}"
)
self._is_logged(
"ERROR",
"Unexpected error occurred subscribing to private user streams...")
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_subscribe_channels_successful(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Initialise WSAssistant and assume connected to websocket server
self.async_run_with_timeout(self.data_source._get_ws_assistant())
self.async_run_with_timeout(
self.data_source._ws_assistant.connect(CONSTANTS.WS_PRIVATE_URL))
self.assertIsNotNone(self.data_source._ws_assistant)
successful_sub_trades_response = {
"action": "sub",
"code": 200,
"ch": "trade.clearing#*",
"data": {}
}
successful_sub_order_response = {
"action": "sub",
"code": 200,
"ch": "orders#*",
"data": {}
}
successful_sub_account_response = {
"action": "sub",
"code": 200,
"ch": "accounts.update#2",
"data": {}
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_trades_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_order_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_account_response))
result = self.async_run_with_timeout(
self.data_source._subscribe_channels())
self.assertIsNone(result)
subscription_requests_sent = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value)
expected_orders_channel_subscription = {
"action": "sub",
"ch": "orders#*"
}
self.assertIn(expected_orders_channel_subscription,
subscription_requests_sent)
expected_accounts_channel_subscription = {
"action": "sub",
"ch": "accounts.update#2"
}
self.assertIn(expected_accounts_channel_subscription,
subscription_requests_sent)
expected_trades_channel_subscription = {
"action": "sub",
"ch": "trade.clearing#*"
}
self.assertIn(expected_trades_channel_subscription,
subscription_requests_sent)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.huobi.huobi_api_user_stream_data_source.HuobiAPIUserStreamDataSource._sleep"
)
def test_listen_for_user_stream_raises_cancelled_error(
self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.side_effect = asyncio.CancelledError
msg_queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_user_stream(msg_queue))
self.assertEqual(0, msg_queue.qsize())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.huobi.huobi_api_user_stream_data_source.HuobiAPIUserStreamDataSource._sleep"
)
def test_listen_for_user_stream_logs_exception(self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
successful_auth_response = {
"action": "req",
"code": 200,
"ch": "auth",
"data": {}
}
successful_sub_trades_response = {
"action": "sub",
"code": 200,
"ch": "trade.clearing#*",
"data": {}
}
successful_sub_order_response = {
"action": "sub",
"code": 200,
"ch": "orders#*",
"data": {}
}
successful_sub_account_response = {
"action": "sub",
"code": 200,
"ch": "accounts.update#2",
"data": {}
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_auth_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_trades_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_order_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_account_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.CLOSE)
msg_queue = asyncio.Queue()
self.async_tasks.append(
self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue)))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertEqual(0, msg_queue.qsize())
self._is_logged(
"ERROR",
"Unexpected error with Huobi WebSocket connection. Retrying after 30 seconds..."
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.huobi.huobi_api_user_stream_data_source.HuobiAPIUserStreamDataSource._sleep"
)
def test_listen_for_user_stream_handle_ping(self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
successful_auth_response = {
"action": "req",
"code": 200,
"ch": "auth",
"data": {}
}
successful_sub_trades_response = {
"action": "sub",
"code": 200,
"ch": "trade.clearing#*",
"data": {}
}
successful_sub_order_response = {
"action": "sub",
"code": 200,
"ch": "orders#*",
"data": {}
}
successful_sub_account_response = {
"action": "sub",
"code": 200,
"ch": "accounts.update#2",
"data": {}
}
ping_response = {"action": "ping", "data": {"ts": 1637553193021}}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_auth_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_trades_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_order_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_account_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(ping_response))
msg_queue = asyncio.Queue()
self.async_tasks.append(
self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue)))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertEqual(0, msg_queue.qsize())
sent_json = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value)
self.assertTrue(any(["pong" in str(payload) for payload in sent_json]))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.huobi.huobi_api_user_stream_data_source.HuobiAPIUserStreamDataSource._sleep"
)
def test_listen_for_user_stream_enqueues_updates(self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
successful_auth_response = {
"action": "req",
"code": 200,
"ch": "auth",
"data": {}
}
successful_sub_trades_response = {
"action": "sub",
"code": 200,
"ch": "trade.clearing#*",
"data": {}
}
successful_sub_order_response = {
"action": "sub",
"code": 200,
"ch": "orders#*",
"data": {}
}
successful_sub_account_response = {
"action": "sub",
"code": 200,
"ch": "accounts.update#2",
"data": {}
}
ping_response = {"action": "ping", "data": {"ts": 1637553193021}}
order_update_response = {
"action": "push",
"ch": "orders#",
"data": {
"execAmt": "0",
"lastActTime": 1637553210074,
"orderSource": "spot-api",
"remainAmt": "0.005",
"orderPrice": "4122.62",
"orderSize": "0.005",
"symbol": "ethusdt",
"orderId": 414497810678464,
"orderStatus": "canceled",
"eventType": "cancellation",
"clientOrderId": "AAc484720a-buy-ETH-USDT-1637553180003697",
"type": "buy-limit-maker",
},
}
account_update_response = {
"action": "push",
"ch": "accounts.update#2",
"data": {
"currency": "usdt",
"accountId": 15026496,
"balance": "100",
"available": "100",
"changeType": "order.cancel",
"accountType": "trade",
"seqNum": 117,
"changeTime": 1637553210076,
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_auth_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_trades_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_order_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(successful_sub_account_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(ping_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(order_update_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message=json.dumps(account_update_response))
msg_queue = asyncio.Queue()
self.async_tasks.append(
self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue)))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertEqual(2, msg_queue.qsize())
class TestKucoinAPIUserStreamDataSource(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.api_key = "someKey"
cls.api_passphrase = "somePassPhrase"
cls.api_secret_key = "someSecretKey"
def setUp(self) -> None:
super().setUp()
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.auth = KucoinAuth(self.api_key, self.api_passphrase,
self.api_secret_key)
self.data_source = KucoinAPIUserStreamDataSource(
self.throttler, self.auth)
self.mocking_assistant = NetworkMockingAssistant()
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
@staticmethod
def get_listen_key_mock():
listen_key = {
"code": "200000",
"data": {
"token":
"someToken",
"instanceServers": [{
"endpoint": "wss://someEndpoint",
"encrypt": True,
"protocol": "websocket",
"pingInterval": 18000,
"pingTimeout": 10000,
}]
}
}
return listen_key
@aioresponses()
def test_get_listen_key_raises(self, mock_api):
url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PRIVATE_WS_DATA_PATH_URL
mock_api.post(url, status=500)
with self.assertRaises(IOError):
self.async_run_with_timeout(self.data_source.get_listen_key())
@aioresponses()
def test_get_listen_key(self, mock_api):
url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PRIVATE_WS_DATA_PATH_URL
resp = self.get_listen_key_mock()
mock_api.post(url, body=json.dumps(resp))
ret = self.async_run_with_timeout(self.data_source.get_listen_key())
self.assertEqual(ret, resp) # shallow comparison ok
@aioresponses()
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_to_user_stream_subscribes_to_private_topics(
self, mock_api, ws_connect_mock):
url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PRIVATE_WS_DATA_PATH_URL
resp = self.get_listen_key_mock()
mock_api.post(url, body=json.dumps(resp))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
msg_queue = asyncio.Queue()
self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, msg_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(
ws_connect_mock.return_value)
self.assertEqual(len(CONSTANTS.PRIVATE_ENDPOINT_NAMES),
len(sent_messages))
subscribed_endpoints = {m["topic"] for m in sent_messages}
self.assertEqual(set(CONSTANTS.PRIVATE_ENDPOINT_NAMES),
subscribed_endpoints)
@aioresponses()
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_to_user_stream_accepts_message(self, mock_api,
ws_connect_mock):
url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PRIVATE_WS_DATA_PATH_URL
resp = self.get_listen_key_mock()
mock_api.post(url, body=json.dumps(resp))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
msg = "someMsg"
msg_queue = asyncio.Queue()
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(msg))
self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, msg_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertTrue(not msg_queue.empty())
queued = msg_queue.get_nowait()
self.assertEqual(msg, queued)
@aioresponses()
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_to_user_stream_sends_ping_ignores_pong(
self, mock_api, ws_connect_mock):
url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PRIVATE_WS_DATA_PATH_URL
resp = self.get_listen_key_mock()
mock_api.post(url, body=json.dumps(resp))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.PONG)
msg = "someMsg"
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(msg))
msg_queue = asyncio.Queue()
self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, msg_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
ws_connect_mock.return_value.ping.assert_called() # ping was sent
self.assertTrue(not msg_queue.empty())
queued = msg_queue.get_nowait()
self.assertEqual(msg, queued)
class BinancePerpetualDerivativeUnitTest(unittest.TestCase):
# the level is required to receive logs from the data source logger
level = 0
start_timestamp: float = pd.Timestamp("2021-01-01", tz="UTC").timestamp()
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.symbol = f"{cls.base_asset}{cls.quote_asset}"
cls.domain = CONSTANTS.TESTNET_DOMAIN
cls.listen_key = "TEST_LISTEN_KEY"
cls.ev_loop = asyncio.get_event_loop()
@patch("hummingbot.connector.exchange.binance.binance_time.BinanceTime.start")
def setUp(self, _) -> None:
super().setUp()
self.log_records = []
self.ws_sent_messages = []
self.ws_incoming_messages = asyncio.Queue()
self.resume_test_event = asyncio.Event()
self.exchange = BinancePerpetualDerivative(
binance_perpetual_api_key="testAPIKey",
binance_perpetual_api_secret="testSecret",
trading_pairs=[self.trading_pair],
domain=self.domain,
)
self.exchange.logger().setLevel(1)
self.exchange.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.test_task: Optional[asyncio.Task] = None
self.resume_test_event = asyncio.Event()
def tearDown(self) -> None:
self.test_task and self.test_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(record.levelname == log_level and record.getMessage() == message for record in self.log_records)
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(asyncio.wait_for(coroutine, timeout))
return ret
def _get_position_risk_api_endpoint_single_position_list(self) -> List[Dict[str, Any]]:
positions = [
{
"symbol": self.symbol,
"positionAmt": "1",
"entryPrice": "10",
"markPrice": "11",
"unRealizedProfit": "1",
"liquidationPrice": "100",
"leverage": "1",
"maxNotionalValue": "9",
"marginType": "cross",
"isolatedMargin": "0",
"isAutoAddMargin": "false",
"positionSide": "BOTH",
"notional": "11",
"isolatedWallet": "0",
"updateTime": int(self.start_timestamp),
}
]
return positions
def _get_account_update_ws_event_single_position_dict(self) -> Dict[str, Any]:
account_update = {
"e": "ACCOUNT_UPDATE",
"E": 1564745798939,
"T": 1564745798938,
"a": {
"m": "POSITION",
"B": [
{"a": "USDT", "wb": "122624.12345678", "cw": "100.12345678", "bc": "50.12345678"},
],
"P": [
{
"s": self.symbol,
"pa": "1",
"ep": "10",
"cr": "200",
"up": "1",
"mt": "cross",
"iw": "0.00000000",
"ps": "BOTH",
},
],
},
}
return account_update
@aioresponses()
def test_existing_account_position_detected_on_positions_update(self, req_mock):
url = utils.rest_url(
CONSTANTS.POSITION_INFORMATION_URL, domain=self.domain, api_version=CONSTANTS.API_VERSION_V2
)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
positions = self._get_position_risk_api_endpoint_single_position_list()
req_mock.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
self.assertEqual(len(self.exchange.account_positions), 1)
pos = list(self.exchange.account_positions.values())[0]
self.assertEqual(pos.trading_pair.replace("-", ""), self.symbol)
@aioresponses()
def test_account_position_updated_on_positions_update(self, req_mock):
url = utils.rest_url(
CONSTANTS.POSITION_INFORMATION_URL, domain=self.domain, api_version=CONSTANTS.API_VERSION_V2
)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
positions = self._get_position_risk_api_endpoint_single_position_list()
req_mock.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
self.assertEqual(len(self.exchange.account_positions), 1)
pos = list(self.exchange.account_positions.values())[0]
self.assertEqual(pos.amount, 1)
positions[0]["positionAmt"] = "2"
req_mock.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
pos = list(self.exchange.account_positions.values())[0]
self.assertEqual(pos.amount, 2)
@aioresponses()
def test_new_account_position_detected_on_positions_update(self, req_mock):
url = utils.rest_url(
CONSTANTS.POSITION_INFORMATION_URL, domain=self.domain, api_version=CONSTANTS.API_VERSION_V2
)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
req_mock.get(regex_url, body=json.dumps([]))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
self.assertEqual(len(self.exchange.account_positions), 0)
positions = self._get_position_risk_api_endpoint_single_position_list()
req_mock.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
self.assertEqual(len(self.exchange.account_positions), 1)
@aioresponses()
def test_closed_account_position_removed_on_positions_update(self, req_mock):
url = utils.rest_url(
CONSTANTS.POSITION_INFORMATION_URL, domain=self.domain, api_version=CONSTANTS.API_VERSION_V2
)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
positions = self._get_position_risk_api_endpoint_single_position_list()
req_mock.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
self.assertEqual(len(self.exchange.account_positions), 1)
positions[0]["positionAmt"] = "0"
req_mock.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
self.assertEqual(len(self.exchange.account_positions), 0)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_new_account_position_detected_on_stream_event(self, mock_api, ws_connect_mock):
url = utils.rest_url(CONSTANTS.BINANCE_USER_STREAM_ENDPOINT, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
listen_key_response = {"listenKey": self.listen_key}
mock_api.post(regex_url, body=json.dumps(listen_key_response))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.ev_loop.create_task(self.exchange._user_stream_tracker.start())
self.assertEqual(len(self.exchange.account_positions), 0)
account_update = self._get_account_update_ws_event_single_position_dict()
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(account_update))
url = utils.rest_url(
CONSTANTS.POSITION_INFORMATION_URL, domain=self.domain, api_version=CONSTANTS.API_VERSION_V2
)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
positions = self._get_position_risk_api_endpoint_single_position_list()
mock_api.get(regex_url, body=json.dumps(positions))
self.ev_loop.create_task(self.exchange._user_stream_event_listener())
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertEqual(len(self.exchange.account_positions), 1)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_account_position_updated_on_stream_event(self, mock_api, ws_connect_mock):
url = utils.rest_url(
CONSTANTS.POSITION_INFORMATION_URL, domain=self.domain, api_version=CONSTANTS.API_VERSION_V2
)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
positions = self._get_position_risk_api_endpoint_single_position_list()
mock_api.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
url = utils.rest_url(CONSTANTS.BINANCE_USER_STREAM_ENDPOINT, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
listen_key_response = {"listenKey": self.listen_key}
mock_api.post(regex_url, body=json.dumps(listen_key_response))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.ev_loop.create_task(self.exchange._user_stream_tracker.start())
self.assertEqual(len(self.exchange.account_positions), 1)
pos = list(self.exchange.account_positions.values())[0]
self.assertEqual(pos.amount, 1)
account_update = self._get_account_update_ws_event_single_position_dict()
account_update["a"]["P"][0]["pa"] = 2
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(account_update))
self.ev_loop.create_task(self.exchange._user_stream_event_listener())
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertEqual(len(self.exchange.account_positions), 1)
pos = list(self.exchange.account_positions.values())[0]
self.assertEqual(pos.amount, 2)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_closed_account_position_removed_on_stream_event(self, mock_api, ws_connect_mock):
url = utils.rest_url(
CONSTANTS.POSITION_INFORMATION_URL, domain=self.domain, api_version=CONSTANTS.API_VERSION_V2
)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
positions = self._get_position_risk_api_endpoint_single_position_list()
mock_api.get(regex_url, body=json.dumps(positions))
task = self.ev_loop.create_task(self.exchange._update_positions())
self.async_run_with_timeout(task)
url = utils.rest_url(CONSTANTS.BINANCE_USER_STREAM_ENDPOINT, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
listen_key_response = {"listenKey": self.listen_key}
mock_api.post(regex_url, body=json.dumps(listen_key_response))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.ev_loop.create_task(self.exchange._user_stream_tracker.start())
self.assertEqual(len(self.exchange.account_positions), 1)
account_update = self._get_account_update_ws_event_single_position_dict()
account_update["a"]["P"][0]["pa"] = 0
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(account_update))
self.ev_loop.create_task(self.exchange._user_stream_event_listener())
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertEqual(len(self.exchange.account_positions), 0)
@aioresponses()
def test_set_position_mode_initial_mode_is_none(self, mock_api):
self.assertIsNone(self.exchange.position_mode)
url = utils.rest_url(CONSTANTS.CHANGE_POSITION_MODE_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
get_position_mode_response = {"dualSidePosition": False} # True: Hedge Mode; False: One-way Mode
post_position_mode_response = {"code": 200, "msg": "success"}
mock_api.get(regex_url, body=json.dumps(get_position_mode_response))
mock_api.post(regex_url, body=json.dumps(post_position_mode_response))
task = self.ev_loop.create_task(self.exchange._set_position_mode(PositionMode.HEDGE))
self.async_run_with_timeout(task)
self.assertEqual(PositionMode.HEDGE, self.exchange.position_mode)
@aioresponses()
def test_set_position_initial_mode_unchanged(self, mock_api):
self.exchange._position_mode = PositionMode.ONEWAY
url = utils.rest_url(CONSTANTS.CHANGE_POSITION_MODE_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
get_position_mode_response = {"dualSidePosition": False} # True: Hedge Mode; False: One-way Mode
mock_api.get(regex_url, body=json.dumps(get_position_mode_response))
task = self.ev_loop.create_task(self.exchange._set_position_mode(PositionMode.ONEWAY))
self.async_run_with_timeout(task)
self.assertEqual(PositionMode.ONEWAY, self.exchange.position_mode)
@aioresponses()
def test_set_position_mode_diff_initial_mode_change_successful(self, mock_api):
self.exchange._position_mode = PositionMode.ONEWAY
url = utils.rest_url(CONSTANTS.CHANGE_POSITION_MODE_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
get_position_mode_response = {"dualSidePosition": False} # True: Hedge Mode; False: One-way Mode
post_position_mode_response = {"code": 200, "msg": "success"}
mock_api.get(regex_url, body=json.dumps(get_position_mode_response))
mock_api.post(regex_url, body=json.dumps(post_position_mode_response))
task = self.ev_loop.create_task(self.exchange._set_position_mode(PositionMode.HEDGE))
self.async_run_with_timeout(task)
self.assertEqual(PositionMode.HEDGE, self.exchange.position_mode)
@aioresponses()
def test_set_position_mode_diff_initial_mode_change_fail(self, mock_api):
self.exchange._position_mode = PositionMode.ONEWAY
url = utils.rest_url(CONSTANTS.CHANGE_POSITION_MODE_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
get_position_mode_response = {"dualSidePosition": False} # True: Hedge Mode; False: One-way Mode
post_position_mode_response = {"code": -4059, "msg": "No need to change position side."}
mock_api.get(regex_url, body=json.dumps(get_position_mode_response))
mock_api.post(regex_url, body=json.dumps(post_position_mode_response))
task = self.ev_loop.create_task(self.exchange._set_position_mode(PositionMode.HEDGE))
self.async_run_with_timeout(task)
self.assertEqual(PositionMode.ONEWAY, self.exchange.position_mode)
@patch("aiohttp.ClientSession.ws_connect")
def test_funding_info_polling_loop_cancelled_when_connecting(self, ws_connect_mock):
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(self.exchange._funding_info_polling_loop())
@patch("aiohttp.ClientSession.ws_connect")
def test_funding_info_polling_loop_cancelled_when_listening(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
ws_connect_mock.return_value.receive_json.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(self.exchange._funding_info_polling_loop())
@patch("aiohttp.ClientSession.ws_connect")
@patch("hummingbot.connector.derivative.binance_perpetual.binance_perpetual_derivative.BinancePerpetualDerivative._sleep")
def test_funding_info_polling_loop_log_exception(self, mock_sleep, ws_connect_mock):
mock_sleep.side_effect = lambda: (
# Allows _funding_info_polling_loop task to yield control over thread
self.ev_loop.run_until_complete(asyncio.sleep(0.5))
)
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
ws_connect_mock.return_value.receive_json.side_effect = lambda: (
self._create_exception_and_unlock_test_with_event(Exception("TEST ERROR"))
)
self.test_task = self.ev_loop.create_task(self.exchange._funding_info_polling_loop())
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(self._is_logged("ERROR",
"Unexpected error updating funding info. Retrying after 10 seconds... "))
class AltmarketsAPIOrderBookDataSourceTests(TestCase):
# logging.Level required to receive logs from the exchange
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "HBOT"
cls.quote_asset = "USDT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.exchange_trading_pair = convert_to_exchange_trading_pair(
cls.trading_pair)
cls.api_key = "testKey"
cls.api_secret_key = "testSecretKey"
cls.username = "******"
cls.throttler = AsyncThrottler(Constants.RATE_LIMITS)
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.data_source = AltmarketsAPIOrderBookDataSource(
throttler=self.throttler, trading_pairs=[self.trading_pair])
self.mocking_assistant = NetworkMockingAssistant()
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def test_throttler_rates(self):
self.assertEqual(
str(self.throttler._rate_limits[0]),
str(self.data_source._get_throttler_instance()._rate_limits[0]))
self.assertEqual(
str(self.throttler._rate_limits[-1]),
str(self.data_source._get_throttler_instance()._rate_limits[-1]))
@aioresponses()
def test_get_last_traded_prices(self, mock_api):
url = f"{Constants.REST_URL}/{Constants.ENDPOINT['TICKER_SINGLE'].format(trading_pair=self.exchange_trading_pair)}"
resp = {"ticker": {"last": 51234.56}}
mock_api.get(url, body=json.dumps(resp))
results = self.async_run_with_timeout(
AltmarketsAPIOrderBookDataSource.get_last_traded_prices(
trading_pairs=[self.trading_pair], throttler=self.throttler))
self.assertIn(self.trading_pair, results)
self.assertEqual(Decimal("51234.56"), results[self.trading_pair])
@aioresponses()
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_http_utils.retry_sleep_time"
)
def test_get_last_traded_prices_multiple(self, mock_api,
retry_sleep_time_mock):
retry_sleep_time_mock.side_effect = lambda *args, **kwargs: 0
url = f"{Constants.REST_URL}/{Constants.ENDPOINT['TICKER']}"
resp = {
f"{self.exchange_trading_pair}": {
"ticker": {
"last": 51234.56
}
},
"rogerbtc": {
"ticker": {
"last": 0.00000002
}
},
"btcusdt": {
"ticker": {
"last": 51234.56
}
},
"hbotbtc": {
"ticker": {
"last": 0.9
}
},
}
mock_api.get(url, body=json.dumps(resp))
results = self.async_run_with_timeout(
AltmarketsAPIOrderBookDataSource.get_last_traded_prices(
trading_pairs=[
self.trading_pair, 'rogerbtc', 'btcusdt', 'hbotbtc'
],
throttler=self.throttler))
self.assertIn(self.trading_pair, results)
self.assertEqual(Decimal("51234.56"), results[self.trading_pair])
self.assertEqual(Decimal("0.00000002"), results["rogerbtc"])
self.assertEqual(Decimal("51234.56"), results["btcusdt"])
self.assertEqual(Decimal("0.9"), results["hbotbtc"])
@aioresponses()
def test_fetch_trading_pairs(self, mock_api):
url = f"{Constants.REST_URL}/{Constants.ENDPOINT['SYMBOL']}"
resp = [{
"name": f"{self.base_asset}/{self.quote_asset}",
"state": "enabled"
}, {
"name": "ROGER/BTC",
"state": "enabled"
}]
mock_api.get(url, body=json.dumps(resp))
results = self.async_run_with_timeout(
AltmarketsAPIOrderBookDataSource.fetch_trading_pairs(
throttler=self.throttler))
self.assertIn(self.trading_pair, results)
self.assertIn("ROGER-BTC", results)
@aioresponses()
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_http_utils.retry_sleep_time"
)
def test_fetch_trading_pairs_returns_empty_on_error(
self, mock_api, retry_sleep_time_mock):
retry_sleep_time_mock.side_effect = lambda *args, **kwargs: 0
url = f"{Constants.REST_URL}/{Constants.ENDPOINT['SYMBOL']}"
for i in range(Constants.API_MAX_RETRIES):
mock_api.get(url, body=json.dumps([{"noname": "empty"}]))
results = self.async_run_with_timeout(
AltmarketsAPIOrderBookDataSource.fetch_trading_pairs(
throttler=self.throttler))
self.assertEqual(0, len(results))
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._time"
)
@aioresponses()
def test_get_new_order_book(self, time_mock, mock_api):
time_mock.return_value = 1234567899
url = f"{Constants.REST_URL}/" \
f"{Constants.ENDPOINT['ORDER_BOOK'].format(trading_pair=self.exchange_trading_pair)}" \
"?limit=300"
resp = {"timestamp": 1234567899, "bids": [], "asks": []}
mock_api.get(url, body=json.dumps(resp))
order_book: AltmarketsOrderBook = self.async_run_with_timeout(
self.data_source.get_new_order_book(self.trading_pair))
self.assertEqual(1234567899 * 1e3, order_book.snapshot_uid)
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_http_utils.retry_sleep_time"
)
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._time"
)
@aioresponses()
def test_get_new_order_book_raises_error(self, retry_sleep_time_mock,
time_mock, mock_api):
retry_sleep_time_mock.side_effect = lambda *args, **kwargs: 0
time_mock.return_value = 1234567899
url = f"{Constants.REST_URL}/" \
f"{Constants.ENDPOINT['ORDER_BOOK'].format(trading_pair=self.exchange_trading_pair)}" \
"?limit=300"
for i in range(Constants.API_MAX_RETRIES):
mock_api.get(url,
body=json.dumps({
"errors": {
"message": "Dummy error."
},
"status": 500
}))
with self.assertRaises(IOError):
self.async_run_with_timeout(
self.data_source.get_new_order_book(self.trading_pair))
@aioresponses()
def test_listen_for_snapshots_cancelled_when_fetching_snapshot(
self, mock_get):
trades_queue = asyncio.Queue()
endpoint = Constants.ENDPOINT['ORDER_BOOK'].format(
trading_pair=r'[\w]+')
re_url = f"{Constants.REST_URL}/{endpoint}"
regex_url = re.compile(re_url)
resp = {"timestamp": 1234567899, "bids": [], "asks": []}
mock_get.get(regex_url, body=json.dumps(resp))
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_order_book_snapshots(
ev_loop=asyncio.get_event_loop(), output=trades_queue))
with self.assertRaises(asyncio.CancelledError):
self.listening_task.cancel()
asyncio.get_event_loop().run_until_complete(self.listening_task)
@aioresponses()
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._sleep",
new_callable=AsyncMock)
def test_listen_for_snapshots_logs_exception_when_fetching_snapshot(
self, mock_get, mock_sleep):
# the queue and the division by zero error are used just to synchronize the test
sync_queue = deque()
sync_queue.append(1)
endpoint = Constants.ENDPOINT['ORDER_BOOK'].format(
trading_pair=r'[\w]+')
re_url = f"{Constants.REST_URL}/{endpoint}"
regex_url = re.compile(re_url)
for x in range(2):
mock_get.get(regex_url, body=json.dumps({}))
mock_sleep.side_effect = lambda delay: 1 / 0 if len(
sync_queue) == 0 else sync_queue.pop()
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(ZeroDivisionError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
self.assertEqual(0, msg_queue.qsize())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred listening for orderbook snapshots. Retrying in 5 secs..."
))
@aioresponses()
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._sleep",
new_callable=AsyncMock)
def test_listen_for_snapshots_successful(self, mock_get, mock_sleep):
# the queue and the division by zero error are used just to synchronize the test
sync_queue = deque()
sync_queue.append(1)
mock_response = {
"timestamp":
1234567890,
"asks": [[7221.08, 6.92321326], [7220.08, 6.92321326],
[7222.08, 6.92321326], [7219.2, 0.69259752]],
"bids": [[7199.27, 6.95094164], [7192.27, 6.95094164],
[7193.27, 6.95094164], [7196.15, 0.69481598]]
}
endpoint = Constants.ENDPOINT['ORDER_BOOK'].format(
trading_pair=r'[\w]+')
regex_url = re.compile(f"{Constants.REST_URL}/{endpoint}")
for x in range(2):
mock_get.get(regex_url, body=json.dumps(mock_response))
mock_sleep.side_effect = lambda delay: 1 / 0 if len(
sync_queue) == 0 else sync_queue.pop()
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(ZeroDivisionError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
self.assertEqual(msg_queue.qsize(), 2)
snapshot_msg: OrderBookMessage = msg_queue.get_nowait()
self.assertEqual(snapshot_msg.update_id,
mock_response["timestamp"] * 1e3)
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_trades(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
received_messages = asyncio.Queue()
message = {
"hbotusdt.trades": {
"trades": [{
"date": 1234567899,
"tid": '3333',
"taker_type": "buy",
"price": 8772.05,
"amount": 0.1,
}]
}
}
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=received_messages))
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(message))
trade_message = self.async_run_with_timeout(received_messages.get())
self.assertEqual(OrderBookMessageType.TRADE, trade_message.type)
self.assertEqual(1234567899, trade_message.timestamp)
self.assertEqual('3333', trade_message.trade_id)
self.assertEqual(self.trading_pair, trade_message.trading_pair)
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_trades_unrecognised(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
received_messages = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=received_messages))
message = {"hbotusdttrades": {}}
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(message))
with self.assertRaises(asyncio.TimeoutError):
self.async_run_with_timeout(received_messages.get())
self.assertTrue(
self._is_logged(
"INFO",
"Unrecognized message received from Altmarkets websocket: {'hbotusdttrades': {}}"
))
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_trades_handles_exception(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
received_messages = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=received_messages))
message = {"hbotusdt.trades": {"tradess": []}}
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(message))
with self.assertRaises(asyncio.TimeoutError):
self.async_run_with_timeout(received_messages.get())
self.assertTrue(
self._is_logged(
"ERROR",
"Trades: Unexpected error with WebSocket connection. Retrying after 30 seconds..."
))
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._time"
)
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_order_book_diff(self, ws_connect_mock, time_mock):
time_mock.return_value = 1234567890
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
received_messages = asyncio.Queue()
message = {
"hbotusdt.ob-inc": {
"timestamp":
1234567890,
"asks": [[7220.08, 0], [7221.08, 0], [7222.08, 6.92321326],
[7219.2, 0.69259752]],
"bids": [[7190.27, 0], [7192.27, 0], [7193.27, 6.95094164],
[7196.15, 0.69481598]]
}
}
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
ev_loop=self.ev_loop, output=received_messages))
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(message))
diff_message = self.async_run_with_timeout(received_messages.get())
self.assertEqual(OrderBookMessageType.DIFF, diff_message.type)
self.assertEqual(4, len(diff_message.content.get("bids")))
self.assertEqual(4, len(diff_message.content.get("asks")))
self.assertEqual(1234567890, diff_message.timestamp)
self.assertEqual(int(1234567890 * 1e3), diff_message.update_id)
self.assertEqual(-1, diff_message.trade_id)
self.assertEqual(self.trading_pair, diff_message.trading_pair)
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._time"
)
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_order_book_snapshot(self, ws_connect_mock, time_mock):
time_mock.return_value = 1234567890
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
received_messages = asyncio.Queue()
message = {
"hbotusdt.ob-snap": {
"timestamp":
1234567890,
"asks": [[7220.08, 6.92321326], [7221.08, 6.92321326],
[7222.08, 6.92321326], [7219.2, 0.69259752]],
"bids": [[7190.27, 6.95094164], [7192.27, 6.95094164],
[7193.27, 6.95094164], [7196.15, 0.69481598]]
}
}
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
ev_loop=self.ev_loop, output=received_messages))
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(message))
diff_message = self.async_run_with_timeout(received_messages.get())
self.assertEqual(OrderBookMessageType.SNAPSHOT, diff_message.type)
self.assertEqual(4, len(diff_message.content.get("bids")))
self.assertEqual(4, len(diff_message.content.get("asks")))
self.assertEqual(1234567890, diff_message.timestamp)
self.assertEqual(int(1234567890 * 1e3), diff_message.update_id)
self.assertEqual(-1, diff_message.trade_id)
self.assertEqual(self.trading_pair, diff_message.trading_pair)
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._time"
)
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_order_book_diff_unrecognised(self, ws_connect_mock,
time_mock):
time_mock.return_value = 1234567890
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
received_messages = asyncio.Queue()
message = {"snapcracklepop": {}}
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
ev_loop=self.ev_loop, output=received_messages))
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(message))
with self.assertRaises(asyncio.TimeoutError):
self.async_run_with_timeout(received_messages.get())
self.assertTrue(
self._is_logged(
"INFO",
"Unrecognized message received from Altmarkets websocket: {'snapcracklepop': {}}"
))
@patch(
"hummingbot.connector.exchange.altmarkets.altmarkets_api_order_book_data_source.AltmarketsAPIOrderBookDataSource._time"
)
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_order_book_diff_handles_exception(
self, ws_connect_mock, time_mock):
time_mock.return_value = "NaN"
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
received_messages = asyncio.Queue()
message = {".ob-snap": {}}
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
ev_loop=self.ev_loop, output=received_messages))
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(message))
with self.assertRaises(asyncio.TimeoutError):
self.async_run_with_timeout(received_messages.get())
self.assertTrue(
self._is_logged("NETWORK",
"Unexpected error with WebSocket connection."))
class TestKucoinAPIOrderBookDataSource(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ws_endpoint = "ws://someEndpoint"
cls.api_key = "someKey"
cls.api_passphrase = "somePassPhrase"
cls.api_secret_key = "someSecretKey"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.async_task = None
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.time_synchronnizer = TimeSynchronizer()
self.time_synchronnizer.add_time_offset_ms_sample(1000)
self.ob_data_source = KucoinAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
throttler=self.throttler,
time_synchronizer=self.time_synchronnizer)
self.ob_data_source.logger().setLevel(1)
self.ob_data_source.logger().addHandler(self)
KucoinAPIOrderBookDataSource._trading_pair_symbol_map = {
CONSTANTS.DEFAULT_DOMAIN:
bidict({self.trading_pair: self.trading_pair})
}
def tearDown(self) -> None:
self.async_task and self.async_task.cancel()
KucoinAPIOrderBookDataSource._trading_pair_symbol_map = {}
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
@staticmethod
def get_snapshot_mock() -> Dict:
snapshot = {
"code": "200000",
"data": {
"time": 1630556205455,
"sequence": "1630556205456",
"bids": [["0.3003", "4146.5645"]],
"asks": [["0.3004", "1553.6412"]]
}
}
return snapshot
@aioresponses()
def test_get_last_traded_prices(self, mock_api):
KucoinAPIOrderBookDataSource._trading_pair_symbol_map[
CONSTANTS.DEFAULT_DOMAIN]["TKN1-TKN2"] = "TKN1-TKN2"
url1 = web_utils.rest_url(
path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL,
domain=CONSTANTS.DEFAULT_DOMAIN)
url1 = f"{url1}?symbol={self.trading_pair}"
regex_url = re.compile(f"^{url1}".replace(".",
r"\.").replace("?", r"\?"))
resp = {
"code": "200000",
"data": {
"sequence": "1550467636704",
"bestAsk": "0.03715004",
"size": "0.17",
"price": "100",
"bestBidSize": "3.803",
"bestBid": "0.03710768",
"bestAskSize": "1.788",
"time": 1550653727731
}
}
mock_api.get(regex_url, body=json.dumps(resp))
url2 = web_utils.rest_url(
path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL,
domain=CONSTANTS.DEFAULT_DOMAIN)
url2 = f"{url2}?symbol=TKN1-TKN2"
regex_url = re.compile(f"^{url2}".replace(".",
r"\.").replace("?", r"\?"))
resp = {
"code": "200000",
"data": {
"sequence": "1550467636704",
"bestAsk": "0.03715004",
"size": "0.17",
"price": "200",
"bestBidSize": "3.803",
"bestBid": "0.03710768",
"bestAskSize": "1.788",
"time": 1550653727731
}
}
mock_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
coroutine=KucoinAPIOrderBookDataSource.get_last_traded_prices(
[self.trading_pair, "TKN1-TKN2"]))
ticker_requests = [(key, value)
for key, value in mock_api.requests.items()
if key[1].human_repr().startswith(url1)
or key[1].human_repr().startswith(url2)]
request_params = ticker_requests[0][1][0].kwargs["params"]
self.assertEqual(f"{self.base_asset}-{self.quote_asset}",
request_params["symbol"])
request_params = ticker_requests[1][1][0].kwargs["params"]
self.assertEqual("TKN1-TKN2", request_params["symbol"])
self.assertEqual(ret[self.trading_pair], 100)
self.assertEqual(ret["TKN1-TKN2"], 200)
@aioresponses()
def test_fetch_trading_pairs(self, mock_api):
KucoinAPIOrderBookDataSource._trading_pair_symbol_map = {}
url = web_utils.rest_url(path_url=CONSTANTS.EXCHANGE_INFO_PATH_URL)
resp = {
"data": [{
"symbol": self.trading_pair,
"name": self.trading_pair,
"baseCurrency": self.base_asset,
"quoteCurrency": self.quote_asset,
"enableTrading": True,
}, {
"symbol": "SOME-PAIR",
"name": "SOME-PAIR",
"baseCurrency": "SOME",
"quoteCurrency": "PAIR",
"enableTrading": False,
}]
}
mock_api.get(url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
coroutine=KucoinAPIOrderBookDataSource.fetch_trading_pairs(
throttler=self.throttler,
time_synchronizer=self.time_synchronnizer,
))
self.assertEqual(1, len(ret))
self.assertEqual(self.trading_pair, ret[0])
@aioresponses()
def test_fetch_trading_pairs_exception_raised(self, mock_api):
KucoinAPIOrderBookDataSource._trading_pair_symbol_map = {}
url = web_utils.rest_url(path_url=CONSTANTS.EXCHANGE_INFO_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=Exception)
result: Dict[str] = self.async_run_with_timeout(
self.ob_data_source.fetch_trading_pairs())
self.assertEqual(0, len(result))
@aioresponses()
def test_get_snapshot_raises(self, mock_api):
url = web_utils.rest_url(path_url=CONSTANTS.SNAPSHOT_NO_AUTH_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=500)
with self.assertRaises(IOError):
self.async_run_with_timeout(
coroutine=self.ob_data_source.get_snapshot(self.trading_pair))
@aioresponses()
def test_get_snapshot(self, mock_api):
url = web_utils.rest_url(path_url=CONSTANTS.SNAPSHOT_NO_AUTH_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
resp = self.get_snapshot_mock()
mock_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
coroutine=self.ob_data_source.get_snapshot(self.trading_pair))
self.assertEqual(ret, resp) # shallow comparison ok
@aioresponses()
def test_get_new_order_book(self, mock_api):
url = web_utils.rest_url(path_url=CONSTANTS.SNAPSHOT_NO_AUTH_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
resp = self.get_snapshot_mock()
mock_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
coroutine=self.ob_data_source.get_new_order_book(
self.trading_pair))
bid_entries = list(ret.bid_entries())
ask_entries = list(ret.ask_entries())
self.assertEqual(1, len(bid_entries))
self.assertEqual(0.3003, bid_entries[0].price)
self.assertEqual(4146.5645, bid_entries[0].amount)
self.assertEqual(int(resp["data"]["sequence"]),
bid_entries[0].update_id)
self.assertEqual(1, len(ask_entries))
self.assertEqual(0.3004, ask_entries[0].price)
self.assertEqual(1553.6412, ask_entries[0].amount)
self.assertEqual(int(resp["data"]["sequence"]),
ask_entries[0].update_id)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.kucoin.kucoin_web_utils.next_message_id"
)
def test_listen_for_subscriptions_subscribes_to_trades_and_order_diffs(
self, mock_api, id_mock, ws_connect_mock):
id_mock.side_effect = [1, 2]
url = web_utils.rest_url(path_url=CONSTANTS.PUBLIC_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))
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_subscriptions())
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_trade_subscription = {
"id": 1,
"type": "subscribe",
"topic": f"/market/match:{self.trading_pair}",
"privateChannel": False,
"response": False
}
self.assertEqual(expected_trade_subscription,
sent_subscription_messages[0])
expected_diff_subscription = {
"id": 2,
"type": "subscribe",
"topic": f"/market/level2:{self.trading_pair}",
"privateChannel": False,
"response": False
}
self.assertEqual(expected_diff_subscription,
sent_subscription_messages[1])
self.assertTrue(
self._is_logged(
"INFO",
"Subscribed to public order book and trade channels..."))
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.kucoin.kucoin_web_utils.next_message_id"
)
@patch(
"hummingbot.connector.exchange.kucoin.kucoin_api_order_book_data_source.KucoinAPIOrderBookDataSource._time"
)
def test_listen_for_subscriptions_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.rest_url(path_url=CONSTANTS.PUBLIC_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))
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_subscriptions())
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])
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
def test_listen_for_subscriptions_raises_cancel_exception(
self, mock_api, _, ws_connect_mock):
url = web_utils.rest_url(path_url=CONSTANTS.PUBLIC_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.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_subscriptions())
self.async_run_with_timeout(self.listening_task)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
def test_listen_for_subscriptions_logs_exception_details(
self, mock_api, sleep_mock, ws_connect_mock):
url = web_utils.rest_url(path_url=CONSTANTS.PUBLIC_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))
sleep_mock.side_effect = asyncio.CancelledError
ws_connect_mock.side_effect = Exception("TEST ERROR.")
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_subscriptions())
self.async_run_with_timeout(self.listening_task)
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred when listening to order book streams. Retrying in 5 seconds..."
))
def test_listen_for_trades_cancelled_when_listening(self):
mock_queue = MagicMock()
mock_queue.get.side_effect = asyncio.CancelledError()
self.ob_data_source._message_queue[
CONSTANTS.TRADE_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_trades(self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
def test_listen_for_trades_logs_exception(self):
incomplete_resp = {
"type": "message",
"topic": f"/market/match:{self.trading_pair}",
}
mock_queue = AsyncMock()
mock_queue.get.side_effect = [
incomplete_resp, asyncio.CancelledError()
]
self.ob_data_source._message_queue[
CONSTANTS.TRADE_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_trades(self.ev_loop, msg_queue))
try:
self.async_run_with_timeout(self.listening_task)
except asyncio.CancelledError:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error when processing public trade updates from exchange"
))
def test_listen_for_trades_successful(self):
mock_queue = AsyncMock()
trade_event = {
"type": "message",
"topic": f"/market/match:{self.trading_pair}",
"subject": "trade.l3match",
"data": {
"sequence": "1545896669145",
"type": "match",
"symbol": self.trading_pair,
"side": "buy",
"price": "0.08200000000000000000",
"size": "0.01022222000000000000",
"tradeId": "5c24c5da03aa673885cd67aa",
"takerOrderId": "5c24c5d903aa6772d55b371e",
"makerOrderId": "5c2187d003aa677bd09d5c93",
"time": "1545913818099033203"
}
}
mock_queue.get.side_effect = [trade_event, asyncio.CancelledError()]
self.ob_data_source._message_queue[
CONSTANTS.TRADE_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
try:
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_trades(self.ev_loop, msg_queue))
except asyncio.CancelledError:
pass
msg: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(trade_event["data"]["tradeId"], msg.trade_id)
def test_listen_for_order_book_diffs_cancelled(self):
mock_queue = AsyncMock()
mock_queue.get.side_effect = asyncio.CancelledError()
self.ob_data_source._message_queue[
CONSTANTS.DIFF_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
def test_listen_for_order_book_diffs_logs_exception(self):
incomplete_resp = {
"type": "message",
"topic": f"/market/level2:{self.trading_pair}",
}
mock_queue = AsyncMock()
mock_queue.get.side_effect = [
incomplete_resp, asyncio.CancelledError()
]
self.ob_data_source._message_queue[
CONSTANTS.DIFF_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
try:
self.async_run_with_timeout(self.listening_task)
except asyncio.CancelledError:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error when processing public order book updates from exchange"
))
def test_listen_for_order_book_diffs_successful(self):
mock_queue = AsyncMock()
diff_event = {
"type": "message",
"topic": "/market/level2:BTC-USDT",
"subject": "trade.l2update",
"data": {
"sequenceStart": 1545896669105,
"sequenceEnd": 1545896669106,
"symbol": f"{self.trading_pair}",
"changes": {
"asks": [["6", "1", "1545896669105"]],
"bids": [["4", "1", "1545896669106"]]
}
}
}
mock_queue.get.side_effect = [diff_event, asyncio.CancelledError()]
self.ob_data_source._message_queue[
CONSTANTS.DIFF_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
try:
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
except asyncio.CancelledError:
pass
msg: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(diff_event["data"]["sequenceEnd"], msg.update_id)
@aioresponses()
def test_listen_for_order_book_snapshots_cancelled_when_fetching_snapshot(
self, mock_api):
url = web_utils.rest_url(path_url=CONSTANTS.SNAPSHOT_NO_AUTH_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=asyncio.CancelledError)
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.ob_data_source.listen_for_order_book_snapshots(
self.ev_loop, asyncio.Queue()))
@aioresponses()
@patch(
"hummingbot.connector.exchange.kucoin.kucoin_api_order_book_data_source"
".KucoinAPIOrderBookDataSource._sleep")
def test_listen_for_order_book_snapshots_log_exception(
self, mock_api, sleep_mock):
msg_queue: asyncio.Queue = asyncio.Queue()
sleep_mock.side_effect = asyncio.CancelledError
url = web_utils.rest_url(path_url=CONSTANTS.SNAPSHOT_NO_AUTH_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=Exception)
try:
self.async_run_with_timeout(
self.ob_data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
except asyncio.CancelledError:
pass
self.assertTrue(
self._is_logged(
"ERROR",
f"Unexpected error fetching order book snapshot for {self.trading_pair}."
))
@aioresponses()
def test_listen_for_order_book_snapshots_successful(
self,
mock_api,
):
msg_queue: asyncio.Queue = asyncio.Queue()
url = web_utils.rest_url(path_url=CONSTANTS.SNAPSHOT_NO_AUTH_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
snapshot_data = {
"code": "200000",
"data": {
"sequence": "3262786978",
"time": 1550653727731,
"bids": [["6500.12", "0.45054140"], ["6500.11", "0.45054140"]],
"asks": [["6500.16", "0.57753524"], ["6500.15", "0.57753524"]]
}
}
mock_api.get(regex_url, body=json.dumps(snapshot_data))
self.listening_task = self.ev_loop.create_task(
self.ob_data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
msg: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertEqual(int(snapshot_data["data"]["sequence"]), msg.update_id)
class CryptoComAPIOrderBookDataSourceUnitTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ex_trading_pair = crypto_com_utils.convert_to_exchange_trading_pair(
cls.trading_pair)
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.async_task: Optional[asyncio.Task] = None
self.data_source = CryptoComAPIOrderBookDataSource(
trading_pairs=[self.trading_pair])
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.resume_test_event = asyncio.Event()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def test_get_throttler_instance(self):
self.assertIsInstance(self.data_source._get_throttler_instance(),
AsyncThrottler)
@aioresponses()
def test_get_last_trade_prices(self, mock_api):
url = crypto_com_utils.get_rest_url(
path_url=CONSTANTS.GET_TICKER_PATH_URL)
regex_url = re.compile(f"^{url}")
expected_last_traded_price = 1.0
mock_responses = {
"code": 0,
"method": "public/get-ticker",
"result": {
"data": [
{ # Truncated Response
"i": self.ex_trading_pair,
"a": expected_last_traded_price,
}
]
},
}
mock_api.get(regex_url, body=ujson.dumps(mock_responses))
result = self.async_run_with_timeout(
self.data_source.get_last_traded_prices(
trading_pairs=[self.trading_pair]))
self.assertEqual(result[self.trading_pair], expected_last_traded_price)
@aioresponses()
def test_fetch_trading_pairs(self, mock_api):
url = crypto_com_utils.get_rest_url(
path_url=CONSTANTS.GET_TICKER_PATH_URL)
regex_url = re.compile(f"^{url}")
mock_response = {
"code": 0,
"method": "public/get-ticker",
"result": {
"data": [
{ # Truncated Response
"i": self.ex_trading_pair,
"a": 1.0,
}
]
},
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source.fetch_trading_pairs())
self.assertTrue(self.trading_pair in result)
@aioresponses()
def test_get_order_book_data(self, mock_api):
url = crypto_com_utils.get_rest_url(
path_url=CONSTANTS.GET_ORDER_BOOK_PATH_URL)
regex_url = re.compile(f"^{url}")
mock_response = {
"code": 0,
"method": "public/get-book",
"result": {
"instrument_name":
self.ex_trading_pair,
"depth":
150,
"data": [{
"bids": [
[999.00, 1.0, 1],
],
"asks": [
[1000.00, 1.0, 1],
],
"t": 1634731570152,
}],
},
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source.get_order_book_data(self.trading_pair))
self.assertIsInstance(result, dict)
@aioresponses()
def test_get_new_order_book(self, mock_api):
url = crypto_com_utils.get_rest_url(
path_url=CONSTANTS.GET_ORDER_BOOK_PATH_URL)
regex_url = re.compile(f"^{url}")
snapshot_timestamp = 1634731570152
mock_response = {
"code": 0,
"method": "public/get-book",
"result": {
"instrument_name":
self.ex_trading_pair,
"depth":
150,
"data": [{
"bids": [
[999.00, 1.0, 1],
],
"asks": [
[1000.00, 1.0, 1],
],
"t": snapshot_timestamp,
}],
},
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source.get_new_order_book(self.trading_pair))
self.assertIsInstance(result, OrderBook)
self.assertEqual(snapshot_timestamp, result.snapshot_uid)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_create_websocket_connection_raised_cancelled(
self, ws_connect_mock):
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source._create_websocket_connection())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_create_websocket_connection_logs_exception(self, ws_connect_mock):
ws_connect_mock.side_effect = Exception("TEST ERROR")
with self.assertRaisesRegex(Exception, "TEST ERROR"):
self.async_run_with_timeout(
self.data_source._create_websocket_connection())
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occured connecting to crypto_com WebSocket API. (TEST ERROR)"
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_exception_raised_cancelled_when_connecting(
self, ws_connect_mock):
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_subscriptions())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_subscriptions_exception_raised_cancelled_when_subscribing(
self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_subscriptions())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_subscriptions_exception_raised_cancelled_when_listening(
self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.receive.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_subscriptions())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_subscription_logs_exception(self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.receive.side_effect = lambda: self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR"))
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred when listening to order book streams. Retrying in 5 seconds..."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_subscriptions_enqueues_diff_and_trade_messages(
self, _, ws_connect_mock):
diffs_queue = self.data_source._message_queue[
CryptoComWebsocket.DIFF_CHANNEL_ID]
trade_queue = self.data_source._message_queue[
CryptoComWebsocket.TRADE_CHANNEL_ID]
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add diff event message be processed
diff_response = {
"method": "subscribe",
"result": {
"instrument_name":
self.ex_trading_pair,
"subscription":
f"book.{self.ex_trading_pair}.150",
"channel":
"book",
"depth":
150,
"data": [{
"bids": [[11746.488, 128, 8]],
"asks": [[11747.488, 201, 12]],
"t": 1587523078844
}],
},
}
# Add trade event message be processed
trade_response = {
"method": "subscribe",
"result": {
"instrument_name":
self.ex_trading_pair,
"subscription":
f"trade.{self.ex_trading_pair}",
"channel":
"trade",
"data": [{
"p": 162.12,
"q": 11.085,
"s": "buy",
"d": 1210447366,
"t": 1587523078844,
"dataTime": 0,
"i": f"{self.ex_trading_pair}",
}],
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, ujson.dumps(diff_response))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, ujson.dumps(trade_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertEqual(1, diffs_queue.qsize())
self.assertEqual(1, trade_queue.qsize())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_order_book_diff_raises_cancel_exceptions(
self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(ev_loop=self.ev_loop,
output=queue))
with self.assertRaises(asyncio.CancelledError):
self.listening_task.cancel()
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_api_order_book_data_source.CryptoComAPIOrderBookDataSource._sleep"
)
def test_listen_for_order_book_diff_logs_exception_parsing_message(
self, _, __, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add incomplete diff event message be processed
incomplete_diff_response = {
"method": "subscribe",
"result": {
"channel": "book",
"INCOMPLETE": "PAYLOAD"
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
ujson.dumps(incomplete_diff_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(ev_loop=self.ev_loop,
output=output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertTrue(
self._is_logged(
"ERROR",
f"Unexpected error parsing order book diff payload. Payload: {incomplete_diff_response['result']}",
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_order_book_diff_successful(self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add diff event message be processed
diff_response = {
"method": "subscribe",
"result": {
"instrument_name":
self.ex_trading_pair,
"subscription":
f"book.{self.ex_trading_pair}.150",
"channel":
"book",
"depth":
150,
"data": [{
"bids": [[11746.488, 128, 8]],
"asks": [[11747.488, 201, 12]],
"t": 1587523078844
}],
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, ujson.dumps(diff_response))
diffs_queue = self.data_source._message_queue[
CryptoComWebsocket.DIFF_CHANNEL_ID]
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(ev_loop=self.ev_loop,
output=output_queue))
order_book_message = self.async_run_with_timeout(output_queue.get())
self.assertTrue(diffs_queue.empty())
self.assertEqual(1587523078844, order_book_message.update_id)
self.assertEqual(1587523078844, order_book_message.timestamp)
self.assertEqual(11746.488, order_book_message.bids[0].price)
self.assertEqual(11747.488, order_book_message.asks[0].price)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_trades_raises_cancel_exceptions(
self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=queue))
with self.assertRaises(asyncio.CancelledError):
self.listening_task.cancel()
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_api_order_book_data_source.CryptoComAPIOrderBookDataSource._sleep"
)
def test_listen_for_trades_logs_exception_parsing_message(
self, _, __, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add incomplete trade event message be processed
incomplete_trade_response = {
"method": "subscribe",
"result": {
"channel": "trade",
"INCOMPLETE": "PAYLOAD"
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
ujson.dumps(incomplete_trade_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertTrue(
self._is_logged(
"ERROR",
f"Unexpected error parsing order book trade payload. Payload: {incomplete_trade_response['result']}",
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.exchange.crypto_com.crypto_com_websocket.CryptoComWebsocket._sleep"
)
def test_listen_for_trades_successful(self, _, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Add trade event message be processed
trade_response = {
"method": "subscribe",
"result": {
"instrument_name":
self.ex_trading_pair,
"subscription":
f"trade.{self.ex_trading_pair}",
"channel":
"trade",
"data": [{
"p": 162.12,
"q": 11.085,
"s": "buy",
"d": 1210447366,
"t": 1587523078844,
"dataTime": 0,
"i": f"{self.ex_trading_pair}",
}],
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, ujson.dumps(trade_response))
trades_queue = self.data_source._message_queue[
CryptoComWebsocket.TRADE_CHANNEL_ID]
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
output_queue = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(ev_loop=self.ev_loop,
output=output_queue))
first_trade_message = self.async_run_with_timeout(output_queue.get())
self.assertTrue(trades_queue.empty())
self.assertEqual(1587523078844, first_trade_message.timestamp)
@aioresponses()
def test_listen_for_order_book_snapshots_successful(self, mock_api):
url = crypto_com_utils.get_rest_url(
path_url=CONSTANTS.GET_ORDER_BOOK_PATH_URL)
regex_url = re.compile(f"^{url}")
mock_response = {
"code": 0,
"method": "public/get-book",
"result": {
"instrument_name":
self.ex_trading_pair,
"depth":
150,
"data": [{
"bids": [
[999.00, 1.0, 1],
],
"asks": [
[1000.00, 1.0, 1],
],
"t": 1634731570152,
}],
},
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
order_book_messages = asyncio.Queue()
self.async_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
ev_loop=self.ev_loop, output=order_book_messages))
order_book_message = self.async_run_with_timeout(
order_book_messages.get())
self.assertTrue(order_book_messages.empty())
self.assertEqual(1634731570152, order_book_message.update_id)
self.assertEqual(1634731570152, order_book_message.timestamp)
self.assertEqual(999.00, order_book_message.bids[0].price)
self.assertEqual(1000.00, order_book_message.asks[0].price)
class BinanceAPIOrderBookDataSourceUnitTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ex_trading_pair = cls.base_asset + cls.quote_asset
cls.domain = "com"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.mocking_assistant = NetworkMockingAssistant()
self.time_synchronizer = TimeSynchronizer()
self.time_synchronizer.add_time_offset_ms_sample(1000)
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = BinanceAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
throttler=self.throttler,
domain=self.domain,
time_synchronizer=self.time_synchronizer)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.resume_test_event = asyncio.Event()
BinanceAPIOrderBookDataSource._trading_pair_symbol_map = {
"com":
bidict({f"{self.base_asset}{self.quote_asset}": self.trading_pair})
}
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
BinanceAPIOrderBookDataSource._trading_pair_symbol_map = {}
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def _successfully_subscribed_event(self):
resp = {"result": None, "id": 1}
return resp
def _trade_update_event(self):
resp = {
"e": "trade",
"E": 123456789,
"s": self.ex_trading_pair,
"t": 12345,
"p": "0.001",
"q": "100",
"b": 88,
"a": 50,
"T": 123456785,
"m": True,
"M": True
}
return resp
def _order_diff_event(self):
resp = {
"e": "depthUpdate",
"E": 123456789,
"s": self.ex_trading_pair,
"U": 157,
"u": 160,
"b": [["0.0024", "10"]],
"a": [["0.0026", "100"]]
}
return resp
def _snapshot_response(self):
resp = {
"lastUpdateId": 1027024,
"bids": [["4.00000000", "431.00000000"]],
"asks": [["4.00000200", "12.00000000"]]
}
return resp
@aioresponses()
def test_get_last_trade_prices(self, mock_api):
url = web_utils.public_rest_url(
path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL,
domain=self.domain)
url = f"{url}?symbol={self.base_asset}{self.quote_asset}"
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"symbol": "BNBBTC",
"priceChange": "-94.99999800",
"priceChangePercent": "-95.960",
"weightedAvgPrice": "0.29628482",
"prevClosePrice": "0.10002000",
"lastPrice": "100.0",
"lastQty": "200.00000000",
"bidPrice": "4.00000000",
"bidQty": "100.00000000",
"askPrice": "4.00000200",
"askQty": "100.00000000",
"openPrice": "99.00000000",
"highPrice": "100.00000000",
"lowPrice": "0.10000000",
"volume": "8913.30000000",
"quoteVolume": "15.30000000",
"openTime": 1499783499040,
"closeTime": 1499869899040,
"firstId": 28385,
"lastId": 28460,
"count": 76,
}
mock_api.get(regex_url, body=json.dumps(mock_response))
result: Dict[str, float] = self.async_run_with_timeout(
self.data_source.get_last_traded_prices(
trading_pairs=[self.trading_pair],
throttler=self.throttler,
time_synchronizer=self.time_synchronizer))
self.assertEqual(1, len(result))
self.assertEqual(100, result[self.trading_pair])
@aioresponses()
def test_get_all_mid_prices(self, mock_api):
url = web_utils.public_rest_url(CONSTANTS.SERVER_TIME_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
response = {"serverTime": 1640000003000}
mock_api.get(regex_url, body=json.dumps(response))
url = web_utils.public_rest_url(
path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL,
domain=self.domain)
mock_response: List[Dict[str, Any]] = [
{
# Truncated Response
"symbol": self.ex_trading_pair,
"bidPrice": "99",
"askPrice": "101",
},
{
# Truncated Response for unrecognized pair
"symbol": "BCCBTC",
"bidPrice": "99",
"askPrice": "101",
}
]
mock_api.get(url, body=json.dumps(mock_response))
result: Dict[str, float] = self.async_run_with_timeout(
self.data_source.get_all_mid_prices())
self.assertEqual(1, len(result))
self.assertEqual(100, result[self.trading_pair])
@aioresponses()
def test_fetch_trading_pairs(self, mock_api):
BinanceAPIOrderBookDataSource._trading_pair_symbol_map = {}
url = web_utils.public_rest_url(
path_url=CONSTANTS.EXCHANGE_INFO_PATH_URL, domain=self.domain)
mock_response: Dict[str, Any] = {
"timezone":
"UTC",
"serverTime":
1639598493658,
"rateLimits": [],
"exchangeFilters": [],
"symbols": [
{
"symbol":
"ETHBTC",
"status":
"TRADING",
"baseAsset":
"ETH",
"baseAssetPrecision":
8,
"quoteAsset":
"BTC",
"quotePrecision":
8,
"quoteAssetPrecision":
8,
"baseCommissionPrecision":
8,
"quoteCommissionPrecision":
8,
"orderTypes": [
"LIMIT", "LIMIT_MAKER", "MARKET", "STOP_LOSS_LIMIT",
"TAKE_PROFIT_LIMIT"
],
"icebergAllowed":
True,
"ocoAllowed":
True,
"quoteOrderQtyMarketAllowed":
True,
"isSpotTradingAllowed":
True,
"isMarginTradingAllowed":
True,
"filters": [],
"permissions": ["SPOT", "MARGIN"]
},
{
"symbol":
"LTCBTC",
"status":
"TRADING",
"baseAsset":
"LTC",
"baseAssetPrecision":
8,
"quoteAsset":
"BTC",
"quotePrecision":
8,
"quoteAssetPrecision":
8,
"baseCommissionPrecision":
8,
"quoteCommissionPrecision":
8,
"orderTypes": [
"LIMIT", "LIMIT_MAKER", "MARKET", "STOP_LOSS_LIMIT",
"TAKE_PROFIT_LIMIT"
],
"icebergAllowed":
True,
"ocoAllowed":
True,
"quoteOrderQtyMarketAllowed":
True,
"isSpotTradingAllowed":
True,
"isMarginTradingAllowed":
True,
"filters": [],
"permissions": ["SPOT", "MARGIN"]
},
{
"symbol":
"BNBBTC",
"status":
"TRADING",
"baseAsset":
"BNB",
"baseAssetPrecision":
8,
"quoteAsset":
"BTC",
"quotePrecision":
8,
"quoteAssetPrecision":
8,
"baseCommissionPrecision":
8,
"quoteCommissionPrecision":
8,
"orderTypes": [
"LIMIT", "LIMIT_MAKER", "MARKET", "STOP_LOSS_LIMIT",
"TAKE_PROFIT_LIMIT"
],
"icebergAllowed":
True,
"ocoAllowed":
True,
"quoteOrderQtyMarketAllowed":
True,
"isSpotTradingAllowed":
True,
"isMarginTradingAllowed":
True,
"filters": [],
"permissions": ["MARGIN"]
},
]
}
mock_api.get(url, body=json.dumps(mock_response))
result: Dict[str] = self.async_run_with_timeout(
self.data_source.fetch_trading_pairs(
time_synchronizer=self.time_synchronizer))
self.assertEqual(2, len(result))
self.assertIn("ETH-BTC", result)
self.assertIn("LTC-BTC", result)
self.assertNotIn("BNB-BTC", result)
@aioresponses()
def test_fetch_trading_pairs_exception_raised(self, mock_api):
BinanceAPIOrderBookDataSource._trading_pair_symbol_map = {}
url = web_utils.public_rest_url(
path_url=CONSTANTS.EXCHANGE_INFO_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=Exception)
result: Dict[str] = self.async_run_with_timeout(
self.data_source.fetch_trading_pairs(
time_synchronizer=self.time_synchronizer))
self.assertEqual(0, len(result))
@aioresponses()
def test_get_snapshot_successful(self, mock_api):
url = web_utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, body=json.dumps(self._snapshot_response()))
result: Dict[str, Any] = self.async_run_with_timeout(
self.data_source.get_snapshot(self.trading_pair))
self.assertEqual(self._snapshot_response(), result)
@aioresponses()
def test_get_snapshot_catch_exception(self, mock_api):
url = web_utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=400)
with self.assertRaises(IOError):
self.async_run_with_timeout(
self.data_source.get_snapshot(self.trading_pair))
@aioresponses()
def test_get_new_order_book(self, mock_api):
url = web_utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
"lastUpdateId": 1,
"bids": [["4.00000000", "431.00000000"]],
"asks": [["4.00000200", "12.00000000"]]
}
mock_api.get(regex_url, body=json.dumps(mock_response))
result: OrderBook = self.async_run_with_timeout(
self.data_source.get_new_order_book(self.trading_pair))
self.assertEqual(1, result.snapshot_uid)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_subscribes_to_trades_and_order_diffs(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
result_subscribe_trades = {"result": None, "id": 1}
result_subscribe_diffs = {"result": None, "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))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
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_trade_subscription = {
"method": "SUBSCRIBE",
"params": [f"{self.ex_trading_pair.lower()}@trade"],
"id": 1
}
self.assertEqual(expected_trade_subscription,
sent_subscription_messages[0])
expected_diff_subscription = {
"method": "SUBSCRIBE",
"params": [f"{self.ex_trading_pair.lower()}@depth@100ms"],
"id": 2
}
self.assertEqual(expected_diff_subscription,
sent_subscription_messages[1])
self.assertTrue(
self._is_logged(
"INFO",
"Subscribed to public order book and trade channels..."))
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect")
def test_listen_for_subscriptions_raises_cancel_exception(
self, mock_ws, _: AsyncMock):
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.async_run_with_timeout(self.listening_task)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_logs_exception_details(
self, mock_ws, sleep_mock):
mock_ws.side_effect = Exception("TEST ERROR.")
sleep_mock.side_effect = lambda _: self._create_exception_and_unlock_test_with_event(
asyncio.CancelledError())
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred when listening to order book streams. Retrying in 5 seconds..."
))
def test_subscribe_channels_raises_cancel_exception(self):
mock_ws = MagicMock()
mock_ws.send.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source._subscribe_channels(mock_ws))
self.async_run_with_timeout(self.listening_task)
def test_subscribe_channels_raises_exception_and_logs_error(self):
mock_ws = MagicMock()
mock_ws.send.side_effect = Exception("Test Error")
with self.assertRaises(Exception):
self.listening_task = self.ev_loop.create_task(
self.data_source._subscribe_channels(mock_ws))
self.async_run_with_timeout(self.listening_task)
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred subscribing to order book trading and delta streams..."
))
def test_listen_for_trades_cancelled_when_listening(self):
mock_queue = MagicMock()
mock_queue.get.side_effect = asyncio.CancelledError()
self.data_source._message_queue[
CONSTANTS.TRADE_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
def test_listen_for_trades_logs_exception(self):
incomplete_resp = {
"m": 1,
"i": 2,
}
mock_queue = AsyncMock()
mock_queue.get.side_effect = [
incomplete_resp, asyncio.CancelledError()
]
self.data_source._message_queue[
CONSTANTS.TRADE_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
try:
self.async_run_with_timeout(self.listening_task)
except asyncio.CancelledError:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error when processing public trade updates from exchange"
))
def test_listen_for_trades_successful(self):
mock_queue = AsyncMock()
mock_queue.get.side_effect = [
self._trade_update_event(),
asyncio.CancelledError()
]
self.data_source._message_queue[
CONSTANTS.TRADE_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
try:
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
except asyncio.CancelledError:
pass
msg: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(12345, msg.trade_id)
def test_listen_for_order_book_diffs_cancelled(self):
mock_queue = AsyncMock()
mock_queue.get.side_effect = asyncio.CancelledError()
self.data_source._message_queue[CONSTANTS.DIFF_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
def test_listen_for_order_book_diffs_logs_exception(self):
incomplete_resp = {
"m": 1,
"i": 2,
}
mock_queue = AsyncMock()
mock_queue.get.side_effect = [
incomplete_resp, asyncio.CancelledError()
]
self.data_source._message_queue[CONSTANTS.DIFF_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
try:
self.async_run_with_timeout(self.listening_task)
except asyncio.CancelledError:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error when processing public order book updates from exchange"
))
def test_listen_for_order_book_diffs_successful(self):
mock_queue = AsyncMock()
mock_queue.get.side_effect = [
self._order_diff_event(),
asyncio.CancelledError()
]
self.data_source._message_queue[CONSTANTS.DIFF_EVENT_TYPE] = mock_queue
msg_queue: asyncio.Queue = asyncio.Queue()
try:
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
except asyncio.CancelledError:
pass
msg: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(12345, msg.update_id)
@aioresponses()
def test_listen_for_order_book_snapshots_cancelled_when_fetching_snapshot(
self, mock_api):
url = web_utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=asyncio.CancelledError)
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, asyncio.Queue()))
@aioresponses()
@patch(
"hummingbot.connector.exchange.binance.binance_api_order_book_data_source"
".BinanceAPIOrderBookDataSource._sleep")
def test_listen_for_order_book_snapshots_log_exception(
self, mock_api, sleep_mock):
msg_queue: asyncio.Queue = asyncio.Queue()
sleep_mock.side_effect = lambda _: self._create_exception_and_unlock_test_with_event(
asyncio.CancelledError())
url = web_utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=Exception)
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
f"Unexpected error fetching order book snapshot for {self.trading_pair}."
))
@aioresponses()
def test_listen_for_order_book_snapshots_successful(
self,
mock_api,
):
msg_queue: asyncio.Queue = asyncio.Queue()
url = web_utils.public_rest_url(path_url=CONSTANTS.SNAPSHOT_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, body=json.dumps(self._snapshot_response()))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
msg: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertEqual(1027024, msg.update_id)
class KrakenAPIUserStreamDataSourceTest(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.api_tier = KrakenAPITier.STARTER
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(
build_rate_limits_by_tier(self.api_tier))
not_a_real_secret = "kQH5HW/8p1uGOVjbgWA7FunAmGO8lsSUXNsu3eow76sz84Q18fWxnyRzBHCd3pd5nE9qa99HAZtuZuj6F1huXg=="
kraken_auth = KrakenAuth(api_key="someKey",
secret_key=not_a_real_secret)
self.data_source = KrakenAPIUserStreamDataSource(
self.throttler, kraken_auth)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
@staticmethod
def get_auth_response_mock() -> Dict:
auth_resp = {
"error": [],
"result": {
"token": "1Dwc4lzSwNWOAwkMdqhssNNFhs1ed606d1WcF3XfEMw",
"expires": 900
}
}
return auth_resp
@staticmethod
def get_open_orders_mock() -> List:
open_orders = [[{
"OGTT3Y-C6I3P-XRI6HX": {
"status": "closed"
}
}, {
"OGTT3Y-C6I3P-XRI6HX": {
"status": "closed"
}
}], "openOrders", {
"sequence": 59342
}]
return open_orders
@staticmethod
def get_own_trades_mock() -> List:
own_trades = [[
{
"TDLH43-DVQXD-2KHVYY": {
"cost": "1000000.00000",
"fee": "1600.00000",
"margin": "0.00000",
"ordertxid": "TDLH43-DVQXD-2KHVYY",
"ordertype": "limit",
"pair": "XBT/EUR",
"postxid": "OGTT3Y-C6I3P-XRI6HX",
"price": "100000.00000",
"time": "1560516023.070651",
"type": "sell",
"vol": "1000000000.00000000"
}
},
], "ownTrades", {
"sequence": 2948
}]
return own_trades
@aioresponses()
def test_get_auth_token(self, mocked_api):
url = f"{CONSTANTS.BASE_URL}{CONSTANTS.GET_TOKEN_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
resp = self.get_auth_response_mock()
mocked_api.post(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(self.data_source.get_auth_token())
self.assertEqual(ret, resp["result"]["token"])
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream(self, mocked_api, ws_connect_mock):
url = f"{CONSTANTS.BASE_URL}{CONSTANTS.GET_TOKEN_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
resp = self.get_auth_response_mock()
mocked_api.post(regex_url, body=json.dumps(resp))
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
output_queue = asyncio.Queue()
self.ev_loop.create_task(
self.data_source.listen_for_user_stream(output_queue))
resp = self.get_open_orders_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(resp))
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
resp = self.get_own_trades_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(resp))
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
class BybitPerpetualUserStreamDataSourceTests(TestCase):
# the level is required to receive logs from the data source loger
level = 0
def setUp(self) -> None:
super().setUp()
self.api_key = 'testAPIKey'
self.secret = 'testSecret'
self.log_records = []
self.listening_task = None
self.data_source = BybitPerpetualUserStreamDataSource(
auth_assistant=BybitPerpetualAuth(api_key=self.api_key,
secret_key=self.secret))
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
if self.data_source._session is not None:
asyncio.get_event_loop().run_until_complete(
self.data_source._session.close())
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _authentication_response(self, authenticated: bool) -> str:
request = {
"op": "auth",
"args": ['testAPIKey', 'testExpires', 'testSignature']
}
message = {
"success": authenticated,
"ret_msg": "",
"conn_id": "testConnectionID",
"request": request
}
return message
def _subscription_response(self, subscribed: bool,
subscription: str) -> str:
request = {"op": "subscribe", "args": [subscription]}
message = {
"success": subscribed,
"ret_msg": "",
"conn_id": "testConnectionID",
"request": request
}
return message
def _raise_exception(self, exception_class):
raise exception_class
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_authenticates_and_subscribes_to_events(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
initial_last_recv_time = self.data_source.last_recv_time
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source._listen_for_user_stream_on_url(
"test_url", messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, self._authentication_response(True))
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._subscription_response(
True, CONSTANTS.WS_SUBSCRIPTION_POSITIONS_ENDPOINT_NAME))
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._subscription_response(
True, CONSTANTS.WS_SUBSCRIPTION_ORDERS_ENDPOINT_NAME))
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._subscription_response(
True, CONSTANTS.WS_SUBSCRIPTION_EXECUTIONS_ENDPOINT_NAME))
# Add a dummy message for the websocket to read and include in the "messages" queue
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, json.dumps('dummyMessage'))
asyncio.get_event_loop().run_until_complete(messages.get())
self.assertTrue(
self._is_logged('INFO', "Authenticating to User Stream..."))
self.assertTrue(
self._is_logged('INFO',
"Successfully authenticated to User Stream."))
self.assertTrue(
self._is_logged(
'INFO',
"Successful subscription to the topic ['position'] on test_url"
))
self.assertTrue(
self._is_logged(
"INFO",
"Successful subscription to the topic ['order'] on test_url"))
self.assertTrue(
self._is_logged(
"INFO",
"Successful subscription to the topic ['execution'] on test_url"
))
sent_messages = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value)
self.assertEqual(4, len(sent_messages))
authentication_request = sent_messages[0]
subscription_positions_request = sent_messages[1]
subscription_orders_request = sent_messages[2]
subscription_executions_request = sent_messages[3]
self.assertEqual(
CONSTANTS.WS_AUTHENTICATE_USER_ENDPOINT_NAME,
BybitPerpetualWebSocketAdaptor.endpoint_from_message(
authentication_request))
self.assertEqual(
CONSTANTS.WS_SUBSCRIPTION_POSITIONS_ENDPOINT_NAME,
BybitPerpetualWebSocketAdaptor.endpoint_from_message(
subscription_positions_request))
self.assertEqual(
CONSTANTS.WS_SUBSCRIPTION_ORDERS_ENDPOINT_NAME,
BybitPerpetualWebSocketAdaptor.endpoint_from_message(
subscription_orders_request))
self.assertEqual(
CONSTANTS.WS_SUBSCRIPTION_EXECUTIONS_ENDPOINT_NAME,
BybitPerpetualWebSocketAdaptor.endpoint_from_message(
subscription_executions_request))
subscription_positions_payload = BybitPerpetualWebSocketAdaptor.payload_from_message(
subscription_positions_request)
expected_payload = {"op": "subscribe", "args": ["position"]}
self.assertEqual(expected_payload, subscription_positions_payload)
subscription_orders_payload = BybitPerpetualWebSocketAdaptor.payload_from_message(
subscription_orders_request)
expected_payload = {"op": "subscribe", "args": ["order"]}
self.assertEqual(expected_payload, subscription_orders_payload)
subscription_executions_payload = BybitPerpetualWebSocketAdaptor.payload_from_message(
subscription_executions_request)
expected_payload = {"op": "subscribe", "args": ["execution"]}
self.assertEqual(expected_payload, subscription_executions_payload)
self.assertGreater(self.data_source.last_recv_time,
initial_last_recv_time)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_fails_when_authentication_fails(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, self._authentication_response(False))
try:
asyncio.get_event_loop().run_until_complete(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR", "Error occurred when authenticating to user stream "
"(Could not authenticate websocket connection with Bybit Perpetual)"
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Bybit Perpetual WebSocket connection on"
" wss://stream.bybit.com/realtime_private. Retrying in 30 seconds. "
"(Could not authenticate websocket connection with Bybit Perpetual)"
))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_initialization(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
asyncio.get_event_loop().run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_authentication(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(asyncio.CancelledError)
if CONSTANTS.WS_AUTHENTICATE_USER_ENDPOINT_NAME in sent_message[
"op"] else self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, sent_message))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
asyncio.get_event_loop().run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_positions_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(asyncio.CancelledError) if CONSTANTS.
WS_SUBSCRIPTION_POSITIONS_ENDPOINT_NAME in sent_message[
"args"] else self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, sent_message))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._authentication_response(True))
asyncio.get_event_loop().run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_orders_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(asyncio.CancelledError)
if CONSTANTS.WS_SUBSCRIPTION_ORDERS_ENDPOINT_NAME in sent_message[
"args"] else self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, sent_message))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._authentication_response(True))
asyncio.get_event_loop().run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_executions_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(asyncio.CancelledError) if CONSTANTS.
WS_SUBSCRIPTION_EXECUTIONS_ENDPOINT_NAME in sent_message[
"args"] else self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, sent_message))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._authentication_response(True))
asyncio.get_event_loop().run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_details_during_initialization(
self, ws_connect_mock):
ws_connect_mock.side_effect = Exception
with self.assertRaises(Exception):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source._create_websocket_connection("test_url"))
asyncio.get_event_loop().run_until_complete(self.listening_task)
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occurred during bybit_perpetual WebSocket Connection on test_url ()"
))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_details_during_authentication(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(Exception)
if CONSTANTS.WS_AUTHENTICATE_USER_ENDPOINT_NAME in sent_message[
"op"] else self.mocking_assistant.add_websocket_json_message(
sent_message))
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
try:
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
asyncio.get_event_loop().run_until_complete(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Error occurred when authenticating to user stream ()"))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Bybit Perpetual WebSocket connection on"
" wss://stream.bybit.com/realtime_private. Retrying in 30 seconds. ()"
))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_during_positions_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(Exception) if CONSTANTS.
WS_SUBSCRIPTION_POSITIONS_ENDPOINT_NAME in sent_message[
"args"] else self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, sent_message))
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
try:
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._authentication_response(True))
asyncio.get_event_loop().run_until_complete(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Error occurred subscribing to bybit_perpetual private channels ()"
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Bybit Perpetual WebSocket connection on"
" wss://stream.bybit.com/realtime_private. Retrying in 30 seconds. ()"
))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_during_orders_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(Exception)
if CONSTANTS.WS_SUBSCRIPTION_ORDERS_ENDPOINT_NAME in sent_message[
"args"] else self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, sent_message))
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
try:
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._authentication_response(True))
asyncio.get_event_loop().run_until_complete(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Error occurred subscribing to bybit_perpetual private channels ()"
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Bybit Perpetual WebSocket connection on"
" wss://stream.bybit.com/realtime_private. Retrying in 30 seconds. ()"
))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_during_executions_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(Exception) if CONSTANTS.
WS_SUBSCRIPTION_EXECUTIONS_ENDPOINT_NAME in sent_message[
"args"] else self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value, sent_message))
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
try:
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_json_message(
ws_connect_mock.return_value,
self._authentication_response(True))
asyncio.get_event_loop().run_until_complete(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Error occurred subscribing to bybit_perpetual private channels ()"
))
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Bybit Perpetual WebSocket connection on"
" wss://stream.bybit.com/realtime_private. Retrying in 30 seconds. ()"
))
class WSConnectionTest(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.ws_url = "ws://some/url"
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.client_session = aiohttp.ClientSession()
self.ws_connection = WSConnection(self.client_session)
self.async_tasks: List[asyncio.Task] = []
def tearDown(self) -> None:
self.ws_connection.disconnect()
self.client_session.close()
for task in self.async_tasks:
task.cancel()
super().tearDown()
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_connect_and_disconnect(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.assertFalse(self.ws_connection.connected)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.assertTrue(self.ws_connection.connected)
self.async_run_with_timeout(self.ws_connection.disconnect())
self.assertFalse(self.ws_connection.connected)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_attempt_to_connect_second_time_raises(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
with self.assertRaises(RuntimeError) as e:
self.async_run_with_timeout(self.ws_connection.connect(
self.ws_url))
self.assertEqual("WS is connected.", str(e.exception))
def test_send_when_disconnected_raises(self):
request = WSRequest(payload={"one": 1})
with self.assertRaises(RuntimeError) as e:
self.async_run_with_timeout(self.ws_connection.send(request))
self.assertEqual("WS is not connected.", str(e.exception))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_send(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
request = WSRequest(payload={"one": 1})
self.async_run_with_timeout(self.ws_connection.send(request))
json_msgs = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value)
self.assertEqual(1, len(json_msgs))
self.assertEqual(request.payload, json_msgs[0])
def test_receive_when_disconnected_raises(self):
with self.assertRaises(RuntimeError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual("WS is not connected.", str(e.exception))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_raises_on_timeout(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
def raise_timeout(*_, **__):
raise asyncio.TimeoutError
ws_connect_mock.return_value.receive.side_effect = raise_timeout
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
with self.assertRaises(asyncio.TimeoutError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual("Message receive timed out.", str(e.exception))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
data = {"one": 1}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(data))
self.assertEqual(0, self.ws_connection.last_recv_time)
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertIsInstance(response, WSResponse)
self.assertEqual(data, response.data)
self.assertNotEqual(0, self.ws_connection.last_recv_time)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_disconnects_and_raises_on_aiohttp_closed(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.close_code = 1111
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.CLOSED)
with self.assertRaises(ConnectionError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual(
"The WS connection was closed unexpectedly. Close code = 1111 msg data: ",
str(e.exception))
self.assertFalse(self.ws_connection.connected)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_disconnects_and_raises_on_aiohttp_close(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.close_code = 1111
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.CLOSE)
with self.assertRaises(ConnectionError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual(
"The WS connection was closed unexpectedly. Close code = 1111 msg data: ",
str(e.exception))
self.assertFalse(self.ws_connection.connected)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ignores_aiohttp_close_msg_if_disconnect_called(
self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.CLOSED)
prev_side_effect = ws_connect_mock.return_value.receive.side_effect
async def disconnect_on_side_effect(*args, **kwargs):
await self.ws_connection.disconnect()
return await prev_side_effect(*args, **kwargs)
ws_connect_mock.return_value.receive.side_effect = disconnect_on_side_effect
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertFalse(self.ws_connection.connected)
self.assertIsNone(response)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ignores_ping(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.PING)
data = {"one": 1}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(data))
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual(data, response.data)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_sends_pong_on_ping(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.PING)
receive_task = self.ev_loop.create_task(self.ws_connection.receive())
self.async_tasks.append(receive_task)
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
ws_connect_mock.return_value.pong.assert_called()
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ping_updates_last_recv_time(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.PING)
receive_task = self.ev_loop.create_task(self.ws_connection.receive())
self.async_tasks.append(receive_task)
self.assertEqual(0, self.ws_connection.last_recv_time)
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertNotEqual(0, self.ws_connection.last_recv_time)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ignores_pong(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.PONG)
data = {"one": 1}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(data))
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual(data, response.data)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_pong_updates_last_recv_time(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
message="",
message_type=aiohttp.WSMsgType.PONG)
receive_task = self.ev_loop.create_task(self.ws_connection.receive())
self.async_tasks.append(receive_task)
self.assertEqual(0, self.ws_connection.last_recv_time)
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
ws_connect_mock.return_value)
self.assertNotEqual(0, self.ws_connection.last_recv_time)
class NdaxWebSocketAdaptorTests(TestCase):
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
@patch("aiohttp.ClientSession.ws_connect")
def test_sending_messages_increment_message_number(self, mock_ws):
sent_messages = []
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.send_json.side_effect = lambda sent_message: sent_messages.append(
sent_message)
adaptor = NdaxWebSocketAdaptor(throttler,
websocket=mock_ws.return_value)
payload = {}
asyncio.get_event_loop().run_until_complete(
adaptor.send_request(endpoint_name=CONSTANTS.WS_PING_REQUEST,
payload=payload,
limit_id=CONSTANTS.WS_PING_ID))
asyncio.get_event_loop().run_until_complete(
adaptor.send_request(endpoint_name=CONSTANTS.WS_PING_REQUEST,
payload=payload,
limit_id=CONSTANTS.WS_PING_ID))
asyncio.get_event_loop().run_until_complete(
adaptor.send_request(endpoint_name=CONSTANTS.WS_ORDER_BOOK_CHANNEL,
payload=payload))
self.assertEqual(3, len(sent_messages))
message = sent_messages[0]
self.assertEqual(1, message.get('i'))
message = sent_messages[1]
self.assertEqual(2, message.get('i'))
message = sent_messages[2]
self.assertEqual(3, message.get('i'))
@patch("aiohttp.ClientSession.ws_connect")
def test_request_message_structure(self, mock_ws):
sent_messages = []
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.send_json.side_effect = lambda sent_message: sent_messages.append(
sent_message)
adaptor = NdaxWebSocketAdaptor(throttler,
websocket=mock_ws.return_value)
payload = {"TestElement1": "Value1", "TestElement2": "Value2"}
asyncio.get_event_loop().run_until_complete(
adaptor.send_request(endpoint_name=CONSTANTS.WS_PING_REQUEST,
payload=payload,
limit_id=CONSTANTS.WS_PING_ID))
self.assertEqual(1, len(sent_messages))
message = sent_messages[0]
self.assertEqual(0, message.get('m'))
self.assertEqual(1, message.get('i'))
self.assertEqual(CONSTANTS.WS_PING_REQUEST, message.get('n'))
message_payload = json.loads(message.get('o'))
self.assertEqual(payload, message_payload)
@patch("aiohttp.ClientSession.ws_connect")
def test_receive_message(self, mock_ws):
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, 'test message')
adaptor = NdaxWebSocketAdaptor(throttler,
websocket=mock_ws.return_value)
received_message = asyncio.get_event_loop().run_until_complete(
adaptor.receive())
self.assertEqual('test message', received_message.data)
@patch("aiohttp.ClientSession.ws_connect")
def test_close(self, mock_ws):
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
adaptor = NdaxWebSocketAdaptor(throttler,
websocket=mock_ws.return_value)
asyncio.get_event_loop().run_until_complete(adaptor.close())
self.assertEquals(1, mock_ws.return_value.close.await_count)
@patch("aiohttp.ClientSession.ws_connect")
def test_get_payload_from_raw_received_message(self, mock_ws):
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
payload = {"Key1": True, "Key2": "Value2"}
message = {"m": 1, "i": 1, "n": "Endpoint", "o": json.dumps(payload)}
raw_message = json.dumps(message)
adaptor = NdaxWebSocketAdaptor(throttler,
websocket=mock_ws.return_value)
extracted_payload = adaptor.payload_from_raw_message(
raw_message=raw_message)
self.assertEqual(payload, extracted_payload)
@patch("aiohttp.ClientSession.ws_connect")
def test_get_endpoint_from_raw_received_message(self, mock_ws):
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
payload = {"Key1": True, "Key2": "Value2"}
message = {"m": 1, "i": 1, "n": "Endpoint", "o": json.dumps(payload)}
raw_message = json.dumps(message)
adaptor = NdaxWebSocketAdaptor(throttler,
websocket=mock_ws.return_value)
extracted_endpoint = adaptor.endpoint_from_raw_message(
raw_message=raw_message)
self.assertEqual("Endpoint", extracted_endpoint)
class BinancePerpetualAPIOrderBookDataSourceUnitTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ex_trading_pair = f"{cls.base_asset}{cls.quote_asset}"
cls.domain = "binance_perpetual_testnet"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.data_source = BinancePerpetualAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
domain=self.domain,
)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.resume_test_event = asyncio.Event()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def resume_test_callback(self, *_, **__):
self.resume_test_event.set()
return None
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
def _orderbook_update_event(self):
resp = {
"stream": f"{self.ex_trading_pair.lower()}@depth",
"data": {
"e": "depthUpdate",
"E": 1631591424198,
"T": 1631591424189,
"s": self.ex_trading_pair,
"U": 752409354963,
"u": 752409360466,
"pu": 752409354901,
"b": [
["43614.31", "0.000"],
],
"a": [
["45277.14", "0.257"],
]
}
}
return resp
def _orderbook_trade_event(self):
resp = {
"stream": f"{self.ex_trading_pair.lower()}@aggTrade",
"data": {
"e": "aggTrade",
"E": 1631594403486,
"a": 817295132,
"s": self.ex_trading_pair,
"p": "45266.16",
"q": "2.206",
"f": 1437689393,
"l": 1437689407,
"T": 1631594403330,
"m": False
}
}
return resp
@aioresponses()
def test_get_last_traded_prices(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.TICKER_PRICE_CHANGE_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# Truncated responses
"lastPrice": "10.0",
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result: Dict[str, Any] = self.async_run_with_timeout(
self.data_source.get_last_traded_prices(
trading_pairs=[self.trading_pair], domain=self.domain))
self.assertTrue(self.trading_pair in result)
self.assertEqual(10.0, result[self.trading_pair])
def test_get_throttler_instance(self):
self.assertTrue(
isinstance(self.data_source._get_throttler_instance(),
AsyncThrottler))
@aioresponses()
def test_fetch_trading_pairs_failure(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.EXCHANGE_INFO_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=400, body=ujson.dumps({"ERROR"}))
result: Dict[str, Any] = self.async_run_with_timeout(
self.data_source.fetch_trading_pairs(domain=self.domain))
self.assertEqual(0, len(result))
@aioresponses()
@patch(
"hummingbot.connector.derivative.binance_perpetual.binance_perpetual_utils.convert_from_exchange_trading_pair"
)
def test_fetch_trading_pairs_successful(self, mock_api, mock_utils):
mock_utils.return_value = self.trading_pair
url = utils.rest_url(path_url=CONSTANTS.EXCHANGE_INFO_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# Truncated Responses
"symbols": [{
"symbol": self.ex_trading_pair,
"pair": self.ex_trading_pair,
"baseAsset": self.base_asset,
"quoteAsset": self.quote_asset,
"status": "TRADING",
}, {
"symbol": "INACTIVEMARKET",
"status": "INACTIVE"
}],
}
mock_api.get(regex_url, status=200, body=ujson.dumps(mock_response))
result: Dict[str, Any] = self.async_run_with_timeout(
self.data_source.fetch_trading_pairs(domain=self.domain))
self.assertEqual(1, len(result))
@aioresponses()
def test_get_snapshot_exception_raised(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=400, body=ujson.dumps({"ERROR"}))
with self.assertRaises(IOError) as context:
self.async_run_with_timeout(
self.data_source.get_snapshot(trading_pair=self.trading_pair,
domain=self.domain))
self.assertEqual(
str(context.exception),
f"Error fetching Binance market snapshot for {self.trading_pair}.")
@aioresponses()
def test_get_snapshot_successful(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"lastUpdateId": 1027024,
"E": 1589436922972,
"T": 1589436922959,
"bids": [["10", "1"]],
"asks": [["11", "1"]]
}
mock_api.get(regex_url, status=200, body=ujson.dumps(mock_response))
result: Dict[str, Any] = self.async_run_with_timeout(
self.data_source.get_snapshot(trading_pair=self.trading_pair,
domain=self.domain))
self.assertEqual(mock_response, result)
@aioresponses()
def test_get_new_order_book(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"lastUpdateId": 1027024,
"E": 1589436922972,
"T": 1589436922959,
"bids": [["10", "1"]],
"asks": [["11", "1"]]
}
mock_api.get(regex_url, status=200, body=ujson.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source.get_new_order_book(
trading_pair=self.trading_pair))
self.assertIsInstance(result, OrderBook)
self.assertEqual(1027024, result.snapshot_uid)
@patch("aiohttp.ClientSession.ws_connect")
def test_create_websocket_connection_cancelled_when_connecting(
self, mock_ws):
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source._create_websocket_connection())
@patch("aiohttp.ClientSession.ws_connect")
def test_create_websocket_connection_exception_raised(self, mock_ws):
mock_ws.side_effect = Exception("TEST ERROR.")
with self.assertRaises(Exception):
self.async_run_with_timeout(
self.data_source._create_websocket_connection())
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occured when connecting to WebSocket server. Error: TEST ERROR."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
def test_listen_for_order_book_diffs_cancelled_when_connecting(
self, _, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
self.assertEqual(msg_queue.qsize(), 0)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch(
"hummingbot.connector.derivative.binance_perpetual.binance_perpetual_utils.convert_from_exchange_trading_pair"
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_logs_exception(
self, mock_ws, mock_utils, *_):
mock_utils.return_value = self.trading_pair
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
incomplete_resp = {
"m": 1,
"i": 2,
}
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, incomplete_resp)
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._orderbook_update_event())
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.mocking_assistant.run_until_all_json_messages_delivered(
mock_ws.return_value)
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Websocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.derivative.binance_perpetual.binance_perpetual_utils.convert_from_exchange_trading_pair"
)
def test_listen_for_order_book_diffs_successful(self, mock_utils, mock_ws):
mock_utils.return_value = self.trading_pair
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._orderbook_update_event())
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
result: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertIsInstance(result, OrderBookMessage)
self.assertEqual(OrderBookMessageType.DIFF, result.type)
self.assertTrue(result.has_update_id)
self.assertEqual(result.update_id, 752409360466)
self.assertEqual(self.trading_pair, result.content["trading_pair"])
self.assertEqual(1, len(result.content["bids"]))
self.assertEqual(1, len(result.content["asks"]))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_cancelled_error_raised(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive_json.side_effect = lambda: (
self._raise_exception(asyncio.CancelledError))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
self.assertEqual(msg_queue.qsize(), 0)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch(
"hummingbot.connector.derivative.binance_perpetual.binance_perpetual_utils.convert_from_exchange_trading_pair"
)
def test_listen_for_trades_logs_exception(self, mock_utils, _, mock_ws):
mock_utils.return_value = self.trading_pair
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
incomplete_resp = {
"m": 1,
"i": 2,
}
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, incomplete_resp)
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._orderbook_trade_event())
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
self.async_run_with_timeout(msg_queue.get())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Websocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.connector.derivative.binance_perpetual.binance_perpetual_utils.convert_from_exchange_trading_pair"
)
def test_listen_for_trades_successful(self, mock_utils, mock_ws):
mock_utils.return_value = self.trading_pair
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
self.mocking_assistant.add_websocket_json_message(
mock_ws.return_value, self._orderbook_trade_event())
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
result: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertIsInstance(result, OrderBookMessage)
self.assertEqual(OrderBookMessageType.TRADE, result.type)
self.assertTrue(result.has_trade_id)
self.assertEqual(result.trade_id, 817295132)
self.assertEqual(self.trading_pair, result.content["trading_pair"])
@aioresponses()
def test_listen_for_order_book_snapshots_cancelled_error_raised(
self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=asyncio.CancelledError)
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
self.assertEqual(0, msg_queue.qsize())
@aioresponses()
def test_listen_for_order_book_snapshots_logs_exception_error_with_response(
self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"m": 1,
"i": 2,
}
mock_api.get(regex_url,
body=ujson.dumps(mock_response),
callback=self.resume_test_callback)
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred fetching orderbook snapshots. Retrying in 5 seconds..."
))
@aioresponses()
def test_listen_for_order_book_snapshots_successful(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"lastUpdateId": 1027024,
"E": 1589436922972,
"T": 1589436922959,
"bids": [["10", "1"]],
"asks": [["11", "1"]]
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
result = self.async_run_with_timeout(msg_queue.get())
self.assertIsInstance(result, OrderBookMessage)
self.assertEqual(OrderBookMessageType.SNAPSHOT, result.type)
self.assertTrue(result.has_update_id)
self.assertEqual(result.update_id, 1027024)
self.assertEqual(self.trading_pair, result.content["trading_pair"])
class BinancePerpetualAPIOrderBookDataSourceUnitTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ex_trading_pair = f"{cls.base_asset}{cls.quote_asset}"
cls.domain = "binance_perpetual_testnet"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.async_tasks: List[asyncio.Task] = []
self.data_source = BinancePerpetualAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
domain=self.domain,
)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.resume_test_event = asyncio.Event()
BinancePerpetualAPIOrderBookDataSource._trading_pair_symbol_map = {
self.domain: bidict({self.ex_trading_pair: self.trading_pair})
}
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
for task in self.async_tasks:
task.cancel()
BinancePerpetualAPIOrderBookDataSource._trading_pair_symbol_map = {}
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def resume_test_callback(self, *_, **__):
self.resume_test_event.set()
return None
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
def _raise_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def _orderbook_update_event(self):
resp = {
"stream": f"{self.ex_trading_pair.lower()}@depth",
"data": {
"e": "depthUpdate",
"E": 1631591424198,
"T": 1631591424189,
"s": self.ex_trading_pair,
"U": 752409354963,
"u": 752409360466,
"pu": 752409354901,
"b": [
["43614.31", "0.000"],
],
"a": [
["45277.14", "0.257"],
],
},
}
return resp
def _orderbook_trade_event(self):
resp = {
"stream": f"{self.ex_trading_pair.lower()}@aggTrade",
"data": {
"e": "aggTrade",
"E": 1631594403486,
"a": 817295132,
"s": self.ex_trading_pair,
"p": "45266.16",
"q": "2.206",
"f": 1437689393,
"l": 1437689407,
"T": 1631594403330,
"m": False,
},
}
return resp
def _funding_info_event(self):
resp = {
"stream": f"{self.ex_trading_pair.lower()}@markPrice",
"data": {
"e": "markPriceUpdate",
"E": 1641288864000,
"s": self.ex_trading_pair,
"p": "46353.99600757",
"P": "46507.47845460",
"i": "46358.63622407",
"r": "0.00010000",
"T": 1641312000000,
},
}
return resp
@aioresponses()
def test_get_last_traded_prices(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.TICKER_PRICE_CHANGE_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# Truncated responses
"lastPrice": "10.0",
}
mock_api.get(regex_url, body=json.dumps(mock_response))
result: Dict[str, Any] = self.async_run_with_timeout(
self.data_source.get_last_traded_prices(
trading_pairs=[self.trading_pair], domain=self.domain))
self.assertTrue(self.trading_pair in result)
self.assertEqual(10.0, result[self.trading_pair])
def test_get_throttler_instance(self):
self.assertTrue(
isinstance(self.data_source._get_throttler_instance(),
AsyncThrottler))
@aioresponses()
def test_init_trading_pair_symbols_failure(self, mock_api):
BinancePerpetualAPIOrderBookDataSource._trading_pair_symbol_map = {}
url = utils.rest_url(path_url=CONSTANTS.EXCHANGE_INFO_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=400, body=json.dumps(["ERROR"]))
map = self.async_run_with_timeout(
self.data_source.trading_pair_symbol_map(domain=self.domain))
self.assertEqual(0, len(map))
@aioresponses()
def test_init_trading_pair_symbols_successful(self, mock_api):
url = utils.rest_url(path_url=CONSTANTS.EXCHANGE_INFO_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# Truncated Responses
"symbols": [
{
"symbol": self.ex_trading_pair,
"pair": self.ex_trading_pair,
"baseAsset": self.base_asset,
"quoteAsset": self.quote_asset,
"status": "TRADING",
},
{
"symbol": "INACTIVEMARKET",
"status": "INACTIVE"
},
],
}
mock_api.get(regex_url, status=200, body=json.dumps(mock_response))
self.async_run_with_timeout(
self.data_source.init_trading_pair_symbols(domain=self.domain))
self.assertEqual(1, len(self.data_source._trading_pair_symbol_map))
@aioresponses()
def test_trading_pair_symbol_map_dictionary_not_initialized(
self, mock_api):
BinancePerpetualAPIOrderBookDataSource._trading_pair_symbol_map = {}
url = utils.rest_url(path_url=CONSTANTS.EXCHANGE_INFO_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# Truncated Responses
"symbols": [
{
"symbol": self.ex_trading_pair,
"pair": self.ex_trading_pair,
"baseAsset": self.base_asset,
"quoteAsset": self.quote_asset,
"status": "TRADING",
},
]
}
mock_api.get(regex_url, status=200, body=json.dumps(mock_response))
self.async_run_with_timeout(
self.data_source.trading_pair_symbol_map(domain=self.domain))
self.assertEqual(1, len(self.data_source._trading_pair_symbol_map))
def test_trading_pair_symbol_map_dictionary_initialized(self):
result = self.async_run_with_timeout(
self.data_source.trading_pair_symbol_map(domain=self.domain))
self.assertEqual(1, len(result))
def test_convert_from_exchange_trading_pair_not_found(self):
unknown_pair = "UNKNOWN-PAIR"
with self.assertRaisesRegex(
ValueError,
f"There is no symbol mapping for exchange trading pair {unknown_pair}"
):
self.async_run_with_timeout(
self.data_source.convert_from_exchange_trading_pair(
unknown_pair, domain=self.domain))
def test_convert_from_exchange_trading_pair_successful(self):
result = self.async_run_with_timeout(
self.data_source.convert_from_exchange_trading_pair(
self.ex_trading_pair, domain=self.domain))
self.assertEqual(result, self.trading_pair)
def test_convert_to_exchange_trading_pair_not_found(self):
unknown_pair = "UNKNOWN-PAIR"
with self.assertRaisesRegex(
ValueError,
f"There is no symbol mapping for trading pair {unknown_pair}"):
self.async_run_with_timeout(
self.data_source.convert_to_exchange_trading_pair(
unknown_pair, domain=self.domain))
def test_convert_to_exchange_trading_pair_successful(self):
result = self.async_run_with_timeout(
self.data_source.convert_to_exchange_trading_pair(
self.trading_pair, domain=self.domain))
self.assertEqual(result, self.ex_trading_pair)
@aioresponses()
def test_get_snapshot_exception_raised(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=400, body=json.dumps(["ERROR"]))
with self.assertRaises(IOError) as context:
self.async_run_with_timeout(
self.data_source.get_snapshot(trading_pair=self.trading_pair,
domain=self.domain))
self.assertEqual(
str(context.exception),
f"Error fetching Binance market snapshot for {self.trading_pair}.")
@aioresponses()
def test_get_snapshot_successful(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"lastUpdateId": 1027024,
"E": 1589436922972,
"T": 1589436922959,
"bids": [["10", "1"]],
"asks": [["11", "1"]],
}
mock_api.get(regex_url, status=200, body=json.dumps(mock_response))
result: Dict[str, Any] = self.async_run_with_timeout(
self.data_source.get_snapshot(trading_pair=self.trading_pair,
domain=self.domain))
self.assertEqual(mock_response, result)
@aioresponses()
def test_get_new_order_book(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"lastUpdateId": 1027024,
"E": 1589436922972,
"T": 1589436922959,
"bids": [["10", "1"]],
"asks": [["11", "1"]],
}
mock_api.get(regex_url, status=200, body=json.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source.get_new_order_book(
trading_pair=self.trading_pair))
self.assertIsInstance(result, OrderBook)
self.assertEqual(1027024, result.snapshot_uid)
@aioresponses()
def test_get_funding_info_from_exchange_error_response(self, mock_api):
url = utils.rest_url(CONSTANTS.MARK_PRICE_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, status=400)
result = self.async_run_with_timeout(
self.data_source._get_funding_info_from_exchange(
self.trading_pair))
self.assertIsNone(result)
self._is_logged(
"ERROR",
f"Unable to fetch FundingInfo for {self.trading_pair}. Error: None"
)
@aioresponses()
def test_get_funding_info_from_exchange_successful(self, mock_api):
url = utils.rest_url(CONSTANTS.MARK_PRICE_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"symbol": self.ex_trading_pair,
"markPrice": "46382.32704603",
"indexPrice": "46385.80064948",
"estimatedSettlePrice": "46510.13598963",
"lastFundingRate": "0.00010000",
"interestRate": "0.00010000",
"nextFundingTime": 1641312000000,
"time": 1641288825000,
}
mock_api.get(regex_url, body=json.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source._get_funding_info_from_exchange(
self.trading_pair))
self.assertIsInstance(result, FundingInfo)
self.assertEqual(result.trading_pair, self.trading_pair)
self.assertEqual(result.index_price,
Decimal(mock_response["indexPrice"]))
self.assertEqual(result.mark_price,
Decimal(mock_response["markPrice"]))
self.assertEqual(result.next_funding_utc_timestamp,
mock_response["nextFundingTime"])
self.assertEqual(result.rate,
Decimal(mock_response["lastFundingRate"]))
@aioresponses()
def test_get_funding_info(self, mock_api):
self.assertNotIn(self.trading_pair, self.data_source._funding_info)
url = utils.rest_url(CONSTANTS.MARK_PRICE_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"symbol": self.ex_trading_pair,
"markPrice": "46382.32704603",
"indexPrice": "46385.80064948",
"estimatedSettlePrice": "46510.13598963",
"lastFundingRate": "0.00010000",
"interestRate": "0.00010000",
"nextFundingTime": 1641312000000,
"time": 1641288825000,
}
mock_api.get(regex_url, body=json.dumps(mock_response))
result = self.async_run_with_timeout(
self.data_source.get_funding_info(trading_pair=self.trading_pair))
self.assertIsInstance(result, FundingInfo)
self.assertEqual(result.trading_pair, self.trading_pair)
self.assertEqual(result.index_price,
Decimal(mock_response["indexPrice"]))
self.assertEqual(result.mark_price,
Decimal(mock_response["markPrice"]))
self.assertEqual(result.next_funding_utc_timestamp,
mock_response["nextFundingTime"])
self.assertEqual(result.rate,
Decimal(mock_response["lastFundingRate"]))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
def test_listen_for_subscriptions_cancelled_when_connecting(
self, _, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.async_run_with_timeout(self.listening_task)
self.assertEqual(msg_queue.qsize(), 0)
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_logs_exception(self, mock_ws, *_):
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
incomplete_resp = {
"m": 1,
"i": 2,
}
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, json.dumps(incomplete_resp))
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, json.dumps(self._orderbook_update_event()))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
try:
self.async_run_with_timeout(self.listening_task)
except asyncio.exceptions.TimeoutError:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with Websocket connection. Retrying after 30 seconds..."
))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_subscriptions_successful(self, mock_ws):
msg_queue_diffs: asyncio.Queue = asyncio.Queue()
msg_queue_trades: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, json.dumps(self._orderbook_update_event()))
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, json.dumps(self._orderbook_trade_event()))
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, json.dumps(self._funding_info_event()))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.listening_task_diffs = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue_diffs))
self.listening_task_trades = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue_trades))
self.listening_task_funding_info = self.ev_loop.create_task(
self.data_source.listen_for_funding_info())
result: OrderBookMessage = self.async_run_with_timeout(
msg_queue_diffs.get())
self.assertIsInstance(result, OrderBookMessage)
self.assertEqual(OrderBookMessageType.DIFF, result.type)
self.assertTrue(result.has_update_id)
self.assertEqual(result.update_id, 752409360466)
self.assertEqual(self.trading_pair, result.content["trading_pair"])
self.assertEqual(1, len(result.content["bids"]))
self.assertEqual(1, len(result.content["asks"]))
result: OrderBookMessage = self.async_run_with_timeout(
msg_queue_trades.get())
self.assertIsInstance(result, OrderBookMessage)
self.assertEqual(OrderBookMessageType.TRADE, result.type)
self.assertTrue(result.has_trade_id)
self.assertEqual(result.trade_id, 817295132)
self.assertEqual(self.trading_pair, result.content["trading_pair"])
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
mock_ws.return_value)
self.assertIn(self.trading_pair, self.data_source.funding_info)
funding_info: FundingInfo = self.data_source.funding_info[
self.trading_pair]
self.assertTrue(self.data_source.is_funding_info_initialized)
self.assertEqual(funding_info.trading_pair, self.trading_pair)
self.assertEqual(funding_info.index_price,
Decimal(self._funding_info_event()["data"]["i"]))
self.assertEqual(funding_info.mark_price,
Decimal(self._funding_info_event()["data"]["p"]))
self.assertEqual(funding_info.next_funding_utc_timestamp,
int(self._funding_info_event()["data"]["T"]))
self.assertEqual(funding_info.rate,
Decimal(self._funding_info_event()["data"]["r"]))
@aioresponses()
def test_listen_for_order_book_snapshots_cancelled_error_raised(
self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url, exception=asyncio.CancelledError)
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.listening_task)
self.assertEqual(0, msg_queue.qsize())
@aioresponses()
def test_listen_for_order_book_snapshots_logs_exception_error_with_response(
self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"m": 1,
"i": 2,
}
mock_api.get(regex_url,
body=json.dumps(mock_response),
callback=self.resume_test_callback)
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occurred fetching orderbook snapshots. Retrying in 5 seconds..."
))
@aioresponses()
def test_listen_for_order_book_snapshots_successful(self, mock_api):
url = utils.rest_url(CONSTANTS.SNAPSHOT_REST_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
"lastUpdateId": 1027024,
"E": 1589436922972,
"T": 1589436922959,
"bids": [["10", "1"]],
"asks": [["11", "1"]],
}
mock_api.get(regex_url, body=json.dumps(mock_response))
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
result = self.async_run_with_timeout(msg_queue.get())
self.assertIsInstance(result, OrderBookMessage)
self.assertEqual(OrderBookMessageType.SNAPSHOT, result.type)
self.assertTrue(result.has_update_id)
self.assertEqual(result.update_id, 1027024)
self.assertEqual(self.trading_pair, result.content["trading_pair"])
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_funding_info_invalid_trading_pair(self, mock_ws):
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
mock_response = {
"stream": "unknown_pair@markPrice",
"data": {
"e": "markPriceUpdate",
"E": 1641288864000,
"s": "unknown_pair",
"p": "46353.99600757",
"P": "46507.47845460",
"i": "46358.63622407",
"r": "0.00010000",
"T": 1641312000000,
},
}
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, json.dumps(mock_response))
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_subscriptions())
self.listening_task_funding_info = self.ev_loop.create_task(
self.data_source.listen_for_funding_info())
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
mock_ws.return_value)
self.assertNotIn(self.trading_pair, self.data_source.funding_info)
def test_listen_for_funding_info_cancelled_error_raised(self):
mock_queue = AsyncMock()
mock_queue.get.side_effect = asyncio.CancelledError
self.data_source._message_queue[
CONSTANTS.FUNDING_INFO_STREAM_ID] = mock_queue
with self.assertRaises(asyncio.CancelledError):
self.async_run_with_timeout(
self.data_source.listen_for_funding_info())
@patch(
"hummingbot.core.data_type.order_book_tracker_data_source.OrderBookTrackerDataSource._sleep"
)
def test_listen_for_funding_info_logs_exception(self, mock_sleep):
mock_sleep.side_effect = lambda _: (self.ev_loop.run_until_complete(
asyncio.sleep(0.5)))
mock_queue = AsyncMock()
mock_queue.get.side_effect = lambda: (
self._raise_exception_and_unlock_test_with_event(
Exception("TEST ERROR")))
self.data_source._message_queue[
CONSTANTS.FUNDING_INFO_STREAM_ID] = mock_queue
self.listening_task_funding_info = self.ev_loop.create_task(
self.data_source.listen_for_funding_info())
self.async_run_with_timeout(self.resume_test_event.wait())
self._is_logged(
"ERROR",
"Unexpected error occured updating funding information. Retrying in 5 seconds... Error: TEST ERROR"
)
class TestGateIoAPIOrderBookDataSource(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
gate_io_auth = GateIoAuth(api_key="someKey", secret_key="someSecret")
self.data_source = GateIoAPIUserStreamDataSource(gate_io_auth, trading_pairs=[self.trading_pair])
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(asyncio.wait_for(coroutine, timeout))
return ret
def get_user_trades_mock(self) -> Dict:
user_trades = {
"time": 1605176741,
"channel": "spot.usertrades",
"event": "update",
"result": [
{
"id": 5736713,
"user_id": 1000001,
"order_id": "30784428",
"currency_pair": f"{self.base_asset}_{self.quote_asset}",
"create_time": 1605176741,
"create_time_ms": "1605176741123.456",
"side": "sell",
"amount": "1.00000000",
"role": "taker",
"price": "10000.00000000",
"fee": "0.00200000000000",
"point_fee": "0",
"gt_fee": "0",
"text": "apiv4"
}
]
}
return user_trades
def get_user_orders_mock(self) -> Dict:
user_orders = {
"time": 1605175506,
"channel": "spot.orders",
"event": "update",
"result": [
{
"id": "30784435",
"user": 123456,
"text": "t-abc",
"create_time": "1605175506",
"create_time_ms": "1605175506123",
"update_time": "1605175506",
"update_time_ms": "1605175506123",
"event": "put",
"currency_pair": f"{self.base_asset}_{self.quote_asset}",
"type": "limit",
"account": "spot",
"side": "sell",
"amount": "1",
"price": "10001",
"time_in_force": "gtc",
"left": "1",
"filled_total": "0",
"fee": "0",
"fee_currency": "USDT",
"point_fee": "0",
"gt_fee": "0",
"gt_discount": True,
"rebated_fee": "0",
"rebated_fee_currency": "USDT"
}
]
}
return user_orders
def get_user_balance_mock(self) -> Dict:
user_balance = {
"time": 1605248616,
"channel": "spot.balances",
"event": "update",
"result": [
{
"timestamp": "1605248616",
"timestamp_ms": "1605248616123",
"user": "******",
"currency": self.base_asset,
"change": "100",
"total": "1032951.325075926",
"available": "1022943.325075926"
}
]
}
return user_balance
@patch("websockets.connect", new_callable=AsyncMock)
def test_listen_for_user_stream(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_user_stream(self.ev_loop, output_queue))
resp = self.get_user_trades_mock()
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value, message=json.dumps(resp)
)
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
resp = self.get_user_orders_mock()
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value, message=json.dumps(resp)
)
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
resp = self.get_user_balance_mock()
self.mocking_assistant.add_websocket_text_message(
websocket_mock=ws_connect_mock.return_value, message=json.dumps(resp)
)
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
class KrakenAPIOrderBookDataSourceTest(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.api_tier = KrakenAPITier.STARTER
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(
build_rate_limits_by_tier(self.api_tier))
self.data_source = KrakenAPIOrderBookDataSource(
self.throttler, trading_pairs=[self.trading_pair])
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def get_last_traded_prices_mock(self, last_trade_close: Decimal) -> Dict:
last_traded_prices = {
"error": [],
"result": {
f"X{self.base_asset}{self.quote_asset}": {
"a": ["52609.60000", "1", "1.000"],
"b": ["52609.50000", "1", "1.000"],
"c": [str(last_trade_close), "0.00080000"],
"v": ["1920.83610601", "7954.00219674"],
"p": ["52389.94668", "54022.90683"],
"t": [23329, 80463],
"l": ["51513.90000", "51513.90000"],
"h": ["53219.90000", "57200.00000"],
"o": "52280.40000"
}
}
}
return last_traded_prices
def get_depth_mock(self) -> Dict:
depth = {
"error": [],
"result": {
f"X{self.base_asset}{self.quote_asset}": {
"asks": [["52523.00000", "1.199", 1616663113],
["52536.00000", "0.300", 1616663112]],
"bids": [["52522.90000", "0.753", 1616663112],
["52522.80000", "0.006", 1616663109]]
}
}
}
return depth
def get_public_asset_pair_mock(self) -> Dict:
asset_pairs = {
"error": [],
"result": {
f"X{self.base_asset}{self.quote_asset}": {
"altname": f"{self.base_asset}{self.quote_asset}",
"wsname": f"{self.base_asset}/{self.quote_asset}",
"aclass_base": "currency",
"base": self.base_asset,
"aclass_quote": "currency",
"quote": self.quote_asset,
"lot": "unit",
"pair_decimals": 5,
"lot_decimals": 8,
"lot_multiplier": 1,
"leverage_buy": [2, 3, 4, 5],
"leverage_sell": [2, 3, 4, 5],
"fees": [
[0, 0.26],
[50000, 0.24],
],
"fees_maker": [
[0, 0.16],
[50000, 0.14],
],
"fee_volume_currency": "ZUSD",
"margin_call": 80,
"margin_stop": 40,
"ordermin": "0.005"
},
}
}
return asset_pairs
def get_trade_data_mock(self) -> List:
trade_data = [
0,
[["5541.20000", "0.15850568", "1534614057.321597", "s", "l", ""],
["6060.00000", "0.02455000", "1534614057.324998", "b", "l", ""]],
"trade", f"{self.base_asset}/{self.quote_asset}"
]
return trade_data
@aioresponses()
def test_get_last_traded_prices(self, mocked_api):
url = f"{CONSTANTS.BASE_URL}{CONSTANTS.TICKER_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
last_traded_price = Decimal("52641.10000")
resp = self.get_last_traded_prices_mock(
last_trade_close=last_traded_price)
mocked_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
KrakenAPIOrderBookDataSource.get_last_traded_prices(
trading_pairs=[self.trading_pair], throttler=self.throttler))
self.assertIn(self.trading_pair, ret)
self.assertEqual(float(last_traded_price), ret[self.trading_pair])
@aioresponses()
def test_get_new_order_book(self, mocked_api):
url = f"{CONSTANTS.BASE_URL}{CONSTANTS.SNAPSHOT_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
resp = self.get_depth_mock()
mocked_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
self.data_source.get_new_order_book(self.trading_pair))
self.assertTrue(isinstance(ret, OrderBook))
bids_df, asks_df = ret.snapshot
pair_data = resp["result"][f"X{self.base_asset}{self.quote_asset}"]
first_bid_price = float(pair_data["bids"][0][0])
first_ask_price = float(pair_data["asks"][0][0])
self.assertEqual(first_bid_price, bids_df.iloc[0]["price"])
self.assertEqual(first_ask_price, asks_df.iloc[0]["price"])
@aioresponses()
def test_fetch_trading_pairs(self, mocked_api):
url = f"{CONSTANTS.BASE_URL}{CONSTANTS.ASSET_PAIRS_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
resp = self.get_public_asset_pair_mock()
mocked_api.get(regex_url, body=json.dumps(resp))
resp = self.async_run_with_timeout(
KrakenAPIOrderBookDataSource.fetch_trading_pairs())
self.assertTrue(len(resp) == 1)
self.assertIn(self.trading_pair, resp)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
resp = self.get_trade_data_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
websocket_mock=ws_connect_mock.return_value,
message=json.dumps(resp))
output_queue = asyncio.Queue()
self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
websocket_mock=ws_connect_mock.return_value)
self.assertTrue(not output_queue.empty())
msg = output_queue.get_nowait()
self.assertTrue(isinstance(msg, OrderBookMessage))
first_trade_price = resp[1][0][0]
self.assertEqual(msg.content["price"], first_trade_price)
self.assertTrue(not output_queue.empty())
msg = output_queue.get_nowait()
self.assertTrue(isinstance(msg, OrderBookMessage))
second_trade_price = resp[1][1][0]
self.assertEqual(msg.content["price"], second_trade_price)
class BitmartAPIUserStreamDataSourceTests(unittest.TestCase):
# the level is required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.api_key = 'testAPIKey'
cls.secret = 'testSecret'
cls.memo = '001'
cls.account_id = 528
cls.username = '******'
cls.oms_id = 1
cls.ev_loop = asyncio.get_event_loop()
def setUp(self) -> None:
super().setUp()
self.listening_task = None
self.log_records = []
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
auth_assistant = BitmartAuth(api_key=self.api_key,
secret_key=self.secret,
memo=self.memo)
self.data_source = BitmartAPIUserStreamDataSource(
auth_assistant, throttler)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.data_source._trading_pairs = ["HBOT-USDT"]
self.mocking_assistant = NetworkMockingAssistant()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_authenticates_and_subscribes_to_events(
self, ws_connect_mock):
mock_response: Dict[Any] = {
"data": [{
"symbol": "BTC_USDT",
"side": "buy",
"type": "market",
"notional": "",
"size": "1.0000000000",
"ms_t": "1609926028000",
"price": "46100.0000000000",
"filled_notional": "46100.0000000000",
"filled_size": "1.0000000000",
"margin_trading": "0",
"state": "2",
"order_id": "2147857398",
"order_type": "0",
"last_fill_time": "1609926039226",
"last_fill_price": "46100.00000",
"last_fill_count": "1.00000"
}],
"table":
"spot/user/order"
}
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
initial_last_recv_time = self.data_source.last_recv_time
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps({"event": "login"}))
# Add a dummy message for the websocket to read and include in the "messages" queue
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(mock_response))
first_received_message = self.ev_loop.run_until_complete(
messages.get())
self.assertEqual(mock_response, first_received_message)
self.assertTrue(
self._is_logged('INFO', "Authenticating to User Stream..."))
self.assertTrue(
self._is_logged('INFO',
"Successfully authenticated to User Stream."))
self.assertTrue(
self._is_logged(
'INFO', "Successfully subscribed to all Private channels."))
sent_messages = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value)
self.assertEqual(2, len(sent_messages))
auth_req = sent_messages[0]
sub_req = sent_messages[1]
self.assertTrue("op" in auth_req and "args" in auth_req
and "testAPIKey" in auth_req["args"])
self.assertEqual(
{
"op": "subscribe",
"args": ["spot/user/order:HBOT_USDT"]
}, sub_req)
self.assertGreater(self.data_source.last_recv_time,
initial_last_recv_time)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_fails_when_authentication_fails(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.closed = False
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop, messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
json.dumps({
"errorCode": "test code",
"errorMessage": "test err message"
}))
try:
self.ev_loop.run_until_complete(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"WebSocket login errored with message: test err message"))
self.assertTrue(
self._is_logged(
"ERROR", "Error occurred when authenticating to user stream."))
self.assertTrue(
self._is_logged(
"ERROR", "Unexpected error with BitMart WebSocket connection. "
"Retrying after 30 seconds..."))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_initialization(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(
self.ev_loop, messages))
self.ev_loop.run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_authentication(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(asyncio.CancelledError)
if "testAPIKey" in sent_message["args"] else self.mocking_assistant
._sent_websocket_json_messages[ws_connect_mock.return_value
].append(sent_message))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(
self.ev_loop, messages))
self.ev_loop.run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_events_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(asyncio.CancelledError)
if "spot/user/order:HBOT_USDT" in sent_message["args"] else self.
mocking_assistant._sent_websocket_json_messages[
ws_connect_mock.return_value].append(sent_message))
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(
self.ev_loop, messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps({"event": "login"}))
self.ev_loop.run_until_complete(self.listening_task)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_details_during_initialization(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.side_effect = Exception
with self.assertRaises(Exception):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(
self.ev_loop, messages))
try:
self.async_run_with_timeout(self.listening_task)
except asyncio.TimeoutError:
raise
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error with BitMart WebSocket connection. Retrying after 30 seconds..."
))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_details_during_authentication(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(Exception)
if "testAPIKey" in sent_message["args"] else self.mocking_assistant
._sent_websocket_json_messages[ws_connect_mock.return_value
].append(sent_message))
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.closed = False
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
try:
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(
self.ev_loop, messages))
self.ev_loop.run_until_complete(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR", "Error occurred when authenticating to user stream."))
self.assertTrue(
self._is_logged(
"ERROR", "Unexpected error with BitMart WebSocket connection. "
"Retrying after 30 seconds..."))
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listening_process_logs_exception_during_events_subscription(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
ws_connect_mock.return_value.send_json.side_effect = lambda sent_message: (
self._raise_exception(Exception)
if "spot/user/order:HBOT_USDT" in sent_message["args"] else self.
mocking_assistant._sent_websocket_json_messages[
ws_connect_mock.return_value].append(sent_message))
# Make the close function raise an exception to finish the execution
ws_connect_mock.return_value.closed = False
ws_connect_mock.return_value.close.side_effect = lambda: self._raise_exception(
Exception)
try:
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(
self.ev_loop, messages))
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps({"event": "login"}))
self.async_run_with_timeout(self.listening_task)
except Exception:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Error occured during subscribing to Bitmart private channels."
))
self.assertTrue(
self._is_logged(
"ERROR", "Unexpected error with BitMart WebSocket connection. "
"Retrying after 30 seconds..."))
class BitmartAPIOrderBookDataSourceUnitTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.ws_sent_messages = []
self.ws_incoming_messages = asyncio.Queue()
self.listening_task = None
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = BitmartAPIOrderBookDataSource(
self.throttler, [self.trading_pair])
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def _order_book_snapshot_example(self):
return {
"data": {
"timestamp":
1527777538000,
"buys": [
{
"amount": "4800.00",
"total": "4800.00",
"price": "0.000767",
"count": "1"
},
{
"amount": "99996475.79",
"total": "100001275.79",
"price": "0.000201",
"count": "1"
},
],
"sells": [
{
"amount": "100.00",
"total": "100.00",
"price": "0.007000",
"count": "1"
},
{
"amount": "6997.00",
"total": "7097.00",
"price": "1.000000",
"count": "1"
},
]
}
}
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
@aioresponses()
def test_get_last_traded_prices(self, mock_get):
mock_response: Dict[Any] = {
"message": "OK",
"code": 1000,
"trace": "6e42c7c9-fdc5-461b-8fd1-b4e2e1b9ed57",
"data": {
"tickers": [{
"symbol":
"COINALPHA_HBOT",
"last_price":
"1.00",
"quote_volume_24h":
"201477650.88000",
"base_volume_24h":
"25186.48000",
"high_24h":
"8800.00",
"low_24h":
"1.00",
"open_24h":
"8800.00",
"close_24h":
"1.00",
"best_ask":
"0.00",
"best_ask_size":
"0.00000",
"best_bid":
"0.00",
"best_bid_size":
"0.00000",
"fluctuation":
"-0.9999",
"url":
"https://www.bitmart.com/trade?symbol=COINALPHA_HBOT"
}]
}
}
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_LAST_TRADING_PRICES_PATH_URL}"
)
mock_get.get(regex_url, body=json.dumps(mock_response))
results = self.ev_loop.run_until_complete(
asyncio.gather(
self.data_source.get_last_traded_prices([self.trading_pair])))
results: Dict[str, Any] = results[0]
self.assertEqual(results[self.trading_pair], float("1.00"))
@aioresponses()
def test_fetch_trading_pairs(self, mock_get):
mock_response: List[Any] = {
"code": 1000,
"trace": "886fb6ae-456b-4654-b4e0-d681ac05cea1",
"message": "OK",
"data": {
"symbols": [
"COINALPHA_HBOT",
"ANOTHER_MARKET",
]
}
}
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_TRADING_PAIRS_PATH_URL}")
mock_get.get(regex_url, body=json.dumps(mock_response))
results: List[str] = self.ev_loop.run_until_complete(
self.data_source.fetch_trading_pairs())
self.assertTrue(self.trading_pair in results)
self.assertTrue("ANOTHER-MARKET" in results)
@aioresponses()
def test_fetch_trading_pairs_with_error_status_in_response(self, mock_get):
mock_response = {}
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_TRADING_PAIRS_PATH_URL}")
mock_get.get(regex_url, body=json.dumps(mock_response))
result = self.ev_loop.run_until_complete(
self.data_source.fetch_trading_pairs())
self.assertEqual(0, len(result))
@aioresponses()
def test_get_order_book_data(self, mock_get):
mock_response: Dict[str, Any] = self._order_book_snapshot_example()
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_ORDER_BOOK_PATH_URL}")
mock_get.get(regex_url, body=json.dumps(mock_response))
results = self.ev_loop.run_until_complete(
asyncio.gather(
self.data_source.get_order_book_data(self.trading_pair)))
result = results[0]
self.assertTrue("timestamp" in result)
self.assertTrue("buys" in result)
self.assertTrue("sells" in result)
self.assertGreaterEqual(len(result["buys"]) + len(result["sells"]), 0)
self.assertEqual(mock_response["data"]["buys"][0], result["buys"][0])
@aioresponses()
def test_get_order_book_data_raises_exception_when_response_has_error_code(
self, mock_get):
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_ORDER_BOOK_PATH_URL}")
mock_get.get(regex_url, status=100, body=json.dumps({}))
with self.assertRaises(IOError) as context:
self.ev_loop.run_until_complete(
self.data_source.get_order_book_data(self.trading_pair))
self.assertEqual(
str(context.exception),
f"Error fetching OrderBook for {self.trading_pair} at {CONSTANTS.EXCHANGE_NAME}. "
f"HTTP status is {100}.")
@aioresponses()
def test_get_new_order_book(self, mock_get):
mock_response: Dict[str, Any] = self._order_book_snapshot_example()
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_ORDER_BOOK_PATH_URL}")
mock_get.get(regex_url, body=json.dumps(mock_response))
results = self.ev_loop.run_until_complete(
asyncio.gather(
self.data_source.get_new_order_book(self.trading_pair)))
result: OrderBook = results[0]
self.assertTrue(type(result) == OrderBook)
self.assertEqual(result.snapshot_uid,
mock_response["data"]["timestamp"])
def test_listen_for_snapshots_cancelled_when_fetching_snapshot(self):
trades_queue = asyncio.Queue()
task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_order_book_snapshots(
ev_loop=asyncio.get_event_loop(), output=trades_queue))
with self.assertRaises(asyncio.CancelledError):
task.cancel()
asyncio.get_event_loop().run_until_complete(task)
@aioresponses()
@patch(
"hummingbot.connector.exchange.bitmart.bitmart_api_order_book_data_source.BitmartAPIOrderBookDataSource._sleep",
new_callable=AsyncMock)
def test_listen_for_snapshots_logs_exception_when_fetching_snapshot(
self, mock_get, mock_sleep):
# the queue and the division by zero error are used just to synchronize the test
sync_queue = deque()
sync_queue.append(1)
sync_queue.append(2)
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_ORDER_BOOK_PATH_URL}")
mock_get.get(regex_url, body=json.dumps({}))
mock_sleep.side_effect = lambda delay: 1 / 0 if len(
sync_queue) == 0 else sync_queue.pop()
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(ZeroDivisionError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_order_book_snapshots(
asyncio.get_event_loop(), msg_queue))
asyncio.get_event_loop().run_until_complete(self.listening_task)
self.assertEqual(0, msg_queue.qsize())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occured listening for orderbook snapshots. Retrying in 5 secs..."
))
@aioresponses()
@patch(
"hummingbot.connector.exchange.bitmart.bitmart_api_order_book_data_source.BitmartAPIOrderBookDataSource._sleep",
new_callable=AsyncMock)
def test_listen_for_snapshots_successful(self, mock_get, mock_sleep):
# the queue and the division by zero error are used just to synchronize the test
sync_queue = deque()
sync_queue.append(1)
sync_queue.append(2)
mock_response: Dict[str, Any] = self._order_book_snapshot_example()
regex_url = re.compile(
f"{CONSTANTS.REST_URL}/{CONSTANTS.GET_ORDER_BOOK_PATH_URL}")
mock_get.get(regex_url, body=json.dumps(mock_response))
mock_sleep.side_effect = lambda delay: 1 / 0 if len(
sync_queue) == 0 else sync_queue.pop()
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(ZeroDivisionError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_order_book_snapshots(
asyncio.get_event_loop(), msg_queue))
asyncio.get_event_loop().run_until_complete(self.listening_task)
self.assertEqual(msg_queue.qsize(), 1)
snapshot_msg: OrderBookMessage = msg_queue.get_nowait()
self.assertEqual(snapshot_msg.update_id,
mock_response["data"]["timestamp"])
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listen_for_order_book_diffs_cancelled_when_listening(
self, mock_ws):
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
msg_queue: asyncio.Queue = asyncio.Queue()
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
with self.assertRaises(asyncio.CancelledError):
self.listening_task.cancel()
asyncio.get_event_loop().run_until_complete(self.listening_task)
self.assertEqual(msg_queue.qsize(), 0)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_successful(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
resp = {
"table":
"spot/depth5",
"data": [{
"asks": [["161.96", "7.37567"]],
"bids": [["161.94", "4.552355"]],
"symbol": "ETH_USDT",
"ms_t": 1542337219120
}]
}
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value,
bitmart_utils.compress_ws_message(ujson.dumps(resp)),
message_type=aiohttp.WSMsgType.BINARY)
BitmartAPIOrderBookDataSource._trading_pairs = ["ETH-USDT"]
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
first_msg: OrderBookMessage = self.async_run_with_timeout(
msg_queue.get())
self.assertTrue(first_msg.type == OrderBookMessageType.SNAPSHOT)
def _trade_ws_messsage(self):
resp = {
"table":
"spot/trade",
"data": [{
"symbol": "ETH_USDT",
"price": "162.12",
"side": "buy",
"size": "11.085",
"s_t": 1542337219
}, {
"symbol": "ETH_USDT",
"price": "163.12",
"side": "buy",
"size": "15",
"s_t": 1542337238
}]
}
return ujson.dumps(resp)
@patch('aiohttp.ClientSession.ws_connect', new_callable=AsyncMock)
def test_listen_for_trades(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.close.return_value = None
# Add message to be processed after subscriptions, to unlock the test
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value,
bitmart_utils.compress_ws_message(self._trade_ws_messsage()),
message_type=aiohttp.WSMsgType.BINARY)
BitmartAPIOrderBookDataSource._trading_pairs = ["ETH-USDT"]
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_trades(self.ev_loop, msg_queue))
trade1: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
trade2: OrderBookMessage = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(msg_queue.empty())
self.assertEqual(1542337219 * 1000, int(trade1.trade_id))
self.assertEqual(1542337238 * 1000, int(trade2.trade_id))
class BinanceUserStreamDataSourceUnitTests(unittest.TestCase):
# the level is required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.ex_trading_pair = cls.base_asset + cls.quote_asset
cls.domain = "com"
cls.listen_key = "TEST_LISTEN_KEY"
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task: Optional[asyncio.Task] = None
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.mock_time_provider = MagicMock()
self.mock_time_provider.time.return_value = 1000
self.time_synchronizer = TimeSynchronizer()
self.time_synchronizer.add_time_offset_ms_sample(0)
self.data_source = BinanceAPIUserStreamDataSource(
auth=BinanceAuth(api_key="TEST_API_KEY", secret_key="TEST_SECRET", time_provider=self.mock_time_provider),
domain=self.domain,
throttler=self.throttler,
time_synchronizer=self.time_synchronizer,
)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.resume_test_event = asyncio.Event()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def _is_logged(self, log_level: str, message: str) -> bool:
return any(record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
def _create_exception_and_unlock_test_with_event(self, exception):
self.resume_test_event.set()
raise exception
def _create_return_value_and_unlock_test_with_event(self, value):
self.resume_test_event.set()
return value
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(asyncio.wait_for(coroutine, timeout))
return ret
def _error_response(self) -> Dict[str, Any]:
resp = {
"code": "ERROR CODE",
"msg": "ERROR MESSAGE"
}
return resp
def _user_update_event(self):
# Balance Update
resp = {
"e": "balanceUpdate",
"E": 1573200697110,
"a": "BTC",
"d": "100.00000000",
"T": 1573200697068
}
return json.dumps(resp)
def _successfully_subscribed_event(self):
resp = {
"result": None,
"id": 1
}
return resp
@aioresponses()
def test_get_listen_key_log_exception(self, mock_api):
url = web_utils.private_rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_api.post(regex_url, status=400, body=json.dumps(self._error_response()))
with self.assertRaises(IOError):
self.async_run_with_timeout(self.data_source._get_listen_key())
@aioresponses()
def test_get_listen_key_successful(self, mock_api):
url = web_utils.private_rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = {
"listenKey": self.listen_key
}
mock_api.post(regex_url, body=json.dumps(mock_response))
result: str = self.async_run_with_timeout(self.data_source._get_listen_key())
self.assertEqual(self.listen_key, result)
@aioresponses()
def test_ping_listen_key_log_exception(self, mock_api):
url = web_utils.private_rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_api.put(regex_url, status=400, body=json.dumps(self._error_response()))
self.data_source._current_listen_key = self.listen_key
result: bool = self.async_run_with_timeout(self.data_source._ping_listen_key())
self.assertTrue(self._is_logged("WARNING", f"Failed to refresh the listen key {self.listen_key}: {self._error_response()}"))
self.assertFalse(result)
@aioresponses()
def test_ping_listen_key_successful(self, mock_api):
url = web_utils.private_rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_api.put(regex_url, body=json.dumps({}))
self.data_source._current_listen_key = self.listen_key
result: bool = self.async_run_with_timeout(self.data_source._ping_listen_key())
self.assertTrue(result)
@patch("hummingbot.connector.exchange.binance.binance_api_user_stream_data_source.BinanceAPIUserStreamDataSource"
"._ping_listen_key",
new_callable=AsyncMock)
def test_manage_listen_key_task_loop_keep_alive_failed(self, mock_ping_listen_key):
mock_ping_listen_key.side_effect = (lambda *args, **kwargs:
self._create_return_value_and_unlock_test_with_event(False))
self.data_source._current_listen_key = self.listen_key
# Simulate LISTEN_KEY_KEEP_ALIVE_INTERVAL reached
self.data_source._last_listen_key_ping_ts = 0
self.listening_task = self.ev_loop.create_task(self.data_source._manage_listen_key_task_loop())
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(self._is_logged("ERROR", "Error occurred renewing listen key ..."))
self.assertIsNone(self.data_source._current_listen_key)
self.assertFalse(self.data_source._listen_key_initialized_event.is_set())
@patch("hummingbot.connector.exchange.binance.binance_api_user_stream_data_source.BinanceAPIUserStreamDataSource."
"_ping_listen_key",
new_callable=AsyncMock)
def test_manage_listen_key_task_loop_keep_alive_successful(self, mock_ping_listen_key):
mock_ping_listen_key.side_effect = (lambda *args, **kwargs:
self._create_return_value_and_unlock_test_with_event(True))
# Simulate LISTEN_KEY_KEEP_ALIVE_INTERVAL reached
self.data_source._current_listen_key = self.listen_key
self.data_source._listen_key_initialized_event.set()
self.data_source._last_listen_key_ping_ts = 0
self.listening_task = self.ev_loop.create_task(self.data_source._manage_listen_key_task_loop())
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(self._is_logged("INFO", f"Refreshed listen key {self.listen_key}."))
self.assertGreater(self.data_source._last_listen_key_ping_ts, 0)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
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.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = {
"listenKey": self.listen_key
}
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, self._user_update_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(json.loads(self._user_update_event()), msg)
mock_ws.return_value.ping.assert_called()
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_does_not_queue_empty_payload(self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = {
"listenKey": self.listen_key
}
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, "")
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())
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_connection_failed(self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = {
"listenKey": self.listen_key
}
mock_api.post(regex_url, body=json.dumps(mock_response))
mock_ws.side_effect = lambda *arg, **kwars: self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR."))
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue)
)
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged("ERROR",
"Unexpected error while listening to user stream. Retrying after 5 seconds..."))
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_iter_message_throws_exception(self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.BINANCE_USER_STREAM_PATH_URL, domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response = {
"listenKey": self.listen_key
}
mock_api.post(regex_url, body=json.dumps(mock_response))
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive.side_effect = (lambda *args, **kwargs:
self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR")))
mock_ws.close.return_value = None
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue)
)
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error while listening to user stream. Retrying after 5 seconds..."))
class TestGateIoAPIUserStreamDataSource(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
gate_io_auth = GateIoAuth(api_key="someKey", secret_key="someSecret")
self.data_source = GateIoAPIUserStreamDataSource(gate_io_auth, trading_pairs=[self.trading_pair])
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(asyncio.wait_for(coroutine, timeout))
return ret
def get_user_trades_mock(self) -> Dict:
user_trades = {
"time": 1637764970,
"channel": "spot.usertrades",
"event": "update",
"result": [
{
"id": 2217816329,
"user_id": 5774224,
"order_id": "96780687179",
"currency_pair": "ETH_USDT",
"create_time": 1637764970,
"create_time_ms": "1637764970928.48",
"side": "buy",
"amount": "0.005",
"role": "maker",
"price": "4191.1",
"fee": "0.000009",
"fee_currency": "ETH",
"point_fee": "0",
"gt_fee": "0",
"text": "t-HBOT-B-EHUT1637764969004024",
}
],
}
return user_trades
def get_user_orders_mock(self) -> Dict:
user_orders = {
"time": 1605175506,
"channel": "spot.orders",
"event": "update",
"result": [
{
"id": "30784435",
"user": 123456,
"text": "t-abc",
"create_time": "1605175506",
"create_time_ms": "1605175506123",
"update_time": "1605175506",
"update_time_ms": "1605175506123",
"event": "put",
"currency_pair": f"{self.base_asset}_{self.quote_asset}",
"type": "limit",
"account": "spot",
"side": "sell",
"amount": "1",
"price": "10001",
"time_in_force": "gtc",
"left": "1",
"filled_total": "0",
"fee": "0",
"fee_currency": "USDT",
"point_fee": "0",
"gt_fee": "0",
"gt_discount": True,
"rebated_fee": "0",
"rebated_fee_currency": "USDT",
}
],
}
return user_orders
def get_user_balance_mock(self) -> Dict:
user_balance = {
"time": 1605248616,
"channel": "spot.balances",
"event": "update",
"result": [
{
"timestamp": "1605248616",
"timestamp_ms": "1605248616123",
"user": "******",
"currency": self.base_asset,
"change": "100",
"total": "1032951.325075926",
"available": "1022943.325075926",
}
],
}
return user_balance
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_user_trades(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_user_stream(self.ev_loop, output_queue))
resp = self.get_user_trades_mock()
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(resp))
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
resp = self.get_user_orders_mock()
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(resp))
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
resp = self.get_user_balance_mock()
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(resp))
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertEqual(ret, resp)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_user_stream_skips_subscribe_unsubscribe_messages_updates_last_recv_time(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
resp = {"time": 1632223851, "channel": "spot.usertrades", "event": "subscribe", "result": {"status": "success"}}
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(resp))
resp = {
"time": 1632223851,
"channel": "spot.usertrades",
"event": "unsubscribe",
"result": {"status": "success"},
}
self.mocking_assistant.add_websocket_aiohttp_message(ws_connect_mock.return_value, json.dumps(resp))
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_user_stream(self.ev_loop, output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertTrue(output_queue.empty())
np.testing.assert_allclose([time.time()], self.data_source.last_recv_time, rtol=1)
class TestGateIoAPIOrderBookDataSource(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.data_source = GateIoAPIOrderBookDataSource(self.throttler, trading_pairs=[self.trading_pair])
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(asyncio.wait_for(coroutine, timeout))
return ret
def get_last_trade_instance_data_mock(self) -> List:
last_trade_instance_data = [
{
"currency_pair": f"{self.base_asset}_{self.quote_asset}",
"last": "0.2959",
"lowest_ask": "0.295918",
"highest_bid": "0.295898",
"change_percentage": "-1.72",
"base_volume": "78497066.828007",
"quote_volume": "23432064.936692",
"high_24h": "0.309372",
"low_24h": "0.286827",
}
]
return last_trade_instance_data
@staticmethod
def get_order_book_data_mock() -> Dict:
order_book_data = {
"id": 1890172054,
"current": 1630644717528,
"update": 1630644716786,
"asks": [
["0.298705", "5020"]
],
"bids": [
["0.298642", "2703.17"]
]
}
return order_book_data
def get_trade_data_mock(self) -> Dict:
trade_data = {
"time": 1606292218,
"channel": "spot.trades",
"event": "update",
"result": {
"id": 309143071,
"create_time": 1606292218,
"create_time_ms": "1606292218213.4578",
"side": "sell",
"currency_pair": f"{self.base_asset}_{self.quote_asset}",
"amount": "16.4700000000",
"price": "0.4705000000"
}
}
return trade_data
def get_order_book_update_mock(self) -> Dict:
ob_update = {
"time": 1606294781,
"channel": "spot.order_book_update",
"event": "update",
"result": {
"t": 1606294781123,
"e": "depthUpdate",
"E": 1606294781,
"s": f"{self.base_asset}_{self.quote_asset}",
"U": 48776301,
"u": 48776306,
"b": [
[
"19137.74",
"0.0001"
],
],
"a": [
[
"19137.75",
"0.6135"
]
]
}
}
return ob_update
def get_order_book_snapshot_mock(self) -> Dict:
ob_snapshot = {
"time": 1606295412,
"channel": "spot.order_book",
"event": "update",
"result": {
"t": 1606295412123,
"lastUpdateId": 48791820,
"s": f"{self.base_asset}_{self.quote_asset}",
"bids": [
[
"19079.55",
"0.0195"
],
],
"asks": [
[
"19080.24",
"0.1638"
],
]
}
}
return ob_snapshot
@aioresponses()
def test_get_last_trade_instance(self, mock_api):
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.TICKER_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
resp = self.get_last_trade_instance_data_mock()
mock_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
coroutine=GateIoAPIOrderBookDataSource.get_last_traded_prices(trading_pairs=[self.trading_pair])
)
self.assertEqual(ret[self.trading_pair], Decimal(resp[0]["last"]))
@aioresponses()
def test_fetch_trading_pairs(self, mock_api):
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.SYMBOL_PATH_URL}"
resp = [
{
"id": f"{self.base_asset}_{self.quote_asset}"
},
{
"id": "SOME_PAIR"
}
]
mock_api.get(url, body=json.dumps(resp))
ret = self.async_run_with_timeout(coroutine=GateIoAPIOrderBookDataSource.fetch_trading_pairs())
self.assertTrue(self.trading_pair in ret)
self.assertTrue("SOME-PAIR" in ret)
@patch("hummingbot.connector.exchange.gate_io.gate_io_utils.retry_sleep_time")
@aioresponses()
def test_get_order_book_data_raises(self, retry_sleep_time_mock, mock_api):
retry_sleep_time_mock.side_effect = lambda *args, **kwargs: 0
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.ORDER_BOOK_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
resp = ""
for _ in range(CONSTANTS.API_MAX_RETRIES):
mock_api.get(regex_url, body=json.dumps(resp), status=500)
with self.assertRaises(IOError):
self.async_run_with_timeout(
coroutine=GateIoAPIOrderBookDataSource.get_order_book_data(self.trading_pair)
)
@aioresponses()
def test_get_order_book_data(self, mock_api):
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.ORDER_BOOK_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
resp = self.get_order_book_data_mock()
mock_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(
coroutine=GateIoAPIOrderBookDataSource.get_order_book_data(self.trading_pair)
)
self.assertEqual(resp, ret) # shallow comparison is ok
@aioresponses()
def test_get_new_order_book(self, mock_api):
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.ORDER_BOOK_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
resp = self.get_order_book_data_mock()
mock_api.get(regex_url, body=json.dumps(resp))
ret = self.async_run_with_timeout(coroutine=self.data_source.get_new_order_book(self.trading_pair))
self.assertTrue(isinstance(ret, OrderBook))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
resp = self.get_trade_data_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(resp)
)
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_trades(self.ev_loop, output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(websocket_mock=ws_connect_mock.return_value)
self.assertTrue(not output_queue.empty())
self.assertTrue(isinstance(output_queue.get_nowait(), OrderBookMessage))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_trades_skips_subscribe_unsubscribe_messages(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
resp = {"time": 1632223851, "channel": "spot.usertrades", "event": "subscribe", "result": {"status": "success"}}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(resp)
)
resp = {
"time": 1632223851, "channel": "spot.usertrades", "event": "unsubscribe", "result": {"status": "success"}
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(resp)
)
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_trades(self.ev_loop, output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertTrue(output_queue.empty())
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_update(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
resp = self.get_order_book_update_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(resp)
)
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_order_book_diffs(self.ev_loop, output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(websocket_mock=ws_connect_mock.return_value)
self.assertTrue(not output_queue.empty())
self.assertTrue(isinstance(output_queue.get_nowait(), OrderBookMessage))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_snapshot(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
resp = self.get_order_book_snapshot_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(resp)
)
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_order_book_diffs(self.ev_loop, output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(websocket_mock=ws_connect_mock.return_value)
self.assertTrue(not output_queue.empty())
self.assertTrue(isinstance(output_queue.get_nowait(), OrderBookMessage))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_snapshot_skips_subscribe_unsubscribe_messages(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
resp = {"time": 1632223851, "channel": "spot.usertrades", "event": "subscribe", "result": {"status": "success"}}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(resp)
)
resp = {
"time": 1632223851, "channel": "spot.usertrades", "event": "unsubscribe", "result": {"status": "success"}
}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, json.dumps(resp)
)
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_order_book_diffs(self.ev_loop, output_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertTrue(output_queue.empty())
@aioresponses()
def test_listen_for_order_book_snapshots(self, mock_api):
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.ORDER_BOOK_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
resp = self.get_order_book_data_mock()
mock_api.get(regex_url, body=json.dumps(resp))
output_queue = asyncio.Queue()
self.ev_loop.create_task(self.data_source.listen_for_order_book_snapshots(self.ev_loop, output_queue))
ret = self.async_run_with_timeout(coroutine=output_queue.get())
self.assertTrue(isinstance(ret, OrderBookMessage))
class MexcAPIUserStreamDataSourceTests(TestCase):
# the level is required to receive logs from the data source loger
level = 0
def setUp(self) -> None:
super().setUp()
self.uid = '001'
self.api_key = 'testAPIKey'
self.secret = 'testSecret'
self.account_id = 528
self.username = '******'
self.oms_id = 1
self.log_records = []
self.listening_task = None
self.ev_loop = asyncio.get_event_loop()
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
auth_assistant = MexcAuth(api_key=self.api_key, secret_key=self.secret)
self.data_source = MexcAPIUserStreamDataSource(throttler,
auth_assistant)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def async_run_with_timeout(self, coroutine: Awaitable, timeout: float = 1):
ret = self.ev_loop.run_until_complete(
asyncio.wait_for(coroutine, timeout))
return ret
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _raise_exception(self, exception_class):
raise exception_class
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listening_process_authenticates_and_subscribes_to_events(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock(
)
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(asyncio.get_event_loop(),
messages))
# Add a dummy message for the websocket to read and include in the "messages" queue
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value,
ujson.dumps({'channel': 'push.personal.order'}))
first_received_message = self.async_run_with_timeout(messages.get())
self.assertEqual({'channel': 'push.personal.order'},
first_received_message)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listening_process_canceled_when_cancel_exception_during_initialization(
self, ws_connect_mock):
messages = asyncio.Queue()
ws_connect_mock.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
self.listening_task = asyncio.get_event_loop().create_task(
self.data_source.listen_for_user_stream(
asyncio.get_event_loop(), messages))
self.async_run_with_timeout(self.listening_task)
class NdaxAPIOrderBookDataSourceUnitTests(unittest.TestCase):
# logging.Level required to receive logs from the data source logger
level = 0
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.base_asset = "COINALPHA"
cls.quote_asset = "HBOT"
cls.trading_pair = f"{cls.base_asset}-{cls.quote_asset}"
cls.instrument_id = 1
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = NdaxAPIOrderBookDataSource(
throttler=self.throttler, trading_pairs=[self.trading_pair])
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.data_source._trading_pair_id_map.clear()
self.mocking_assistant = NetworkMockingAssistant()
def tearDown(self) -> None:
self.listening_task and self.listening_task.cancel()
super().tearDown()
def handle(self, record):
self.log_records.append(record)
def simulate_trading_pair_ids_initialized(self):
self.data_source._trading_pair_id_map.update(
{self.trading_pair: self.instrument_id})
def _raise_exception(self, exception_class):
raise exception_class
def _is_logged(self, log_level: str, message: str) -> bool:
return any(
record.levelname == log_level and record.getMessage() == message
for record in self.log_records)
def _subscribe_level_2_response(self):
resp = {
"m":
1,
"i":
2,
"n":
"SubscribeLevel2",
"o":
"[[93617617, 1, 1626788175000, 0, 37800.0, 1, 37750.0, 1, 0.015, 0],[93617617, 1, 1626788175000, 0, 37800.0, 1, 37751.0, 1, 0.015, 1]]"
}
return ujson.dumps(resp)
def _orderbook_update_event(self):
resp = {
"m":
3,
"i":
3,
"n":
"Level2UpdateEvent",
"o":
"[[93617618, 1, 1626788175001, 0, 37800.0, 1, 37740.0, 1, 0.015, 0]]"
}
return ujson.dumps(resp)
@patch("aiohttp.ClientSession.get")
def test_init_trading_pair_ids(self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
mock_response: List[Any] = [{
"Product1Symbol": self.base_asset,
"Product2Symbol": self.quote_asset,
"InstrumentId": self.instrument_id,
"SessionStatus": "Running"
}, {
"Product1Symbol": "ANOTHER_ACTIVE",
"Product2Symbol": "MARKET",
"InstrumentId": 2,
"SessionStatus": "Running"
}, {
"Product1Symbol": "NOT_ACTIVE",
"Product2Symbol": "MARKET",
"InstrumentId": 3,
"SessionStatus": "Stopped"
}]
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
self.ev_loop.run_until_complete(
self.data_source.init_trading_pair_ids())
self.assertEqual(2, len(self.data_source._trading_pair_id_map))
self.assertEqual(
1, self.data_source._trading_pair_id_map[self.trading_pair])
self.assertEqual(
2, self.data_source._trading_pair_id_map["ANOTHER_ACTIVE-MARKET"])
@patch("aiohttp.ClientSession.get")
def test_get_last_traded_prices(self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
self.simulate_trading_pair_ids_initialized()
mock_response: Dict[Any] = {"LastTradedPx": 1.0}
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
results = self.ev_loop.run_until_complete(
asyncio.gather(
self.data_source.get_last_traded_prices([self.trading_pair])))
results: Dict[str, Any] = results[0]
self.assertEqual(results[self.trading_pair],
mock_response["LastTradedPx"])
@patch("aiohttp.ClientSession.get")
def test_fetch_trading_pairs(self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
self.simulate_trading_pair_ids_initialized()
mock_response: List[Any] = [{
"Product1Symbol": self.base_asset,
"Product2Symbol": self.quote_asset,
"InstrumentId": self.instrument_id,
"SessionStatus": "Running"
}, {
"Product1Symbol": "ANOTHER_ACTIVE",
"Product2Symbol": "MARKET",
"InstrumentId": 2,
"SessionStatus": "Running"
}, {
"Product1Symbol": "NOT_ACTIVE",
"Product2Symbol": "MARKET",
"InstrumentId": 3,
"SessionStatus": "Stopped"
}]
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
results: List[str] = self.ev_loop.run_until_complete(
self.data_source.fetch_trading_pairs())
self.assertTrue(self.trading_pair in results)
self.assertTrue("ANOTHER_ACTIVE-MARKET" in results)
self.assertFalse("NOT_ACTIVE-MARKET" in results)
@patch("aiohttp.ClientSession.get")
def test_fetch_trading_pairs_with_error_status_in_response(self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
mock_response = {}
self.mocking_assistant.add_http_response(mock_api, 100, mock_response)
result = self.ev_loop.run_until_complete(
self.data_source.fetch_trading_pairs())
self.assertEqual(0, len(result))
@patch("aiohttp.ClientSession.get")
def test_get_order_book_data(self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
self.simulate_trading_pair_ids_initialized()
mock_response: List[List[Any]] = [
# mdUpdateId, accountId, actionDateTime, actionType, lastTradePrice, orderId, price, productPairCode, quantity, side
[
93617617, 1, 1626788175416, 0, 37813.22, 1, 37750.6, 1,
0.014698, 0
]
]
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
results = self.ev_loop.run_until_complete(
asyncio.gather(
self.data_source.get_order_book_data(self.trading_pair)))
result = results[0]
self.assertTrue("data" in result)
self.assertGreaterEqual(len(result["data"]), 0)
self.assertEqual(NdaxOrderBookEntry(*mock_response[0]),
result["data"][0])
@patch("aiohttp.ClientSession.get")
def test_get_order_book_data_raises_exception_when_response_has_error_code(
self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
self.simulate_trading_pair_ids_initialized()
mock_response = {"Erroneous response"}
self.mocking_assistant.add_http_response(mock_api, 100, mock_response)
with self.assertRaises(IOError) as context:
self.ev_loop.run_until_complete(
self.data_source.get_order_book_data(self.trading_pair))
self.assertEqual(
str(context.exception),
f"Error fetching OrderBook for {self.trading_pair} "
f"at {CONSTANTS.ORDER_BOOK_URL}. "
f"HTTP {100}. Response: {mock_response}")
@patch("aiohttp.ClientSession.get")
def test_get_new_order_book(self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
self.simulate_trading_pair_ids_initialized()
mock_response: List[List[Any]] = [
# mdUpdateId, accountId, actionDateTime, actionType, lastTradePrice, orderId, price, productPairCode, quantity, side
[93617617, 1, 1626788175416, 0, 37800.0, 1, 37750.0, 1, 0.015, 0],
[93617617, 1, 1626788175416, 0, 37800.0, 1, 37751.0, 1, 0.015, 1]
]
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
results = self.ev_loop.run_until_complete(
asyncio.gather(
self.data_source.get_new_order_book(self.trading_pair)))
result: OrderBook = results[0]
self.assertTrue(type(result) == OrderBook)
self.assertEqual(result.snapshot_uid, 0)
@patch("aiohttp.ClientSession.get")
def test_get_instrument_ids(self, mock_api):
self.mocking_assistant.configure_http_request_mock(mock_api)
mock_response: List[Any] = [{
"Product1Symbol": self.base_asset,
"Product2Symbol": self.quote_asset,
"InstrumentId": self.instrument_id,
"SessionStatus": "Running",
}]
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
results = self.ev_loop.run_until_complete(
asyncio.gather(self.data_source.get_instrument_ids()))
result: Dict[str, Any] = results[0]
self.assertEqual(
1, self.data_source._trading_pair_id_map[self.trading_pair])
self.assertEqual(result[self.trading_pair], self.instrument_id)
@patch(
"hummingbot.connector.exchange.ndax.ndax_api_order_book_data_source.NdaxAPIOrderBookDataSource._sleep"
)
@patch("aiohttp.ClientSession.get")
def test_listen_for_snapshots_cancelled_when_fetching_snapshot(
self, mock_api, mock_sleep):
mock_api.side_effect = asyncio.CancelledError
self.simulate_trading_pair_ids_initialized()
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
self.assertEqual(msg_queue.qsize(), 0)
@patch(
"hummingbot.connector.exchange.ndax.ndax_api_order_book_data_source.NdaxAPIOrderBookDataSource._sleep"
)
@patch("aiohttp.ClientSession.get")
def test_listen_for_snapshots_logs_exception_when_fetching_snapshot(
self, mock_api, mock_sleep):
# the queue and the division by zero error are used just to synchronize the test
sync_queue = deque()
sync_queue.append(1)
self.simulate_trading_pair_ids_initialized()
mock_api.side_effect = Exception
mock_sleep.side_effect = lambda delay: 1 / 0 if len(
sync_queue) == 0 else sync_queue.pop()
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(ZeroDivisionError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
self.assertEqual(msg_queue.qsize(), 0)
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error occured listening for orderbook snapshots. Retrying in 5 secs..."
))
@patch(
"hummingbot.connector.exchange.ndax.ndax_api_order_book_data_source.NdaxAPIOrderBookDataSource._sleep"
)
@patch("aiohttp.ClientSession.get")
def test_listen_for_snapshots_successful(self, mock_api, mock_sleep):
self.mocking_assistant.configure_http_request_mock(mock_api)
# the queue and the division by zero error are used just to synchronize the test
sync_queue = deque()
sync_queue.append(1)
mock_response: List[List[Any]] = [
# mdUpdateId, accountId, actionDateTime, actionType, lastTradePrice, orderId, price, productPairCode, quantity, side
[93617617, 1, 1626788175416, 0, 37800.0, 1, 37750.0, 1, 0.015, 0],
[93617617, 1, 1626788175416, 0, 37800.0, 1, 37751.0, 1, 0.015, 1],
]
self.mocking_assistant.add_http_response(mock_api, 200, mock_response)
self.simulate_trading_pair_ids_initialized()
mock_sleep.side_effect = lambda delay: 1 / 0 if len(
sync_queue) == 0 else sync_queue.pop()
msg_queue: asyncio.Queue = asyncio.Queue()
with self.assertRaises(ZeroDivisionError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_snapshots(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
self.assertEqual(msg_queue.qsize(), 1)
snapshot_msg: OrderBookMessage = msg_queue.get_nowait()
self.assertEqual(snapshot_msg.update_id, 0)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_cancelled_when_subscribing(
self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.send_json.side_effect = asyncio.CancelledError()
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, self._subscribe_level_2_response())
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, self._orderbook_update_event())
self.simulate_trading_pair_ids_initialized()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_cancelled_when_listening(
self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive.side_effect = lambda: (
self._raise_exception(asyncio.CancelledError))
self.simulate_trading_pair_ids_initialized()
with self.assertRaises(asyncio.CancelledError):
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(self.listening_task)
self.assertEqual(msg_queue.qsize(), 0)
@patch("hummingbot.client.hummingbot_application.HummingbotApplication")
@patch(
"hummingbot.connector.exchange.ndax.ndax_api_order_book_data_source.NdaxAPIOrderBookDataSource._sleep"
)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
@patch("aiohttp.ClientSession.get", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_logs_exception(
self, mock_api, mock_ws, *_):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.close.return_value = None
incomplete_resp = {
"m": 1,
"i": 2,
}
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, ujson.dumps(incomplete_resp))
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, self._orderbook_update_event())
self.simulate_trading_pair_ids_initialized()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
self.ev_loop.run_until_complete(msg_queue.get())
self.assertTrue(
self._is_logged("NETWORK",
"Unexpected error with WebSocket connection."))
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_listen_for_order_book_diffs_successful(self, mock_ws):
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.send_json.return_value = None
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, self._subscribe_level_2_response())
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, self._orderbook_update_event())
self.simulate_trading_pair_ids_initialized()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_order_book_diffs(
self.ev_loop, msg_queue))
first_msg = self.ev_loop.run_until_complete(msg_queue.get())
second_msg = self.ev_loop.run_until_complete(msg_queue.get())
self.assertTrue(first_msg.type == OrderBookMessageType.SNAPSHOT)
self.assertTrue(second_msg.type == OrderBookMessageType.DIFF)
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_websocket_connection_creation_raises_cancel_exception(
self, mock_ws):
mock_ws.side_effect = asyncio.CancelledError
with self.assertRaises(asyncio.CancelledError):
asyncio.get_event_loop().run_until_complete(
self.data_source._create_websocket_connection())
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_websocket_connection_creation_raises_exception_after_loging(
self, mock_ws):
mock_ws.side_effect = Exception
with self.assertRaises(Exception):
asyncio.get_event_loop().run_until_complete(
self.data_source._create_websocket_connection())
self.assertTrue(
self._is_logged(
"NETWORK",
"Unexpected error occurred during ndax WebSocket Connection ()"
))
