def setUpClass(cls):
global MAINNET_RPC_URL
cls.ev_loop = asyncio.get_event_loop()
if API_MOCK_ENABLED:
raise NotImplementedError()
# cls.web_app = HummingWebApp.get_instance()
# cls.web_app.add_host_to_mock(BASE_API_URL, [])
# cls.web_app.start()
# cls.ev_loop.run_until_complete(cls.web_app.wait_til_started())
# cls._patcher = mock.patch("aiohttp.client.URL")
# cls._url_mock = cls._patcher.start()
# cls._url_mock.side_effect = cls.web_app.reroute_local
# cls.web_app.update_response("get", BASE_API_URL, "/v2/public/get-ticker", fixture.TICKERS)
# cls.web_app.update_response("get", BASE_API_URL, "/v2/public/get-instruments", fixture.INSTRUMENTS)
# cls.web_app.update_response("get", BASE_API_URL, "/v2/public/get-book", fixture.GET_BOOK)
# cls.web_app.update_response("post", BASE_API_URL, "/v2/private/get-account-summary", fixture.BALANCES)
# cls.web_app.update_response("post", BASE_API_URL, "/v2/private/cancel-order", fixture.CANCEL)
# HummingWsServerFactory.start_new_server(WSS_PRIVATE_URL)
# HummingWsServerFactory.start_new_server(WSS_PUBLIC_URL)
# cls._ws_patcher = unittest.mock.patch("websockets.connect", autospec=True)
# cls._ws_mock = cls._ws_patcher.start()
# cls._ws_mock.side_effect = HummingWsServerFactory.reroute_ws_connect
cls.clock: Clock = Clock(ClockMode.REALTIME)
cls.connector: DigifinexExchange = DigifinexExchange(
digifinex_api_key=API_KEY,
digifinex_secret_key=API_SECRET,
trading_pairs=[cls.trading_pair],
trading_required=True)
print(
"Initializing Digifinex market... this will take about a minute.")
cls.clock.add_iterator(cls.connector)
cls.stack: contextlib.ExitStack = contextlib.ExitStack()
cls._clock = cls.stack.enter_context(cls.clock)
# if API_MOCK_ENABLED:
# HummingWsServerFactory.send_json_threadsafe(WSS_PRIVATE_URL, fixture.WS_INITIATED, delay=0.5)
# HummingWsServerFactory.send_json_threadsafe(WSS_PRIVATE_URL, fixture.WS_SUBSCRIBE, delay=0.51)
# HummingWsServerFactory.send_json_threadsafe(WSS_PRIVATE_URL, fixture.WS_HEARTBEAT, delay=0.52)
cls.ev_loop.run_until_complete(cls.wait_til_ready())
print("Ready.")
def test_orders_saving_and_restoration(self):
config_path = "test_config"
strategy_name = "test_strategy"
sql = SQLConnectionManager(SQLConnectionType.TRADE_FILLS,
db_path=self.db_path)
order_id = None
recorder = MarketsRecorder(sql, [self.connector], config_path,
strategy_name)
recorder.start()
try:
self.connector._in_flight_orders.clear()
self.assertEqual(0, len(self.connector.tracking_states))
# Try to put limit buy order for 0.02 ETH worth of ZRX, and watch for order creation event.
current_bid_price: Decimal = self.connector.get_price(
self.trading_pair, True)
price: Decimal = current_bid_price * Decimal("0.8")
price = self.connector.quantize_order_price(
self.trading_pair, price)
amount: Decimal = Decimal("0.0001")
amount = self.connector.quantize_order_amount(
self.trading_pair, amount)
cl_order_id = self._place_order(True, amount,
OrderType.LIMIT_MAKER, price, 1,
fixture.UNFILLED_ORDER)
order_created_event = self.ev_loop.run_until_complete(
self.event_logger.wait_for(BuyOrderCreatedEvent))
self.assertEqual(cl_order_id, order_created_event.order_id)
# Verify tracking states
self.assertEqual(1, len(self.connector.tracking_states))
self.assertEqual(cl_order_id,
list(self.connector.tracking_states.keys())[0])
# Verify orders from recorder
recorded_orders: List[
Order] = recorder.get_orders_for_config_and_market(
config_path, self.connector)
self.assertEqual(1, len(recorded_orders))
self.assertEqual(cl_order_id, recorded_orders[0].id)
# Verify saved market states
saved_market_states: MarketState = recorder.get_market_states(
config_path, self.connector)
self.assertIsNotNone(saved_market_states)
self.assertIsInstance(saved_market_states.saved_state, dict)
self.assertGreater(len(saved_market_states.saved_state), 0)
# Close out the current market and start another market.
self.connector.stop(self._clock)
self.ev_loop.run_until_complete(asyncio.sleep(5))
self.clock.remove_iterator(self.connector)
for event_tag in self.events:
self.connector.remove_listener(event_tag, self.event_logger)
new_connector = DigifinexExchange(API_KEY, API_SECRET,
[self.trading_pair], True)
for event_tag in self.events:
new_connector.add_listener(event_tag, self.event_logger)
recorder.stop()
recorder = MarketsRecorder(sql, [new_connector], config_path,
strategy_name)
recorder.start()
saved_market_states = recorder.get_market_states(
config_path, new_connector)
self.clock.add_iterator(new_connector)
if not API_MOCK_ENABLED:
self.ev_loop.run_until_complete(
self.wait_til_ready(new_connector))
self.assertEqual(0, len(new_connector.limit_orders))
self.assertEqual(0, len(new_connector.tracking_states))
new_connector.restore_tracking_states(
saved_market_states.saved_state)
self.assertEqual(1, len(new_connector.limit_orders))
self.assertEqual(1, len(new_connector.tracking_states))
# Cancel the order and verify that the change is saved.
self._cancel_order(cl_order_id)
self.ev_loop.run_until_complete(
self.event_logger.wait_for(OrderCancelledEvent))
order_id = None
self.assertEqual(0, len(new_connector.limit_orders))
self.assertEqual(0, len(new_connector.tracking_states))
saved_market_states = recorder.get_market_states(
config_path, new_connector)
self.assertEqual(0, len(saved_market_states.saved_state))
finally:
if order_id is not None:
self.connector.cancel(self.trading_pair, cl_order_id)
self.run_parallel(
self.event_logger.wait_for(OrderCancelledEvent))
recorder.stop()
# sql._engine.dispose()
# on windows cannot unlink the sqlite db file before closing the db
if os.name != 'nt':
os.unlink(self.db_path)