def setUp(self) -> None: super().setUp() self.log_records = [] self.async_task = None self.mocking_assistant = NetworkMockingAssistant() client_config_map = ClientConfigAdapter(ClientConfigMap()) self.connector = KucoinExchange(client_config_map=client_config_map, kucoin_api_key="", kucoin_passphrase="", kucoin_secret_key="", trading_pairs=[], trading_required=False) self.ob_data_source = KucoinAPIOrderBookDataSource( trading_pairs=[self.trading_pair], connector=self.connector, api_factory=self.connector._web_assistants_factory) self.ob_data_source.logger().setLevel(1) self.ob_data_source.logger().addHandler(self) self.connector._set_trading_pair_symbol_map( bidict({self.trading_pair: self.trading_pair}))
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.ob_data_source = KucoinAPIOrderBookDataSource( self.throttler, [self.trading_pair], self.auth)
def test_trade_event_symbol_transformed_correctly(self, mock_api, ws_connect_mock): base_asset = "WAXP" quote_asset = "USDT" url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PUBLIC_WS_DATA_PATH_URL resp_data = { "data": { "instanceServers": [{ "endpoint": self.ws_endpoint, }], "token": "someToken", } } mock_api.post(url, body=json.dumps(resp_data)) ws_mock = self.mocking_assistant.create_websocket_mock() ws_connect_mock.return_value.__aenter__.return_value = ws_mock data_source = KucoinAPIOrderBookDataSource( self.throttler, [f"_{base_asset}-{quote_asset}"]) received_messages = asyncio.Queue() response = { "type": "message", "topic": "/market/match:WAX-USDT", "subject": "trade.l3match", "data": { "sequence": "1545896669145", "type": "match", "symbol": "WAX-USDT", "side": "buy", "price": "0.08200000000000000000", "size": "0.01022222000000000000", "tradeId": "5c24c5da03aa673885cd67aa", "takerOrderId": "5c24c5d903aa6772d55b371e", "makerOrderId": "5c2187d003aa677bd09d5c93", "time": "1545913818099033203" } } self.mocking_assistant.add_websocket_aiohttp_message( websocket_mock=ws_mock, message=json.dumps(response)) self.listening_task = asyncio.get_event_loop().create_task( data_source.listen_for_trades(asyncio.get_event_loop(), received_messages)) trade_message = self.async_run_with_timeout(received_messages.get()) self.assertEqual(OrderBookMessageType.TRADE, trade_message.type) self.assertEqual(-1, trade_message.update_id) self.assertEqual(response["data"]["tradeId"], trade_message.trade_id) self.assertEqual(f"{base_asset}-{quote_asset}", trade_message.trading_pair)
def test_order_book_diff_symbol_transformed_correctly( self, mock_api, ws_connect_mock): base_asset = "WAXP" quote_asset = "USDT" url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PUBLIC_WS_DATA_PATH_URL resp_data = { "data": { "instanceServers": [{ "endpoint": self.ws_endpoint, }], "token": "someToken", } } mock_api.post(url, body=json.dumps(resp_data)) ws_mock = self.mocking_assistant.create_websocket_mock() ws_connect_mock.return_value.__aenter__.return_value = ws_mock data_source = KucoinAPIOrderBookDataSource( self.throttler, [f"_{base_asset}-{quote_asset}"]) received_messages = asyncio.Queue() diff_response = { "type": "message", "topic": "/market/level2:WAX-USDT", "subject": "trade.l2update", "data": { "sequenceStart": 1545896669105, "sequenceEnd": 1545896669106, "symbol": "WAX-USDT", "changes": { "asks": [["0.1997", "1000", "1545896669105"]], "bids": [["0.1993", "2000", "1545896669106"]] } } } self.mocking_assistant.add_websocket_aiohttp_message( websocket_mock=ws_mock, message=json.dumps(diff_response)) self.listening_task = asyncio.get_event_loop().create_task( data_source.listen_for_order_book_diffs(asyncio.get_event_loop(), received_messages)) diff_message = self.async_run_with_timeout(received_messages.get()) self.assertEqual(OrderBookMessageType.DIFF, diff_message.type) self.assertEqual(diff_response["data"]["sequenceStart"], diff_message.first_update_id) self.assertEqual(f"{base_asset}-{quote_asset}", diff_message.trading_pair)
def _create_order_book_data_source(self) -> OrderBookTrackerDataSource: return KucoinAPIOrderBookDataSource( trading_pairs=self._trading_pairs, connector=self, api_factory=self._web_assistants_factory, domain=self.domain, )
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])
def test_api_get_last_traded_prices(self): prices = self.ev_loop.run_until_complete( KucoinAPIOrderBookDataSource.get_last_traded_prices(["BTC-USDT", "LTC-USDT"])) for key, value in prices.items(): print(f"{key} last_trade_price: {value}") self.assertGreater(prices["BTC-USDT"], 1000) self.assertLess(prices["LTC-USDT"], 1000)
def status_dict(self) -> Dict[str, bool]: return { "symbols_mapping_initialized": KucoinAPIOrderBookDataSource.trading_pair_symbol_map_ready( domain=self._domain), "order_books_initialized": self._order_book_tracker.ready, "account_balance": not self._trading_required or len(self._account_balances) > 0, "trading_rule_initialized": len(self._trading_rules) > 0, "user_stream_initialized": self._user_stream_tracker.data_source.last_recv_time > 0 if self._trading_required else True, }
def __init__(self, throttler: Optional[AsyncThrottler] = None, trading_pairs: Optional[List[str]] = None, auth: Optional[KucoinAuth] = None): super().__init__(KucoinAPIOrderBookDataSource(throttler, trading_pairs, auth), trading_pairs) self._auth = auth self._order_book_diff_stream: asyncio.Queue = asyncio.Queue() self._order_book_snapshot_stream: asyncio.Queue = asyncio.Queue() self._ev_loop: asyncio.AbstractEventLoop = asyncio.get_event_loop() self._saved_message_queues: Dict[str, Deque[KucoinOrderBookMessage]] = defaultdict(lambda: deque(maxlen=1000)) self._active_order_trackers: Dict[str, KucoinActiveOrderTracker] = defaultdict(KucoinActiveOrderTracker)
def __init__(self, trading_pairs: List[str]): super().__init__(KucoinAPIOrderBookDataSource(trading_pairs), trading_pairs) self._order_book_diff_stream: asyncio.Queue = asyncio.Queue() self._order_book_snapshot_stream: asyncio.Queue = asyncio.Queue() self._ev_loop: asyncio.BaseEventLoop = asyncio.get_event_loop() self._saved_message_queues: Dict[ str, Deque[KucoinOrderBookMessage]] = defaultdict( lambda: deque(maxlen=1000)) self._active_order_trackers: Dict[ str, KucoinActiveOrderTracker] = defaultdict(KucoinActiveOrderTracker)
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 test_get_snapshot_raises(self, mock_api): url = CONSTANTS.BASE_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) client = self.ev_loop.run_until_complete( aiohttp.ClientSession().__aenter__()) with self.assertRaises(IOError): self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_snapshot( client, self.trading_pair)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None))
def test_get_snapshot_no_auth(self, mock_api): url = CONSTANTS.BASE_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)) client = aiohttp.ClientSession() ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_snapshot( client, self.trading_pair)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None)) self.assertEqual(ret, resp) # shallow comparison ok
def __init__(self, kucoin_api_key: str, kucoin_passphrase: str, kucoin_secret_key: str, trading_pairs: Optional[List[str]] = None, trading_required: bool = True, domain: str = CONSTANTS.DEFAULT_DOMAIN): self._domain = domain self._time_synchronizer = TimeSynchronizer() super().__init__() self._auth = KucoinAuth( api_key=kucoin_api_key, passphrase=kucoin_passphrase, secret_key=kucoin_secret_key, time_provider=self._time_synchronizer) self._throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS) self._api_factory = web_utils.build_api_factory( throttler=self._throttler, time_synchronizer=self._time_synchronizer, domain=self._domain, auth=self._auth) self._last_poll_timestamp = 0 self._last_timestamp = 0 self._trading_pairs = trading_pairs self._order_book_tracker = OrderBookTracker( data_source=KucoinAPIOrderBookDataSource( trading_pairs=trading_pairs, domain=self._domain, api_factory=self._api_factory, throttler=self._throttler, time_synchronizer=self._time_synchronizer), trading_pairs=trading_pairs, domain=self._domain) self._user_stream_tracker = UserStreamTracker( data_source=KucoinAPIUserStreamDataSource( domain=self._domain, api_factory=self._api_factory, throttler=self._throttler)) self._poll_notifier = asyncio.Event() self._status_polling_task = None self._user_stream_tracker_task = None self._user_stream_event_listener_task = None self._trading_rules_polling_task = None self._trading_fees_polling_task = None self._trading_required = trading_required self._trading_rules = {} self._trading_fees = {} self._order_tracker: ClientOrderTracker = ClientOrderTracker(connector=self)
def test_get_last_traded_prices(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL resp = { "data": { "ticker": [{ "symbol": self.trading_pair, "last": 100.0, }] } } mock_api.get(url, body=json.dumps(resp)) ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_last_traded_prices( [self.trading_pair])) self.assertEqual(ret[self.trading_pair], 100)
def test_fetch_trading_pairs(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.EXCHANGE_INFO_PATH_URL resp = { "data": [{ "symbol": self.trading_pair, "enableTrading": True, }, { "symbol": "SOME-PAIR", "enableTrading": False, }] } mock_api.get(url, body=json.dumps(resp)) ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.fetch_trading_pairs()) self.assertEqual(len(ret), 1) self.assertEqual(ret[0], self.trading_pair)
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)
class TestKucoinAPIOrderBookDataSource(KucoinTestProviders, unittest.TestCase): 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.ob_data_source = KucoinAPIOrderBookDataSource( self.throttler, [self.trading_pair], self.auth) @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): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL resp = { "data": { "ticker": [{ "symbol": self.trading_pair, "last": 100.0, }] } } mock_api.get(url, body=json.dumps(resp)) ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_last_traded_prices( [self.trading_pair])) self.assertEqual(ret[self.trading_pair], 100) @aioresponses() def test_fetch_trading_pairs(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.EXCHANGE_INFO_PATH_URL resp = { "data": [{ "symbol": self.trading_pair, "enableTrading": True, }, { "symbol": "SOME-PAIR", "enableTrading": False, }] } mock_api.get(url, body=json.dumps(resp)) ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.fetch_trading_pairs()) self.assertEqual(len(ret), 1) self.assertEqual(ret[0], self.trading_pair) @aioresponses() def test_get_snapshot_raises(self, mock_api): url = CONSTANTS.BASE_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) client = self.ev_loop.run_until_complete( aiohttp.ClientSession().__aenter__()) with self.assertRaises(IOError): self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_snapshot( client, self.trading_pair)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None)) @aioresponses() def test_get_snapshot_no_auth(self, mock_api): url = CONSTANTS.BASE_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)) client = aiohttp.ClientSession() ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_snapshot( client, self.trading_pair)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None)) self.assertEqual(ret, resp) # shallow comparison ok @aioresponses() def test_get_snapshot_with_auth(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.SNAPSHOT_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)) client = self.ev_loop.run_until_complete( aiohttp.ClientSession().__aenter__()) ret = self.async_run_with_timeout( coroutine=self.ob_data_source.get_snapshot( client, self.trading_pair, self.auth, self.throttler)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None)) self.assertEqual(ret, resp) # shallow comparison ok @aioresponses() def test_get_new_order_book(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.SNAPSHOT_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)) self.assertTrue(isinstance(ret, OrderBook))
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 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" def setUp(self) -> None: super().setUp() self.log_records = [] self.async_task = None self.mocking_assistant = NetworkMockingAssistant() client_config_map = ClientConfigAdapter(ClientConfigMap()) self.connector = KucoinExchange(client_config_map=client_config_map, kucoin_api_key="", kucoin_passphrase="", kucoin_secret_key="", trading_pairs=[], trading_required=False) self.ob_data_source = KucoinAPIOrderBookDataSource( trading_pairs=[self.trading_pair], connector=self.connector, api_factory=self.connector._web_assistants_factory) self.ob_data_source.logger().setLevel(1) self.ob_data_source.logger().addHandler(self) self.connector._set_trading_pair_symbol_map( bidict({self.trading_pair: self.trading_pair})) def tearDown(self) -> None: self.async_task and self.async_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 @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_new_order_book(self, mock_api): url = web_utils.public_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.public_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.public_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.public_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.public_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[ self.ob_data_source._trade_messages_queue_key] = 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[ self.ob_data_source._trade_messages_queue_key] = 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[ self.ob_data_source._trade_messages_queue_key] = 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)) 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[ self.ob_data_source._diff_messages_queue_key] = 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[ self.ob_data_source._diff_messages_queue_key] = 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[ self.ob_data_source._diff_messages_queue_key] = 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.public_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.public_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.public_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 TestKucoinAPIOrderBookDataSource(KucoinTestProviders, unittest.TestCase): def setUp(self) -> None: super().setUp() self.auth = KucoinAuth(self.api_key, self.api_passphrase, self.api_secret_key) self.ob_data_source = KucoinAPIOrderBookDataSource( self.throttler, [self.trading_pair], self.auth) @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): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL resp = { "data": { "ticker": [{ "symbol": self.trading_pair, "last": 100.0, }] } } mock_api.get(url, body=json.dumps(resp)) ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_last_traded_prices( [self.trading_pair])) self.assertEqual(ret[self.trading_pair], 100) @aioresponses() def test_fetch_trading_pairs(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.EXCHANGE_INFO_PATH_URL resp = { "data": [{ "symbol": self.trading_pair, "enableTrading": True, }, { "symbol": "SOME-PAIR", "enableTrading": False, }] } mock_api.get(url, body=json.dumps(resp)) ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.fetch_trading_pairs()) self.assertEqual(len(ret), 1) self.assertEqual(ret[0], self.trading_pair) @aioresponses() def test_get_snapshot_raises(self, mock_api): url = CONSTANTS.BASE_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) client = self.ev_loop.run_until_complete( aiohttp.ClientSession().__aenter__()) with self.assertRaises(IOError): self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_snapshot( client, self.trading_pair)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None)) @aioresponses() def test_get_snapshot_no_auth(self, mock_api): url = CONSTANTS.BASE_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)) client = aiohttp.ClientSession() ret = self.async_run_with_timeout( coroutine=KucoinAPIOrderBookDataSource.get_snapshot( client, self.trading_pair)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None)) self.assertEqual(ret, resp) # shallow comparison ok @aioresponses() def test_get_snapshot_with_auth(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.SNAPSHOT_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)) client = self.ev_loop.run_until_complete( aiohttp.ClientSession().__aenter__()) ret = self.async_run_with_timeout( coroutine=self.ob_data_source.get_snapshot( client, self.trading_pair, self.auth, self.throttler)) self.ev_loop.run_until_complete(client.__aexit__(None, None, None)) self.assertEqual(ret, resp) # shallow comparison ok @aioresponses() def test_get_new_order_book(self, mock_api): url = CONSTANTS.BASE_PATH_URL + CONSTANTS.SNAPSHOT_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)) self.assertTrue(isinstance(ret, OrderBook)) @aioresponses() @patch("aiohttp.client.ClientSession.ws_connect") def test_order_book_diff_symbol_transformed_correctly( self, mock_api, ws_connect_mock): base_asset = "WAXP" quote_asset = "USDT" url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PUBLIC_WS_DATA_PATH_URL resp_data = { "data": { "instanceServers": [{ "endpoint": self.ws_endpoint, }], "token": "someToken", } } mock_api.post(url, body=json.dumps(resp_data)) ws_mock = self.mocking_assistant.create_websocket_mock() ws_connect_mock.return_value.__aenter__.return_value = ws_mock data_source = KucoinAPIOrderBookDataSource( self.throttler, [f"_{base_asset}-{quote_asset}"]) received_messages = asyncio.Queue() diff_response = { "type": "message", "topic": "/market/level2:WAX-USDT", "subject": "trade.l2update", "data": { "sequenceStart": 1545896669105, "sequenceEnd": 1545896669106, "symbol": "WAX-USDT", "changes": { "asks": [["0.1997", "1000", "1545896669105"]], "bids": [["0.1993", "2000", "1545896669106"]] } } } self.mocking_assistant.add_websocket_aiohttp_message( websocket_mock=ws_mock, message=json.dumps(diff_response)) self.listening_task = asyncio.get_event_loop().create_task( data_source.listen_for_order_book_diffs(asyncio.get_event_loop(), received_messages)) diff_message = self.async_run_with_timeout(received_messages.get()) self.assertEqual(OrderBookMessageType.DIFF, diff_message.type) self.assertEqual(diff_response["data"]["sequenceStart"], diff_message.first_update_id) self.assertEqual(f"{base_asset}-{quote_asset}", diff_message.trading_pair) @aioresponses() @patch("aiohttp.client.ClientSession.ws_connect") def test_trade_event_symbol_transformed_correctly(self, mock_api, ws_connect_mock): base_asset = "WAXP" quote_asset = "USDT" url = CONSTANTS.BASE_PATH_URL + CONSTANTS.PUBLIC_WS_DATA_PATH_URL resp_data = { "data": { "instanceServers": [{ "endpoint": self.ws_endpoint, }], "token": "someToken", } } mock_api.post(url, body=json.dumps(resp_data)) ws_mock = self.mocking_assistant.create_websocket_mock() ws_connect_mock.return_value.__aenter__.return_value = ws_mock data_source = KucoinAPIOrderBookDataSource( self.throttler, [f"_{base_asset}-{quote_asset}"]) received_messages = asyncio.Queue() response = { "type": "message", "topic": "/market/match:WAX-USDT", "subject": "trade.l3match", "data": { "sequence": "1545896669145", "type": "match", "symbol": "WAX-USDT", "side": "buy", "price": "0.08200000000000000000", "size": "0.01022222000000000000", "tradeId": "5c24c5da03aa673885cd67aa", "takerOrderId": "5c24c5d903aa6772d55b371e", "makerOrderId": "5c2187d003aa677bd09d5c93", "time": "1545913818099033203" } } self.mocking_assistant.add_websocket_aiohttp_message( websocket_mock=ws_mock, message=json.dumps(response)) self.listening_task = asyncio.get_event_loop().create_task( data_source.listen_for_trades(asyncio.get_event_loop(), received_messages)) trade_message = self.async_run_with_timeout(received_messages.get()) self.assertEqual(OrderBookMessageType.TRADE, trade_message.type) self.assertEqual(-1, trade_message.update_id) self.assertEqual(response["data"]["tradeId"], trade_message.trade_id) self.assertEqual(f"{base_asset}-{quote_asset}", trade_message.trading_pair)