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 setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task: Optional[asyncio.Task] = None
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.mock_time_provider = MagicMock()
self.mock_time_provider.time.return_value = 1000
self.auth = KucoinAuth(self.api_key,
self.api_passphrase,
self.api_secret_key,
time_provider=self.mock_time_provider)
self.time_synchronizer = TimeSynchronizer()
self.time_synchronizer.add_time_offset_ms_sample(0)
self.api_factory = web_utils.build_api_factory(
throttler=self.throttler,
time_synchronizer=self.time_synchronizer,
auth=self.auth)
self.data_source = KucoinAPIUserStreamDataSource(
throttler=self.throttler, api_factory=self.api_factory)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
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)))
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])
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)
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 setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
altmarkets_auth = AltmarketsAuth(api_key="someKey",
secret_key="someSecret")
self.data_source = AltmarketsAPIUserStreamDataSource(
AsyncThrottler(Constants.RATE_LIMITS),
altmarkets_auth=altmarkets_auth,
trading_pairs=[self.trading_pair])
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
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 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 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 setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = MexcAPIOrderBookDataSource(throttler=self.throttler, trading_pairs=[self.trading_pair])
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.websocket = CryptoComWebsocket(auth=self.auth)
self.websocket.logger().setLevel(1)
self.websocket.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.async_task: Optional[asyncio.Task] = None
self.resume_test_event = asyncio.Event()
def setUp(self) -> None:
super().setUp()
auth = CoinbaseProAuth(api_key="SomeAPIKey", secret_key="shht", passphrase="SomePassPhrase")
self.mocking_assistant = NetworkMockingAssistant()
web_assistants_factory = build_coinbase_pro_web_assistant_factory(auth)
self.data_source = CoinbaseProAPIUserStreamDataSource(
trading_pairs=[self.trading_pair], web_assistants_factory=web_assistants_factory
)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.log_records = []
self.async_tasks: List[asyncio.Task] = []
def setUp(self) -> None:
super().setUp()
self.log_records = []
throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.websocket = MexcWebSocketAdaptor(throttler)
self.websocket.logger().setLevel(1)
self.websocket.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.async_task: Optional[asyncio.Task] = None
self.resume_test_event = asyncio.Event()
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.async_task: Optional[asyncio.Task] = None
self.data_source = DydxPerpetualUserStreamDataSource(self.dydx_auth)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mocking_assistant = NetworkMockingAssistant()
self.resume_test_event = asyncio.Event()
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
api_factory = WebAssistantsFactory()
self.data_source = GateIoAPIOrderBookDataSource(
self.throttler, trading_pairs=[self.trading_pair], api_factory=api_factory
)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.log_records = []
self.async_tasks: List[asyncio.Task] = []
def setUp(self) -> None:
super().setUp()
self.ev_loop = asyncio.get_event_loop()
self.mocking_assistant = NetworkMockingAssistant()
self.listening_task = None
self.api_factory = None
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.tracker = AscendExUserStreamTracker(
ascend_ex_auth=AscendExAuth(api_key="testAPIKey",
secret_key="testSecret"),
api_factory=self.api_factory,
throttler=self.throttler,
)
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.async_task: Optional[asyncio.Task] = None
self.data_source = DydxPerpetualAPIOrderBookDataSource(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 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 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 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 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 setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task: Optional[asyncio.Task] = None
self.mocking_assistant = NetworkMockingAssistant()
self.binance_client = MockBinanceClient(api_key="TEST_API_KEY")
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = BinanceAPIUserStreamDataSource(
binance_client=self.binance_client,
domain=self.domain,
throttler=self.throttler)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
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 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 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 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 test_listen_for_user_stream_inner_messages_recv_timeout_ping_timeout(self, ws_connect_mock):
self.data_source.PING_TIMEOUT = 0.1
self.data_source.MESSAGE_TIMEOUT = 0.1
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
ws_connect_mock.return_value.close.side_effect = lambda: done_callback_event.set()
ws_connect_mock.return_value.ping.side_effect = NetworkMockingAssistant.async_partial(
self.mocking_assistant._get_next_websocket_text_message, ws_connect_mock.return_value
)
# Add the authentication response for the websocket
self.mocking_assistant.add_websocket_text_message(
ws_connect_mock.return_value,
json.dumps({"event": "login"}))
done_callback_event = asyncio.Event()
message_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(self.ev_loop,
message_queue)
)
self.ev_loop.run_until_complete(done_callback_event.wait())
self.assertTrue(self._is_logged("WARNING", "WebSocket ping timed out. Going to reconnect..."))
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 setUp(self) -> None:
super().setUp()
self.ev_loop = asyncio.get_event_loop()
self.api_key = "someKey"
self.api_secret = "someSecret"
self.data_source = ProbitAPIOrderBookDataSource(
trading_pairs=[self.trading_pair], domain=self.domain)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.log_records = []
self.mocking_assistant = NetworkMockingAssistant()
self.async_tasks: List[asyncio.Task] = []
