def test_process_instrument_when_subscribers_then_sends_to_registered_handlers(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler1 = [] subscribe1 = Subscribe( provider=BINANCE.value, data_type=DataType(Instrument, metadata={"InstrumentId": ETHUSDT_BINANCE.id}), handler=handler1.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) handler2 = [] subscribe2 = Subscribe( provider=BINANCE.value, data_type=DataType(Instrument, metadata={"InstrumentId": ETHUSDT_BINANCE.id}), handler=handler2.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) self.data_engine.execute(subscribe1) self.data_engine.execute(subscribe2) # Act self.data_engine.process(ETHUSDT_BINANCE) # Assert self.assertEqual([ETHUSDT_BINANCE.id], self.data_engine.subscribed_instruments) self.assertEqual([ETHUSDT_BINANCE], handler1) self.assertEqual([ETHUSDT_BINANCE], handler2)
def test_execute_unsubscribe_for_quote_ticks(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler = [] subscribe = Subscribe( provider=BINANCE.value, data_type=DataType(QuoteTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id}), handler=handler.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) self.data_engine.execute(subscribe) unsubscribe = Unsubscribe( provider=BINANCE.value, data_type=DataType(QuoteTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id}), handler=handler.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) # Act self.data_engine.execute(unsubscribe) # Assert self.assertEqual([], self.data_engine.subscribed_quote_ticks)
def test_execute_unsubscribe_instrument_then_removes_handler(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler = [] subscribe = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType( Instrument, metadata={"InstrumentId": ETHUSDT_BINANCE.id} ), handler=handler.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) self.data_engine.execute(subscribe) unsubscribe = Unsubscribe( client_id=ClientId(BINANCE.value), data_type=DataType( Instrument, metadata={"InstrumentId": ETHUSDT_BINANCE.id} ), handler=handler.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.data_engine.execute(unsubscribe) # Assert self.assertEqual([], self.data_engine.subscribed_instruments)
def test_unsubscribe_bar_type_then_unsubscribes(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() bar_spec = BarSpecification(1000, BarAggregation.TICK, PriceType.MID) bar_type = BarType(ETHUSDT_BINANCE.id, bar_spec, internal_aggregation=True) handler = ObjectStorer() subscribe = Subscribe( provider=BINANCE.value, data_type=DataType(Bar, metadata={"BarType": bar_type}), handler=handler.store_2, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) self.data_engine.execute(subscribe) unsubscribe = Unsubscribe( provider=BINANCE.value, data_type=DataType(Bar, metadata={"BarType": bar_type}), handler=handler.store_2, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) # Act self.data_engine.execute(unsubscribe) # Assert self.assertEqual([], self.data_engine.subscribed_bars)
def test_execute_unsubscribe_custom_data(self): # Arrange self.data_engine.register_client(self.binance_client) self.data_engine.register_client(self.quandl) self.binance_client.connect() handler = [] subscribe = Subscribe( provider="QUANDL", data_type=DataType(str, metadata={"Type": "news"}), handler=handler.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) self.data_engine.execute(subscribe) unsubscribe = Unsubscribe( provider="QUANDL", data_type=DataType(str, metadata={"Type": "news"}), handler=handler.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) # Act self.data_engine.execute(unsubscribe) # Assert self.assertEqual(2, self.data_engine.command_count) self.assertEqual(["subscribe", "unsubscribe"], self.quandl.calls)
def test_process_order_book_when_multiple_subscribers_then_sends_to_registered_handlers(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() order_book = OrderBook( instrument_id=ETHUSDT_BINANCE.id, level=2, depth=25, price_precision=2, size_precision=5, bids=[], asks=[], update_id=0, timestamp=0, ) handler1 = [] subscribe1 = Subscribe( provider=BINANCE.value, data_type=DataType(OrderBook, { "InstrumentId": ETHUSDT_BINANCE.id, "Level": 2, "Depth": 25, "Interval": 0, # Streaming }), handler=handler1.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) handler2 = [] subscribe2 = Subscribe( provider=BINANCE.value, data_type=DataType(OrderBook, { "InstrumentId": ETHUSDT_BINANCE.id, "Level": 2, "Depth": 25, "Interval": 0, # Streaming }), handler=handler2.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) self.data_engine.execute(subscribe1) self.data_engine.execute(subscribe2) # Act self.data_engine.process(order_book) # Assert self.assertEqual([ETHUSDT_BINANCE.id], self.data_engine.subscribed_order_books) self.assertEqual(order_book, handler1[0]) self.assertEqual(order_book, handler2[0])
def test_data_equality_and_hash(self): # Arrange # Act data_type1 = DataType(str, {"type": "NEWS_WIRE", "topic": "Earthquake"}) data_type2 = DataType(str, {"type": "NEWS_WIRE", "topic": "Flood"}) data_type3 = DataType(int, {"type": "FED_DATA", "topic": "NonFarmPayroll"}) # Assert self.assertTrue(data_type1 == data_type1) self.assertTrue(data_type1 != data_type2) self.assertTrue(data_type1 != data_type2) self.assertTrue(data_type1 != data_type3) self.assertEqual(int, type(hash(data_type1)))
def test_process_bar_when_subscribers_then_sends_to_registered_handlers( self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() bar_spec = BarSpecification(1000, BarAggregation.TICK, PriceType.MID) bar_type = BarType(ETHUSDT_BINANCE.id, bar_spec, internal_aggregation=True) handler1 = ObjectStorer() subscribe1 = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType(Bar, metadata={"bar_type": bar_type}), handler=handler1.store, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) handler2 = ObjectStorer() subscribe2 = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType(Bar, metadata={"bar_type": bar_type}), handler=handler2.store, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) self.data_engine.execute(subscribe1) self.data_engine.execute(subscribe2) bar = Bar( bar_type, Price.from_str("1051.00000"), Price.from_str("1055.00000"), Price.from_str("1050.00000"), Price.from_str("1052.00000"), Quantity.from_int(100), 0, 0, ) # Act self.data_engine.process(bar) # Assert self.assertEqual([bar], handler1.get_store()) self.assertEqual([bar], handler2.get_store())
def test_process_quote_tick_when_subscribers_then_sends_to_registered_handlers( self, ): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler1 = [] subscribe1 = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType( QuoteTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id} ), handler=handler1.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) handler2 = [] subscribe2 = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType( QuoteTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id} ), handler=handler2.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) self.data_engine.execute(subscribe1) self.data_engine.execute(subscribe2) tick = QuoteTick( ETHUSDT_BINANCE.id, Price.from_str("100.003"), Price.from_str("100.003"), Quantity.from_int(1), Quantity.from_int(1), 0, 0, ) # Act self.data_engine.process(tick) # Assert self.assertEqual([ETHUSDT_BINANCE.id], self.data_engine.subscribed_quote_ticks) self.assertEqual([tick], handler1) self.assertEqual([tick], handler2)
def test_data_command_str_and_repr(self): # Arrange # Act handler = [].append command_id = self.uuid_factory.generate() command = Subscribe( provider=BINANCE.value, data_type=DataType(str, {"type": "newswire"}), # str data type is invalid handler=handler, command_id=command_id, command_timestamp=self.clock.utc_now(), ) # Assert self.assertEqual("Subscribe(<str> {'type': 'newswire'})", str(command)) self.assertEqual( f"Subscribe(" f"provider=BINANCE, " f"data_type=<str> {{'type': 'newswire'}}, " f"handler={repr(handler)}, " f"id={command_id}, " f"timestamp=1970-01-01 00:00:00+00:00)", repr(command), )
def test_data_command_str_and_repr(self): # Arrange # Act handler = [].append command_id = self.uuid_factory.generate() command = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType( str, {"type": "newswire"}), # str data type is invalid handler=handler, command_id=command_id, timestamp_ns=self.clock.timestamp_ns(), ) # Assert self.assertEqual("Subscribe(<str> {'type': 'newswire'})", str(command)) self.assertEqual( f"Subscribe(" f"client_id=BINANCE, " f"data_type=<str> {{'type': 'newswire'}}, " f"handler={repr(handler)}, " f"id={command_id})", repr(command), )
def test_add_generic_data_adds_to_container(self): # Arrange engine = BacktestEngine() data_type = DataType(MyData, metadata={"news_wire": "hacks"}) generic_data1 = [ GenericData(data_type, MyData("AAPL hacked")), GenericData( data_type, MyData("AMZN hacked", 1000, 1000), ), GenericData( data_type, MyData("NFLX hacked", 3000, 3000), ), GenericData( data_type, MyData("MSFT hacked", 2000, 2000), ), ] generic_data2 = [ GenericData( data_type, MyData("FB hacked", 1500, 1500), ), ] # Act engine.add_generic_data(ClientId("NEWS_CLIENT"), generic_data1) engine.add_generic_data(ClientId("NEWS_CLIENT"), generic_data2)
def test_data_response_message_str_and_repr(self): # Arrange # Act correlation_id = self.uuid_factory.generate() response_id = self.uuid_factory.generate() instrument_id = InstrumentId(Symbol("AUD/USD"), IDEALPRO) response = DataResponse( client_id=ClientId(BINANCE.value), data_type=DataType(QuoteTick, metadata={"instrument_id": instrument_id}), data=[], correlation_id=correlation_id, response_id=response_id, timestamp_ns=self.clock.timestamp_ns(), ) # Assert self.assertEqual( "DataResponse(<QuoteTick> {'instrument_id': InstrumentId('AUD/USD.IDEALPRO')})", str(response), ) self.assertEqual( f"DataResponse(" f"client_id=BINANCE, " f"data_type=<QuoteTick> {{'instrument_id': InstrumentId('AUD/USD.IDEALPRO')}}, " f"correlation_id={correlation_id}, " f"id={response_id})", repr(response), )
def test_execute_subscribe_order_book_intervals_then_adds_handler(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() subscribe = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType( OrderBook, metadata={ "InstrumentId": ETHUSDT_BINANCE.id, "Level": 2, "Depth": 25, "Interval": 10, }, ), handler=[].append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.data_engine.execute(subscribe) # Assert self.assertEqual([ETHUSDT_BINANCE.id], self.data_engine.subscribed_order_books)
def test_send_request_when_no_data_clients_registered_does_nothing(self): # Arrange handler = [] request = DataRequest( client_id=ClientId("RANDOM"), data_type=DataType( QuoteTick, metadata={ "instrument_id": InstrumentId(Symbol("SOMETHING"), Venue("RANDOM")), "from_datetime": None, "to_datetime": None, "limit": 1000, }, ), callback=handler.append, request_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.data_engine.send(request) # Assert self.assertEqual(1, self.data_engine.request_count)
def test_message_qsize_at_max_blocks_on_receive_response(self): # Arrange self.engine = LiveDataEngine( loop=self.loop, portfolio=self.portfolio, clock=self.clock, logger=self.logger, config={"qsize": 1}, ) response = DataResponse( client_id=ClientId("BINANCE"), data_type=DataType(QuoteTick), data=[], correlation_id=self.uuid_factory.generate(), response_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.engine.receive(response) self.engine.receive(response) # Add over max size # Assert self.assertEqual(1, self.engine.message_qsize()) self.assertEqual(0, self.engine.command_count)
def test_message_qsize_at_max_blocks_on_put_data_command(self): # Arrange self.engine = LiveDataEngine( loop=self.loop, portfolio=self.portfolio, clock=self.clock, logger=self.logger, config={"qsize": 1}, ) subscribe = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType(QuoteTick), handler=[].append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.engine.execute(subscribe) self.engine.execute(subscribe) # Assert self.assertEqual(1, self.engine.message_qsize()) self.assertEqual(0, self.engine.command_count)
async def run_test(): # Arrange self.engine.start() handler = [] request = DataRequest( client_id=ClientId("RANDOM"), data_type=DataType( QuoteTick, metadata={ "InstrumentId": InstrumentId(Symbol("SOMETHING"), Venue("RANDOM")), "FromDateTime": None, "ToDateTime": None, "Limit": 1000, }, ), callback=handler.append, request_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.engine.send(request) await asyncio.sleep(0.1) # Assert self.assertEqual(0, self.engine.message_qsize()) self.assertEqual(1, self.engine.request_count) # Tear Down self.engine.stop()
def test_process_trade_tick_when_subscriber_then_sends_to_registered_handler(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler = [] subscribe = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType( TradeTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id} ), handler=handler.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) self.data_engine.execute(subscribe) tick = TradeTick( ETHUSDT_BINANCE.id, Price.from_str("1050.00000"), Quantity.from_int(100), AggressorSide.BUY, TradeMatchId("123456789"), 0, 0, ) # Act self.data_engine.process(tick) # Assert self.assertEqual([tick], handler)
def test_send_data_request_when_data_type_unrecognized_logs_and_does_nothing(self): # Arrange self.data_engine.register_client(self.binance_client) handler = [] request = DataRequest( client_id=ClientId(BINANCE.value), data_type=DataType( str, metadata={ # str data type is invalid "InstrumentId": InstrumentId(Symbol("SOMETHING"), Venue("RANDOM")), "FromDateTime": None, "ToDateTime": None, "Limit": 1000, }, ), callback=handler.append, request_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.data_engine.send(request) # Assert self.assertEqual(1, self.data_engine.request_count)
def test_data_response_message_str_and_repr(self): # Arrange # Act correlation_id = self.uuid_factory.generate() response_id = self.uuid_factory.generate() instrument_id = InstrumentId(Symbol("AUD/USD"), IDEALPRO) response = DataResponse( provider=BINANCE.value, data_type=DataType(QuoteTick, metadata={"InstrumentId": instrument_id}), data=[], correlation_id=correlation_id, response_id=response_id, response_timestamp=self.clock.utc_now(), ) # Assert self.assertEqual("DataResponse(<QuoteTick> {'InstrumentId': InstrumentId('AUD/USD.IDEALPRO')})", str(response)) self.assertEqual( f"DataResponse(" f"provider=BINANCE, " f"data_type=<QuoteTick> {{'InstrumentId': InstrumentId('AUD/USD.IDEALPRO')}}, " f"correlation_id={correlation_id}, " f"id={response_id}, " f"timestamp=1970-01-01 00:00:00+00:00)", repr(response), )
async def run_test(): # Arrange self.data_engine.start() # Also starts client await asyncio.sleep(0.3) # Allow engine message queue to start handler = ObjectStorer() request = DataRequest( client_name=BINANCE.value, data_type=DataType( TradeTick, metadata={ "InstrumentId": ETHUSDT, "FromDateTime": None, "ToDateTime": None, "Limit": 100, }, ), callback=handler.store, request_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) # Act self.data_engine.send(request) await asyncio.sleep(1) # Assert self.assertEqual(1, self.data_engine.response_count) self.assertEqual(1, handler.count) # Tear Down self.data_engine.stop() await self.data_engine.get_run_queue_task()
def test_process_bar_when_subscriber_then_sends_to_registered_handler(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() bar_spec = BarSpecification(1000, BarAggregation.TICK, PriceType.MID) bar_type = BarType(ETHUSDT_BINANCE.id, bar_spec, internal_aggregation=True) handler = ObjectStorer() subscribe = Subscribe( provider=BINANCE.value, data_type=DataType(Bar, metadata={"BarType": bar_type}), handler=handler.store_2, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) self.data_engine.execute(subscribe) bar = Bar( Price("1051.00000"), Price("1055.00000"), Price("1050.00000"), Price("1052.00000"), Quantity(100), UNIX_EPOCH, ) data = BarData(bar_type, bar) # Act self.data_engine.process(data) # Assert self.assertEqual([(bar_type, bar)], handler.get_store())
def test_process_quote_tick_when_subscriber_then_sends_to_registered_handler(self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler = [] subscribe = Subscribe( provider=BINANCE.value, data_type=DataType(QuoteTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id}), handler=handler.append, command_id=self.uuid_factory.generate(), command_timestamp=self.clock.utc_now(), ) self.data_engine.execute(subscribe) tick = QuoteTick( ETHUSDT_BINANCE.id, Price("100.003"), Price("100.003"), Quantity(1), Quantity(1), UNIX_EPOCH, ) # Act self.data_engine.process(tick) # Assert self.assertEqual([ETHUSDT_BINANCE.id], self.data_engine.subscribed_quote_ticks) self.assertEqual([tick], handler)
def test_process_trade_tick_when_subscribers_then_sends_to_registered_handlers( self, ): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler1 = [] subscribe1 = Subscribe( client_name=BINANCE.value, data_type=DataType( TradeTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id} ), handler=handler1.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) handler2 = [] subscribe2 = Subscribe( client_name=BINANCE.value, data_type=DataType( TradeTick, metadata={"InstrumentId": ETHUSDT_BINANCE.id} ), handler=handler2.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) self.data_engine.execute(subscribe1) self.data_engine.execute(subscribe2) tick = TradeTick( ETHUSDT_BINANCE.id, Price("1050.00000"), Quantity(100), OrderSide.BUY, TradeMatchId("123456789"), 0, ) # Act self.data_engine.process(tick) # Assert self.assertEqual([tick], handler1) self.assertEqual([tick], handler2)
def test_send_data_request_with_duplicate_ids_logs_and_does_not_handle_second( self): # Arrange self.data_engine.register_client(self.binance_client) self.data_engine.start() handler = [] uuid = self.uuid_factory.generate() # We'll use this as a duplicate request1 = DataRequest( client_id=ClientId(BINANCE.value), data_type=DataType( QuoteTick, metadata={ # str data type is invalid "instrument_id": InstrumentId(Symbol("SOMETHING"), Venue("RANDOM")), "from_datetime": None, "to_datetime": None, "limit": 1000, }, ), callback=handler.append, request_id=uuid, # Duplicate timestamp_ns=self.clock.timestamp_ns(), ) request2 = DataRequest( client_id=ClientId(BINANCE.value), data_type=DataType( QuoteTick, metadata={ # str data type is invalid "instrument_id": InstrumentId(Symbol("SOMETHING"), Venue("RANDOM")), "from_datetime": None, "to_datetime": None, "limit": 1000, }, ), callback=handler.append, request_id=uuid, # Duplicate timestamp_ns=self.clock.timestamp_ns(), ) # Act self.data_engine.send(request1) self.data_engine.send(request2) # Assert self.assertEqual(2, self.data_engine.request_count)
def test_data_type_as_key_in_dict(self): # Arrange # Act data_type = DataType(str, {"type": "NEWS_WIRE", "topic": "Earthquake"}) hash_map = {data_type: []} # Assert self.assertIn(data_type, hash_map)
def test_request_when_not_implemented_raises_exception(self): # Arrange # Act # Assert self.assertRaises( NotImplementedError, self.client.request, DataType(str), self.uuid_factory.generate(), )
def test_handle_data_sends_to_data_engine(self): # Arrange data_type = DataType(str, {"Type": "NEWS_WIRE"}) data = GenericData(data_type, "Some news headline", UNIX_EPOCH) # Act self.client._handle_data_py(data) # Assert self.assertEqual(1, self.data_engine.data_count)
async def test_request_search_instruments(betfair_data_client, data_engine, uuid): req = DataType( data_type=InstrumentSearch, metadata={"event_type_id": "7"}, ) betfair_data_client.request(req, uuid) await asyncio.sleep(0) resp = data_engine.responses[0] assert len(resp.data.data.instruments) == 9383