def test_add_order_state_report(self):
# Arrange
report = ExecutionMassStatus(
client_id=ClientId("IB"),
account_id=TestStubs.account_id(),
timestamp_ns=0,
)
venue_order_id = VenueOrderId("1")
order_report = OrderStatusReport(
client_order_id=ClientOrderId("O-123456"),
venue_order_id=venue_order_id,
order_state=OrderState.REJECTED,
filled_qty=Quantity.zero(),
timestamp_ns=0,
)
# Act
report.add_order_report(order_report)
# Assert
assert report.order_reports()[venue_order_id] == order_report
assert (
repr(report) ==
"ExecutionMassStatus(client_id=IB, account_id=SIM-000, timestamp_ns=0, order_reports={VenueOrderId('1'): OrderStatusReport(client_order_id=O-123456, venue_order_id=1, order_state=REJECTED, filled_qty=0, timestamp_ns=0)}, exec_reports={}, position_reports={})" # noqa
)
assert (
repr(order_report) ==
"OrderStatusReport(client_order_id=O-123456, venue_order_id=1, order_state=REJECTED, filled_qty=0, timestamp_ns=0)" # noqa
)
async def test_reconcile_state_when_order_completed_returns_true_with_warning2(
self):
# Arrange
self.exec_engine.start()
self.risk_engine.start()
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.risk_engine.execute(submit_order)
await asyncio.sleep(0) # Process queue
self.exec_engine.process(TestStubs.event_order_submitted(order))
await asyncio.sleep(0) # Process queue
self.exec_engine.process(TestStubs.event_order_accepted(order))
await asyncio.sleep(0) # Process queue
self.exec_engine.process(
TestStubs.event_order_filled(order, AUDUSD_SIM))
await asyncio.sleep(0) # Process queue
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_status=OrderStatus.FILLED,
filled_qty=Quantity.from_int(100000),
ts_init=0,
)
# Act
result = await self.client.reconcile_state(report, order)
# Assert
assert result
async def generate_order_status_report(self, order) -> Optional[OrderStatusReport]:
return [
OrderStatusReport(
client_order_id=ClientOrderId(),
venue_order_id=VenueOrderId(),
order_state=OrderState(),
filled_qty=Quantity.zero(),
timestamp_ns=millis_to_nanos(),
)
for order in self.client().betting.list_current_orders()["currentOrders"]
]
async def generate_order_status_report(self, order) -> Optional[OrderStatusReport]:
return [
OrderStatusReport(
client_order_id=ClientOrderId(),
venue_order_id=VenueOrderId(),
order_status=OrderStatus(),
filled_qty=Quantity.zero(),
ts_init=int(pd.Timestamp(order["timestamp"]).to_datetime64()),
)
for order in self.client().betting.list_current_orders()["currentOrders"]
]
async def run_test():
# Arrange
self.engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.engine.register_strategy(strategy)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submit_order = SubmitOrder(
AUDUSD_SIM.id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.engine.execute(submit_order)
self.engine.process(TestStubs.event_order_submitted(order))
self.engine.process(TestStubs.event_order_accepted(order))
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_state=OrderState.EXPIRED,
filled_qty=Quantity(0),
timestamp_ns=0,
)
self.client.add_order_status_report(report)
await asyncio.sleep(0.01)
# Act
result = await self.engine.reconcile_state()
self.engine.stop()
# Assert
assert result
async def test_reconcile_state_when_expired_reconciles(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.exec_engine.execute(submit_order)
self.exec_engine.process(TestStubs.event_order_submitted(order))
self.exec_engine.process(TestStubs.event_order_accepted(order))
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_status=OrderStatus.EXPIRED,
filled_qty=Quantity.zero(),
ts_init=0,
)
self.client.add_order_status_report(report)
await asyncio.sleep(0.1) # Allow processing time
# Act
result = await self.exec_engine.reconcile_state(timeout_secs=10)
self.exec_engine.stop()
# Assert
assert result
async def run_test():
# Arrange
report = OrderStatusReport(
client_order_id=ClientOrderId("O-123456"),
venue_order_id=VenueOrderId("1"),
order_state=OrderState.FILLED,
filled_qty=Quantity(100000),
timestamp_ns=0,
)
# Act
result = await self.client.reconcile_state(
report, order=None) # <- order won't be in cache
# Assert
assert not result
async def test_reconcile_state_given_no_order_and_not_in_cache_returns_false(
self):
# Arrange
report = OrderStatusReport(
client_order_id=ClientOrderId("O-123456"),
venue_order_id=VenueOrderId("1"),
order_status=OrderStatus.FILLED,
filled_qty=Quantity.from_int(100000),
ts_init=0,
)
# Act
result = await self.client.reconcile_state(
report, order=None) # <- order won't be in the cache
# Assert
assert not result
def test_add_order_state_report(self):
# Arrange
report = ExecutionMassStatus(
client="IB",
account_id=TestStubs.account_id(),
timestamp_ns=0,
)
venue_order_id = VenueOrderId("1")
order_report = OrderStatusReport(
client_order_id=ClientOrderId("O-123456"),
venue_order_id=venue_order_id,
order_state=OrderState.REJECTED,
filled_qty=Quantity(0),
timestamp_ns=0,
)
# Act
report.add_order_report(order_report)
# Assert
assert report.order_reports()[venue_order_id] == order_report
async def test_reconcile_state_when_filled_reconciles(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.exec_engine.execute(submit_order)
self.exec_engine.process(TestStubs.event_order_submitted(order))
self.exec_engine.process(TestStubs.event_order_accepted(order))
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_status=OrderStatus.FILLED,
filled_qty=Quantity.from_int(100000),
ts_init=0,
)
trade1 = ExecutionReport(
execution_id=ExecutionId("1"),
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
venue_position_id=None,
last_qty=Quantity.from_int(50000),
last_px=Price.from_str("1.00000"),
commission=Money(5.00, USD),
liquidity_side=LiquiditySide.MAKER,
ts_event=0,
ts_init=0,
)
trade2 = ExecutionReport(
execution_id=ExecutionId("2"),
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
venue_position_id=None,
last_qty=Quantity.from_int(50000),
last_px=Price.from_str("1.00000"),
commission=Money(2.00, USD),
liquidity_side=LiquiditySide.MAKER,
ts_event=0,
ts_init=0,
)
self.client.add_order_status_report(report)
self.client.add_trades_list(VenueOrderId("1"), [trade1, trade2])
await asyncio.sleep(0.1) # Allow processing time
# Act
result = await self.exec_engine.reconcile_state(timeout_secs=10)
self.exec_engine.stop()
# Assert
assert result
async def run_test():
# Arrange
self.engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.engine.register_strategy(strategy)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submit_order = SubmitOrder(
AUDUSD_SIM.id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.engine.execute(submit_order)
self.engine.process(TestStubs.event_order_submitted(order))
self.engine.process(TestStubs.event_order_accepted(order))
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_state=OrderState.FILLED,
filled_qty=Quantity(100000),
timestamp_ns=0,
)
trade1 = ExecutionReport(
execution_id=ExecutionId("1"),
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
last_qty=Decimal(50000),
last_px=Decimal("1.00000"),
commission_amount=Decimal("5.0"),
commission_currency="USD",
liquidity_side=LiquiditySide.MAKER,
execution_ns=0,
timestamp_ns=0,
)
trade2 = ExecutionReport(
execution_id=ExecutionId("2"),
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
last_qty=Decimal(50000),
last_px=Decimal("1.00000"),
commission_amount=Decimal("2.0"),
commission_currency="USD",
liquidity_side=LiquiditySide.MAKER,
execution_ns=0,
timestamp_ns=0,
)
self.client.add_order_status_report(report)
self.client.add_trades_list(VenueOrderId("1"), [trade1, trade2])
await asyncio.sleep(0.01)
# Act
result = await self.engine.reconcile_state()
self.engine.stop()
# Assert
assert result
async def run_test():
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER-000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.exec_engine.execute(submit_order)
self.exec_engine.process(TestStubs.event_order_submitted(order))
self.exec_engine.process(TestStubs.event_order_accepted(order))
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_state=OrderState.PARTIALLY_FILLED,
filled_qty=Quantity.from_int(70000),
timestamp_ns=0,
)
trade1 = ExecutionReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
execution_id=ExecutionId("1"),
last_qty=Quantity.from_int(50000),
last_px=Price.from_str("1.00000"),
commission=Money(5.00, USD),
liquidity_side=LiquiditySide.MAKER,
ts_filled_ns=0,
timestamp_ns=0,
)
trade2 = ExecutionReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
execution_id=ExecutionId("2"),
last_qty=Quantity.from_int(20000),
last_px=Price.from_str("1.00000"),
commission=Money(2.00, USD),
liquidity_side=LiquiditySide.MAKER,
ts_filled_ns=0,
timestamp_ns=0,
)
self.client.add_order_status_report(report)
self.client.add_trades_list(VenueOrderId("1"), [trade1, trade2])
await asyncio.sleep(0.01)
# Act
result = await self.exec_engine.reconcile_state(timeout_secs=10)
self.exec_engine.stop()
# Assert
assert result
