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