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_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_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),
)
def test_venue_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("IB"),
venue=Venue("IDEALPRO"),
data_type=DataType(QuoteTick,
metadata={"instrument_id": instrument_id}),
data=[],
correlation_id=correlation_id,
response_id=response_id,
ts_init=self.clock.timestamp_ns(),
)
# Assert
assert (
str(response) ==
"DataResponse(QuoteTick{'instrument_id': InstrumentId('AUD/USD.IDEALPRO')})"
)
assert repr(response) == (
f"DataResponse("
f"client_id=IB, "
f"venue=IDEALPRO, "
f"data_type=QuoteTick{{'instrument_id': InstrumentId('AUD/USD.IDEALPRO')}}, "
f"correlation_id={correlation_id}, "
f"id={response_id})")
def test_message_qsize_at_max_blocks_on_receive_response(self):
# Arrange
self.data_engine = LiveDataEngine(loop=self.loop,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
config={"qsize": 1})
response = DataResponse(
venue=Venue("BINANCE"),
data_type=QuoteTick,
metadata={},
data=[],
correlation_id=self.uuid_factory.generate(),
response_id=self.uuid_factory.generate(),
response_timestamp=self.clock.utc_now(),
)
# Act
self.data_engine.receive(response)
self.data_engine.receive(response) # Add over max size
# Assert
self.assertEqual(1, self.data_engine.message_qsize())
self.assertEqual(0, self.data_engine.command_count)
def test_data_messages_when_client_id_and_venue_none_raise_value_error(
self):
# Arrange, Act , Assert
with pytest.raises(ValueError) as ex:
Subscribe(
client_id=None,
venue=None,
data_type=DataType(str, {"type": "newswire"}),
command_id=self.uuid_factory.generate(),
ts_init=self.clock.timestamp_ns(),
)
assert ex.type == ValueError
assert ex.match("Both `client_id` and `venue` were None")
with pytest.raises(ValueError) as ex:
Unsubscribe(
client_id=None,
venue=None,
data_type=DataType(str, {"type": "newswire"}),
command_id=self.uuid_factory.generate(),
ts_init=self.clock.timestamp_ns(),
)
assert ex.type == ValueError
assert ex.match("Both `client_id` and `venue` were None")
with pytest.raises(ValueError) as ex:
handler = []
DataRequest(
client_id=None,
venue=None,
data_type=DataType(QuoteTick),
callback=handler.append,
request_id=self.uuid_factory.generate(),
ts_init=self.clock.timestamp_ns(),
)
assert ex.type == ValueError
assert ex.match("Both `client_id` and `venue` were None")
with pytest.raises(ValueError) as ex:
DataResponse(
client_id=None,
venue=None,
data_type=DataType(QuoteTick),
data=[],
correlation_id=self.uuid_factory.generate(),
response_id=self.uuid_factory.generate(),
ts_init=self.clock.timestamp_ns(),
)
assert ex.type == ValueError
assert ex.match("Both `client_id` and `venue` were None")
def test_receive_response_when_no_data_clients_registered_does_nothing(self):
# Arrange
response = DataResponse(
provider=BINANCE.value,
data_type=DataType(QuoteTick),
data=[],
correlation_id=self.uuid_factory.generate(),
response_id=self.uuid_factory.generate(),
response_timestamp=self.clock.utc_now(),
)
# Act
self.data_engine.receive(response)
# Assert
self.assertEqual(1, self.data_engine.response_count)
async def test_message_qsize_at_max_blocks_on_receive_response(self):
# Arrange
self.msgbus.deregister(endpoint="DataEngine.execute",
handler=self.engine.execute)
self.msgbus.deregister(endpoint="DataEngine.process",
handler=self.engine.process)
self.msgbus.deregister(endpoint="DataEngine.request",
handler=self.engine.request)
self.msgbus.deregister(endpoint="DataEngine.response",
handler=self.engine.response)
self.engine = LiveDataEngine(
loop=self.loop,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config=LiveDataEngineConfig(qsize=1),
)
response = DataResponse(
client_id=ClientId("BINANCE"),
venue=BINANCE,
data_type=DataType(QuoteTick),
data=[],
correlation_id=self.uuid_factory.generate(),
response_id=self.uuid_factory.generate(),
ts_init=self.clock.timestamp_ns(),
)
# Act
self.engine.response(response)
self.engine.response(response) # Add over max size
await asyncio.sleep(0.1)
# Assert
assert self.engine.message_qsize() == 1
assert self.engine.command_count == 0
async def run_test():
# Arrange
self.engine.start()
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)
await asyncio.sleep(0.1)
# Assert
self.assertEqual(0, self.engine.message_qsize())
self.assertEqual(1, self.engine.response_count)
# Tear Down
self.engine.stop()
async def test_receive_response_processes_message(self):
# Arrange
self.engine.start()
response = DataResponse(
client_id=ClientId("BINANCE"),
data_type=DataType(QuoteTick),
data=[],
correlation_id=self.uuid_factory.generate(),
response_id=self.uuid_factory.generate(),
ts_init=self.clock.timestamp_ns(),
)
# Act
self.engine.response(response)
await asyncio.sleep(0.1)
# Assert
assert self.engine.message_qsize() == 0
assert self.engine.response_count == 1
# Tear Down
self.engine.stop()
async def run_test():
# Arrange
self.data_engine.start()
response = DataResponse(
venue=Venue("BINANCE"),
data_type=QuoteTick,
metadata={},
data=[],
correlation_id=self.uuid_factory.generate(),
response_id=self.uuid_factory.generate(),
response_timestamp=self.clock.utc_now(),
)
# Act
self.data_engine.receive(response)
await asyncio.sleep(0.1)
# Assert
self.assertEqual(0, self.data_engine.message_qsize())
self.assertEqual(1, self.data_engine.response_count)
# Tear Down
self.data_engine.stop()
