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 data_source(self) -> UserStreamTrackerDataSource:
if self._data_source is None:
self._data_source = BinancePerpetualUserStreamDataSource(
api_key=self._api_key,
domain=self._domain,
throttler=self._throttler)
return self._data_source
def data_source(self) -> UserStreamTrackerDataSource:
if self._data_source is None:
self._data_source = BinancePerpetualUserStreamDataSource(
auth=self._auth,
domain=self._domain,
throttler=self._throttler,
api_factory=self._api_factory)
return self._data_source
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task: Optional[asyncio.Task] = None
self.mocking_assistant = NetworkMockingAssistant()
self.emulated_time = 1640001112.223
self.auth = BinancePerpetualAuth(api_key=self.api_key,
api_secret=self.secret_key,
time_provider=self)
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.time_synchronizer = TimeSynchronizer()
self.time_synchronizer.add_time_offset_ms_sample(0)
self.data_source = BinancePerpetualUserStreamDataSource(
auth=self.auth,
domain=self.domain,
throttler=self.throttler,
time_synchronizer=self.time_synchronizer)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.mock_done_event = asyncio.Event()
self.resume_test_event = asyncio.Event()
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.secret_key = "TEST_SECRET_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.emulated_time = 1640001112.223
self.auth = BinancePerpetualAuth(api_key=self.api_key,
api_secret=self.secret_key,
time_provider=self)
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.time_synchronizer = TimeSynchronizer()
self.time_synchronizer.add_time_offset_ms_sample(0)
self.data_source = BinancePerpetualUserStreamDataSource(
auth=self.auth,
domain=self.domain,
throttler=self.throttler,
time_synchronizer=self.time_synchronizer)
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 time(self):
# Implemented to emulate a TimeSynchronizer
return self.emulated_time
def test_last_recv_time(self):
# Initial last_recv_time
self.assertEqual(0, self.data_source.last_recv_time)
@aioresponses()
def test_get_listen_key_exception_raised(self, mock_api):
url = web_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 = web_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 = web_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 = web_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)
@aioresponses()
@patch("aiohttp.ClientSession.ws_connect", new_callable=AsyncMock)
def test_create_websocket_connection_log_exception(self, mock_api,
mock_ws):
url = web_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 = Exception("TEST ERROR.")
msg_queue = asyncio.Queue()
try:
self.async_run_with_timeout(
self.data_source.listen_for_user_stream(msg_queue))
except asyncio.exceptions.TimeoutError:
pass
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error while listening to user stream. Retrying after 5 seconds... Error: TEST ERROR.",
))
@aioresponses()
def test_manage_listen_key_task_loop_keep_alive_failed(self, mock_api):
url = web_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 = web_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 = web_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 = Exception("TEST ERROR.")
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue))
try:
self.async_run_with_timeout(msg_queue.get())
except asyncio.exceptions.TimeoutError:
pass
self.assertTrue(
self._is_logged(
"INFO", f"Successfully obtained listen key {self.listen_key}"))
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 = web_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 = Exception("TEST ERROR")
mock_ws.return_value.closed = False
mock_ws.return_value.close.side_effect = Exception
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue))
try:
self.async_run_with_timeout(msg_queue.get())
except Exception:
pass
self.assertTrue(
self._is_logged(
"INFO", f"Successfully obtained listen key {self.listen_key}"))
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_successful(self, mock_api, mock_ws):
url = web_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, self._simulate_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.assertTrue(msg, self._simulate_user_update_event)
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.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, "")
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
mock_ws.return_value)
self.assertEqual(0, msg_queue.qsize())
def data_source(self) -> UserStreamTrackerDataSource:
if self._data_source is None:
self._data_source = BinancePerpetualUserStreamDataSource(base_url=self._base_url, stream_url=self._stream_url, api_key=self._api_key)
return self._data_source