class LiveExecutionPerformanceTests(unittest.TestCase):
def setUp(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = TestLogger(self.clock, bypass_logging=True)
self.trader_id = TraderId("TESTER", "000")
self.account_id = AccountId("BINANCE", "001")
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
database = BypassExecutionDatabase(trader_id=self.trader_id, logger=self.logger)
self.exec_engine = LiveExecutionEngine(
loop=self.loop,
database=database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
exec_client = MockExecutionClient(
venue=Venue("BINANCE"),
account_id=self.account_id,
exec_engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
self.exec_engine.register_client(exec_client)
self.exec_engine.process(TestStubs.event_account_state(self.account_id))
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(self.strategy)
def submit_order(self):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.symbol,
OrderSide.BUY,
Quantity("1.00000000"),
)
self.strategy.submit_order(order)
def test_execute_command(self):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.symbol,
OrderSide.BUY,
Quantity("1.00000000"),
)
command = SubmitOrder(
order.symbol.venue,
self.trader_id,
self.account_id,
self.strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
def execute_command():
self.exec_engine.execute(command)
PerformanceHarness.profile_function(execute_command, 10000, 1)
# ~0.0ms / ~0.3μs / 253ns minimum of 10,000 runs @ 1 iteration each run.
def test_submit_order(self):
self.exec_engine.start()
time.sleep(0.1)
async def run_test():
def submit_order():
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.symbol,
OrderSide.BUY,
Quantity("1.00000000"),
)
self.strategy.submit_order(order)
PerformanceHarness.profile_function(submit_order, 10000, 1)
self.loop.run_until_complete(run_test())
# ~0.0ms / ~24.5μs / 24455ns minimum of 10,000 runs @ 1 iteration each run.
def test_submit_order_end_to_end(self):
self.exec_engine.start()
time.sleep(0.1)
async def run_test():
for _ in range(10000):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.symbol,
OrderSide.BUY,
Quantity("1.00000000"),
)
self.strategy.submit_order(order)
stats_file = "perf_live_execution.prof"
cProfile.runctx("self.loop.run_until_complete(run_test())", globals(), locals(), stats_file)
s = pstats.Stats(stats_file)
s.strip_dirs().sort_stats("time").print_stats()
class LiveExecutionEngineTests(unittest.TestCase):
def setUp(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = TestLogger(self.clock)
self.trader_id = TraderId("TESTER", "000")
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S", "001"),
clock=self.clock,
)
self.random_order_factory = OrderFactory(
trader_id=TraderId("RANDOM", "042"),
strategy_id=StrategyId("S", "042"),
clock=self.clock,
)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.database = BypassExecutionDatabase(trader_id=self.trader_id,
logger=self.logger)
self.exec_engine = LiveExecutionEngine(
loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.venue = Venue("SIM")
self.exec_client = MockExecutionClient(
self.venue,
self.account_id,
self.exec_engine,
self.clock,
self.logger,
)
self.exec_engine.register_client(self.exec_client)
def tearDown(self):
self.exec_engine.dispose()
self.loop.stop()
self.loop.close()
def test_start_when_loop_not_running_logs(self):
# Arrange
# Act
self.exec_engine.start()
# Assert
self.assertTrue(True) # No exceptions raised
self.exec_engine.stop()
def test_message_qsize_at_max_blocks_on_put_command(self):
# Arrange
self.exec_engine = LiveExecutionEngine(loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
config={"qsize": 1})
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.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
Venue("SIM"),
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_engine.execute(submit_order)
self.exec_engine.execute(submit_order)
# Assert
self.assertEqual(1, self.exec_engine.qsize())
self.assertEqual(0, self.exec_engine.command_count)
def test_message_qsize_at_max_blocks_on_put_event(self):
# Arrange
self.exec_engine = LiveExecutionEngine(loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
config={"qsize": 1})
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.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
Venue("SIM"),
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
event = TestStubs.event_order_submitted(order)
# Act
self.exec_engine.execute(submit_order)
self.exec_engine.process(event) # Add over max size
# Assert
self.assertEqual(1, self.exec_engine.qsize())
self.assertEqual(0, self.exec_engine.command_count)
def test_get_event_loop_returns_expected_loop(self):
# Arrange
# Act
loop = self.exec_engine.get_event_loop()
# Assert
self.assertEqual(self.loop, loop)
def test_start(self):
async def run_test():
# Arrange
# Act
self.exec_engine.start()
await asyncio.sleep(0.1)
# Assert
self.assertEqual(ComponentState.RUNNING, self.exec_engine.state)
# Tear Down
self.exec_engine.stop()
self.loop.run_until_complete(run_test())
def test_kill_when_running_and_no_messages_on_queues(self):
async def run_test():
# Arrange
# Act
self.exec_engine.start()
await asyncio.sleep(0)
self.exec_engine.kill()
# Assert
self.assertEqual(ComponentState.STOPPED, self.exec_engine.state)
self.loop.run_until_complete(run_test())
def test_kill_when_not_running_with_messages_on_queue(self):
async def run_test():
# Arrange
# Act
self.exec_engine.kill()
# Assert
self.assertEqual(0, self.exec_engine.qsize())
self.loop.run_until_complete(run_test())
def test_execute_command_places_command_on_queue(self):
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.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
Venue("SIM"),
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_engine.execute(submit_order)
await asyncio.sleep(0.1)
# Assert
self.assertEqual(0, self.exec_engine.qsize())
self.assertEqual(1, self.exec_engine.command_count)
# Tear Down
self.exec_engine.stop()
self.loop.run_until_complete(run_test())
def test_handle_position_opening_with_position_id_none(self):
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.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
event = TestStubs.event_order_submitted(order)
# Act
self.exec_engine.process(event)
await asyncio.sleep(0.1)
# Assert
self.assertEqual(0, self.exec_engine.qsize())
self.assertEqual(1, self.exec_engine.event_count)
# Tear Down
self.exec_engine.stop()
self.loop.run_until_complete(run_test())
class TestLiveExecutionEngine:
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER", "000")
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S", "001"),
clock=self.clock,
)
self.random_order_factory = OrderFactory(
trader_id=TraderId("RANDOM", "042"),
strategy_id=StrategyId("S", "042"),
clock=self.clock,
)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.database = BypassExecutionDatabase(trader_id=self.trader_id,
logger=self.logger)
self.engine = LiveExecutionEngine(
loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.instrument_provider = InstrumentProvider()
self.instrument_provider.add(AUDUSD_SIM)
self.instrument_provider.add(GBPUSD_SIM)
self.client = MockLiveExecutionClient(
name=SIM.value,
account_id=self.account_id,
engine=self.engine,
instrument_provider=self.instrument_provider,
clock=self.clock,
logger=self.logger,
)
self.engine.register_client(self.client)
def teardown(self):
self.engine.dispose()
self.loop.stop()
self.loop.close()
def test_start_when_loop_not_running_logs(self):
# Arrange
# Act
self.engine.start()
# Assert
assert True # No exceptions raised
self.engine.stop()
def test_get_event_loop_returns_expected_loop(self):
# Arrange
# Act
loop = self.engine.get_event_loop()
# Assert
assert loop == self.loop
def test_message_qsize_at_max_blocks_on_put_command(self):
# Arrange
self.engine = LiveExecutionEngine(
loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
config={"qsize": 1},
)
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
order.instrument_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.engine.execute(submit_order)
self.engine.execute(submit_order)
# Assert
assert self.engine.qsize() == 1
assert self.engine.command_count == 0
def test_message_qsize_at_max_blocks_on_put_event(self):
# Arrange
self.engine = LiveExecutionEngine(
loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
config={"qsize": 1},
)
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
order.instrument_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
event = TestStubs.event_order_submitted(order)
# Act
self.engine.execute(submit_order)
self.engine.process(event) # Add over max size
# Assert
assert self.engine.qsize() == 1
assert self.engine.command_count == 0
def test_start(self):
async def run_test():
# Arrange
# Act
self.engine.start()
await asyncio.sleep(0.1)
# Assert
assert self.engine.state == ComponentState.RUNNING
# Tear Down
self.engine.stop()
self.loop.run_until_complete(run_test())
def test_kill_when_running_and_no_messages_on_queues(self):
async def run_test():
# Arrange
# Act
self.engine.start()
await asyncio.sleep(0)
self.engine.kill()
# Assert
assert self.engine.state == ComponentState.STOPPED
self.loop.run_until_complete(run_test())
def test_kill_when_not_running_with_messages_on_queue(self):
async def run_test():
# Arrange
# Act
self.engine.kill()
# Assert
assert self.engine.qsize() == 0
self.loop.run_until_complete(run_test())
def test_execute_command_places_command_on_queue(self):
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
order.instrument_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.engine.execute(submit_order)
await asyncio.sleep(0.1)
# Assert
assert self.engine.qsize() == 0
assert self.engine.command_count == 1
# Tear Down
self.engine.stop()
self.loop.run_until_complete(run_test())
def test_handle_position_opening_with_position_id_none(self):
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
event = TestStubs.event_order_submitted(order)
# Act
self.engine.process(event)
await asyncio.sleep(0.1)
# Assert
assert self.engine.qsize() == 0
assert self.engine.event_count == 1
# Tear Down
self.engine.stop()
self.loop.run_until_complete(run_test())
def test_reconcile_state_with_no_active_orders(self):
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)
# Act
await self.engine.reconcile_state()
self.engine.stop()
# Assert
assert True # No exceptions raised
self.loop.run_until_complete(run_test())
def test_reconcile_state_when_report_agrees_reconciles(self):
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.ACCEPTED,
filled_qty=Quantity(0),
timestamp_ns=0,
)
self.client.add_order_status_report(report)
await asyncio.sleep(0.1) # Allow processing time
# Act
result = await self.engine.reconcile_state()
self.engine.stop()
# Assert
assert result
self.loop.run_until_complete(run_test())
def test_reconcile_state_when_cancelled_reconciles(self):
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.CANCELLED,
filled_qty=Quantity(0),
timestamp_ns=0,
)
self.client.add_order_status_report(report)
await asyncio.sleep(0.1) # Allow processing time
# Act
result = await self.engine.reconcile_state()
self.engine.stop()
# Assert
assert result
self.loop.run_until_complete(run_test())
def test_reconcile_state_when_expired_reconciles(self):
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
self.loop.run_until_complete(run_test())
def test_reconcile_state_when_partially_filled_reconciles(self):
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.PARTIALLY_FILLED,
filled_qty=Quantity(70000),
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(20000),
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
self.loop.run_until_complete(run_test())
def test_reconcile_state_when_filled_reconciles(self):
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
self.loop.run_until_complete(run_test())
class TestLiveExecutionClient:
def setup(self):
# Fixture Setup
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER", "000")
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S", "001"),
clock=self.clock,
)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
database = BypassExecutionDatabase(trader_id=self.trader_id,
logger=self.logger)
self.engine = LiveExecutionEngine(
loop=self.loop,
database=database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.client = MockLiveExecutionClient(
name=SIM.value,
account_id=self.account_id,
engine=self.engine,
instrument_provider=InstrumentProvider(),
clock=self.clock,
logger=self.logger,
)
self.engine.register_client(self.client)
def teardown(self):
self.client.dispose()
def test_reconcile_state_given_no_order_and_not_in_cache_returns_false(
self):
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
self.loop.run_until_complete(run_test())
def test_reconcile_state_when_order_completed_returns_true_with_warning1(
self):
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.stop_market(
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))
await asyncio.sleep(0) # Process queue
self.engine.process(TestStubs.event_order_accepted(order))
await asyncio.sleep(0) # Process queue
self.engine.process(TestStubs.event_order_cancelled(order))
await asyncio.sleep(0) # Process queue
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_state=OrderState.CANCELLED,
filled_qty=Quantity(0),
timestamp_ns=0,
)
# Act
result = await self.client.reconcile_state(report, order)
# Assert
assert result
self.loop.run_until_complete(run_test())
def test_reconcile_state_when_order_completed_returns_true_with_warning2(
self):
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))
await asyncio.sleep(0) # Process queue
self.engine.process(TestStubs.event_order_accepted(order))
await asyncio.sleep(0) # Process queue
self.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_state=OrderState.FILLED,
filled_qty=Quantity(100000),
timestamp_ns=0,
)
# Act
result = await self.client.reconcile_state(report, order)
# Assert
assert result
self.loop.run_until_complete(run_test())
def test_reconcile_state_with_filled_order_when_trades_not_given_returns_false(
self, ):
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))
await asyncio.sleep(0) # Process queue
self.engine.process(TestStubs.event_order_accepted(order))
await asyncio.sleep(0) # Process queue
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,
)
# Act
result = await self.client.reconcile_state(report, order)
# Assert
assert not result
self.loop.run_until_complete(run_test())
class TestLiveExecutionPerformance(PerformanceHarness):
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.trader_id = TraderId("TESTER", "000")
self.logger = Logger(self.clock, bypass_logging=True)
self.account_id = AccountId("BINANCE", "001")
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
database = BypassExecutionDatabase(trader_id=self.trader_id, logger=self.logger)
self.exec_engine = LiveExecutionEngine(
loop=self.loop,
database=database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
exec_client = MockExecutionClient(
client_id=ClientId("BINANCE"),
account_id=self.account_id,
engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
self.exec_engine.register_client(exec_client)
self.exec_engine.process(TestStubs.event_account_state(self.account_id))
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(self.strategy)
@pytest.fixture(autouse=True)
@pytest.mark.benchmark(disable_gc=True, warmup=True)
def setup_benchmark(self, benchmark):
self.benchmark = benchmark
def submit_order(self):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.id,
OrderSide.BUY,
Quantity("1.00000000"),
)
self.strategy.submit_order(order)
def test_execute_command(self):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.id,
OrderSide.BUY,
Quantity("1.00000000"),
)
command = SubmitOrder(
order.instrument_id.venue.client_id,
self.trader_id,
self.account_id,
self.strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
def execute_command():
self.exec_engine.execute(command)
self.benchmark.pedantic(execute_command, iterations=10_000, rounds=1)
# ~0.0ms / ~0.2μs / 218ns minimum of 10,000 runs @ 1 iteration each run.
def test_submit_order(self):
self.exec_engine.start()
time.sleep(0.1)
async def run_test():
def submit_order():
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.id,
OrderSide.BUY,
Quantity("1.00000000"),
)
self.strategy.submit_order(order)
self.benchmark.pedantic(submit_order, iterations=10_000, rounds=1)
self.loop.run_until_complete(run_test())
# ~0.0ms / ~25.3μs / 25326ns minimum of 10,000 runs @ 1 iteration each run.
def test_submit_order_end_to_end(self):
self.exec_engine.start()
time.sleep(0.1)
async def run_test():
for _ in range(10000):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.id,
OrderSide.BUY,
Quantity("1.00000000"),
)
self.strategy.submit_order(order)
stats_file = "perf_live_execution.prof"
cProfile.runctx(
"self.loop.run_until_complete(run_test())", globals(), locals(), stats_file
)
s = pstats.Stats(stats_file)
s.strip_dirs().sort_stats("time").print_stats()
class TestLiveRiskEngine:
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER-000")
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=self.clock,
)
self.random_order_factory = OrderFactory(
trader_id=TraderId("RANDOM-042"),
strategy_id=StrategyId("S-042"),
clock=self.clock,
)
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.exec_engine = LiveExecutionEngine(
loop=self.loop,
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.risk_engine = LiveRiskEngine(
loop=self.loop,
exec_engine=self.exec_engine,
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config={},
)
self.exec_client = MockExecutionClient(
client_id=ClientId("SIM"),
venue_type=VenueType.ECN,
account_id=TestStubs.account_id(),
account_type=AccountType.MARGIN,
base_currency=USD,
engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
# Wire up components
self.exec_engine.register_client(self.exec_client)
self.exec_engine.register_risk_engine(self.risk_engine)
def test_start_when_loop_not_running_logs(self):
# Arrange
# Act
self.risk_engine.start()
# Assert
assert True # No exceptions raised
self.risk_engine.stop()
def test_get_event_loop_returns_expected_loop(self):
# Arrange
# Act
loop = self.risk_engine.get_event_loop()
# Assert
assert loop == self.loop
def test_message_qsize_at_max_blocks_on_put_command(self):
# Arrange
self.risk_engine = LiveRiskEngine(
loop=self.loop,
exec_engine=self.exec_engine,
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config={"qsize": 1},
)
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
self.risk_engine.execute(submit_order)
# Assert
assert self.risk_engine.qsize() == 1
assert self.risk_engine.command_count == 0
def test_message_qsize_at_max_blocks_on_put_event(self):
# Arrange
self.risk_engine = LiveRiskEngine(
loop=self.loop,
exec_engine=self.exec_engine,
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config={"qsize": 1},
)
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
event = TestStubs.event_order_submitted(order)
# Act
self.risk_engine.execute(submit_order)
self.risk_engine.process(event) # Add over max size
# Assert
assert self.risk_engine.qsize() == 1
assert self.risk_engine.event_count == 0
def test_start(self):
async def run_test():
# Arrange
# Act
self.risk_engine.start()
await asyncio.sleep(0.1)
# Assert
assert self.risk_engine.state == ComponentState.RUNNING
# Tear Down
self.risk_engine.stop()
self.loop.run_until_complete(run_test())
def test_kill_when_running_and_no_messages_on_queues(self):
async def run_test():
# Arrange
# Act
self.risk_engine.start()
await asyncio.sleep(0)
self.risk_engine.kill()
# Assert
assert self.risk_engine.state == ComponentState.STOPPED
self.loop.run_until_complete(run_test())
def test_kill_when_not_running_with_messages_on_queue(self):
async def run_test():
# Arrange
# Act
self.risk_engine.kill()
# Assert
assert self.risk_engine.qsize() == 0
self.loop.run_until_complete(run_test())
def test_execute_command_places_command_on_queue(self):
async def run_test():
# Arrange
self.risk_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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
await asyncio.sleep(0.1)
# Assert
assert self.risk_engine.qsize() == 0
assert self.risk_engine.command_count == 1
# Tear Down
self.risk_engine.stop()
self.loop.run_until_complete(run_test())
def test_handle_position_opening_with_position_id_none(self):
async def run_test():
# Arrange
self.risk_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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
event = TestStubs.event_order_submitted(order)
# Act
self.risk_engine.process(event)
await asyncio.sleep(0.1)
# Assert
assert self.risk_engine.qsize() == 0
assert self.risk_engine.event_count == 1
# Tear Down
self.risk_engine.stop()
self.loop.run_until_complete(run_test())
class LiveExecutionTests(unittest.TestCase):
def setUp(self):
# Fixture Setup
trader_id = TraderId('TESTER', '000')
account_id = TestStubs.account_id()
clock = LiveClock()
guid_factory = LiveGuidFactory()
logger = LiveLogger()
self.command_server = MessageServer(
server_id=ServerId("CommandServer-001"),
recv_port=TEST_COMMANDS_REQ_PORT,
send_port=TEST_COMMANDS_REP_PORT,
header_serializer=MsgPackDictionarySerializer(),
request_serializer=MsgPackRequestSerializer(),
response_serializer=MsgPackResponseSerializer(),
compressor=CompressorBypass(),
encryption=EncryptionSettings(),
clock=clock,
guid_factory=guid_factory,
logger=LoggerAdapter('CommandServer', logger))
self.command_serializer = MsgPackCommandSerializer()
self.command_server_sink = []
self.command_server.register_handler(MessageType.COMMAND, self.command_handler)
self.command_server.start()
time.sleep(0.1)
self.portfolio = Portfolio(
currency=Currency.USD,
clock=clock,
guid_factory=guid_factory,
logger=logger)
self.analyzer = PerformanceAnalyzer()
self.exec_db = InMemoryExecutionDatabase(
trader_id=trader_id,
logger=logger)
self.exec_engine = LiveExecutionEngine(
trader_id=trader_id,
account_id=account_id,
database=self.exec_db,
portfolio=self.portfolio,
clock=clock,
guid_factory=guid_factory,
logger=logger)
self.exec_engine.handle_event(TestStubs.account_event())
self.exec_client = LiveExecClient(
exec_engine=self.exec_engine,
host=LOCALHOST,
command_req_port=TEST_COMMANDS_REQ_PORT,
command_res_port=TEST_COMMANDS_REP_PORT,
event_pub_port=TEST_EVENTS_PUB_PORT,
compressor=CompressorBypass(),
encryption=EncryptionSettings(),
command_serializer=MsgPackCommandSerializer(),
header_serializer=MsgPackDictionarySerializer(),
request_serializer=MsgPackRequestSerializer(),
response_serializer=MsgPackResponseSerializer(),
event_serializer=MsgPackEventSerializer(),
clock=clock,
guid_factory=guid_factory,
logger=logger)
self.exec_engine.register_client(self.exec_client)
self.exec_client.connect()
time.sleep(0.1)
self.bar_type = TestStubs.bartype_audusd_1min_bid()
self.strategy = TestStrategy1(self.bar_type, id_tag_strategy='001')
self.strategy.change_logger(logger)
self.exec_engine.register_strategy(self.strategy)
def tearDown(self):
# Tear Down
self.exec_client.disconnect()
self.command_server.stop()
# Allowing the garbage collector to clean up resources avoids threading
# errors caused by the continuous disposal of sockets. Thus for testing
# we're avoiding calling .dispose() on the sockets.
def command_handler(self, message):
command = self.command_serializer.deserialize(message)
self.command_server_sink.append(command)
def test_can_send_submit_order_command(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
# Act
self.strategy.submit_order(order, self.strategy.position_id_generator.generate())
time.sleep(0.3)
# # Assert
self.assertEqual(order, self.strategy.order(order.id))
self.assertEqual(2, self.command_server.recv_count)
self.assertEqual(1, self.command_server.sent_count)
self.assertEqual(SubmitOrder, type(self.command_server_sink[0]))
def test_can_send_submit_atomic_order(self):
# Arrange
atomic_order = self.strategy.order_factory.atomic_market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
Price(0.99900, 5))
# Act
self.strategy.submit_atomic_order(atomic_order, self.strategy.position_id_generator.generate())
time.sleep(0.3)
# Assert
self.assertEqual(atomic_order.entry, self.strategy.order(atomic_order.entry.id))
self.assertEqual(atomic_order.stop_loss, self.strategy.order(atomic_order.stop_loss.id))
self.assertEqual(2, self.command_server.recv_count)
self.assertEqual(1, self.command_server.sent_count)
self.assertEqual(SubmitAtomicOrder, type(self.command_server_sink[0]))
def test_can_send_cancel_order_command(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
# Act
self.strategy.submit_order(order, self.strategy.position_id_generator.generate())
self.strategy.cancel_order(order, 'SIGNAL_GONE')
time.sleep(0.3)
# Assert
self.assertEqual(order, self.strategy.order(order.id))
self.assertEqual(3, self.command_server.recv_count)
self.assertEqual(1, self.command_server.sent_count)
self.assertEqual(SubmitOrder, type(self.command_server_sink[0]))
self.assertEqual(CancelOrder, type(self.command_server_sink[1]))
def test_can_send_modify_order_command(self):
# Arrange
order = self.strategy.order_factory.limit(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
Price(1.00000, 5))
# Act
self.strategy.submit_order(order, self.strategy.position_id_generator.generate())
self.strategy.modify_order(order, Quantity(110000), Price(1.00001, 5))
time.sleep(0.3)
# Assert
self.assertEqual(order, self.strategy.order(order.id))
self.assertEqual(3, self.command_server.recv_count)
self.assertEqual(1, self.command_server.sent_count)
self.assertEqual(SubmitOrder, type(self.command_server_sink[0]))
self.assertEqual(ModifyOrder, type(self.command_server_sink[1]))
def test_can_send_account_inquiry_command(self):
# Arrange
# Act
self.strategy.account_inquiry()
time.sleep(0.3)
# Assert
self.assertEqual(2, self.command_server.recv_count)
self.assertEqual(1, self.command_server.sent_count)
self.assertEqual(AccountInquiry, type(self.command_server_sink[0]))