def test_submit_order_with_default_settings_then_sends_to_client(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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
# Assert
assert self.exec_engine.command_count == 1
assert self.exec_client.calls == ["_start", "submit_order"]
def test_submit_order_list_with_valid_order_successfully_submits(self):
# Arrange
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
bracket = strategy.order_factory.bracket_market(
USDJPY_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
stop_loss=Price.from_str("90.000"),
take_profit=Price.from_str("90.500"),
)
# Act
strategy.submit_order_list(bracket)
# Assert
assert bracket.orders[0] in strategy.cache.orders()
assert bracket.orders[1] in strategy.cache.orders()
assert bracket.orders[2] in strategy.cache.orders()
def test_flatten_position(self):
# Arrange
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.market(
USDJPY_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
strategy.submit_order(order)
self.exchange.process(0)
position = self.cache.positions_open()[0]
# Act
strategy.flatten_position(position)
self.exchange.process(0)
# Assert
assert order.status == OrderStatus.FILLED
assert strategy.portfolio.is_completely_flat()
def test_submit_order_when_instrument_not_in_cache_then_denies(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.market(
GBPUSD_SIM.id, # <-- not in the cache
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
# Assert
assert self.exec_engine.command_count == 0 # <-- command never reaches engine
def test_cancel_order_when_completed_does_not_submit_command(self):
# Arrange
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.stop_market(
USDJPY_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("90.006"),
)
strategy.submit_order(order)
self.exchange.process(0)
self.exec_engine.process(TestStubs.event_order_expired(order))
# Act
strategy.cancel_order(order)
self.exchange.process(0)
# Assert
assert strategy.cache.orders()[0].status == OrderStatus.EXPIRED
assert order not in strategy.cache.orders_working()
assert strategy.cache.order_exists(order.client_order_id)
assert not strategy.cache.is_order_working(order.client_order_id)
assert strategy.cache.is_order_completed(order.client_order_id)
def test_modify_order_when_no_changes_does_not_submit_command(self):
# Arrange
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(
USDJPY_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("90.001"),
)
strategy.submit_order(order)
# Act
strategy.modify_order(
order=order,
quantity=Quantity.from_int(100000),
price=Price.from_str("90.001"),
)
# Assert
assert self.exec_engine.command_count == 1
def test_submit_order_when_invalid_quantity_less_than_minimum_then_denies(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(1), # <- invalid quantity
Price.from_str("1.00000"),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
# Assert
assert self.exec_engine.command_count == 0 # <-- command never reaches engine
def test_submit_order_with_valid_order_successfully_submits(self):
# Arrange
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.market(
USDJPY_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
# Act
strategy.submit_order(order)
self.exchange.process(0)
# Assert
assert order in strategy.cache.orders()
assert strategy.cache.orders()[0].status == OrderStatus.FILLED
assert order.client_order_id not in strategy.cache.orders_working()
assert not strategy.cache.is_order_working(order.client_order_id)
assert strategy.cache.is_order_completed(order.client_order_id)
def test_submit_order_when_risk_bypassed_sends_to_execution_engine(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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
trader_id=self.trader_id,
strategy_id=strategy.id,
position_id=None,
order=order,
command_id=self.uuid_factory.generate(),
ts_init=self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
# Assert
assert self.exec_engine.command_count == 1 # <-- initial account event
assert self.exec_client.calls == ["_start", "submit_order"]
def test_update_order_when_no_order_found_denies(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,
)
modify = ModifyOrder(
self.trader_id,
strategy.id,
AUDUSD_SIM.id,
ClientOrderId("invalid"),
VenueOrderId("1"),
Quantity.from_int(100000),
Price.from_str("1.00010"),
None,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(modify)
# Assert
assert self.exec_client.calls == ["_start"]
assert self.risk_engine.command_count == 1
assert self.exec_engine.command_count == 0
def test_cancel_order_when_order_does_not_exist_then_denies(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,
)
cancel = CancelOrder(
self.trader_id,
strategy.id,
AUDUSD_SIM.id,
ClientOrderId("1"),
VenueOrderId("1"),
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(cancel)
# Assert
assert self.exec_client.calls == ["_start"]
assert self.risk_engine.command_count == 1
assert self.exec_engine.command_count == 0
def test_submit_bracket_order_when_instrument_not_in_cache_then_denies(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,
)
bracket = strategy.order_factory.bracket_market(
GBPUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
stop_loss=Price.from_str("1.00000"),
take_profit=Price.from_str("1.00010"),
)
submit_bracket = SubmitOrderList(
self.trader_id,
strategy.id,
bracket,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_bracket)
# Assert
assert self.exec_engine.command_count == 0 # <-- command never reaches engine
async def test_handle_position_opening_with_position_id_none(self):
# Arrange
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.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()
await self.risk_engine.get_run_queue_task()
def test_update_order_when_already_completed_then_denies(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.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00010"),
)
submit = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.risk_engine.execute(submit)
self.exec_engine.process(TestStubs.event_order_submitted(order))
self.exec_engine.process(TestStubs.event_order_accepted(order))
self.exec_engine.process(
TestStubs.event_order_filled(order, AUDUSD_SIM))
modify = ModifyOrder(
self.trader_id,
strategy.id,
order.instrument_id,
order.client_order_id,
VenueOrderId("1"),
order.quantity,
Price.from_str("1.00010"),
None,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(modify)
# Assert
assert self.exec_client.calls == ["_start", "submit_order"]
assert self.risk_engine.command_count == 2
assert self.exec_engine.command_count == 1
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
def test_submit_order_list_when_trading_halted_then_denies_orders(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,
)
entry = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
stop_loss = strategy.order_factory.stop_market( # <-- duplicate
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
take_profit = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.10000"),
)
bracket = OrderList(
list_id=OrderListId("1"),
orders=[entry, stop_loss, take_profit],
)
submit_bracket = SubmitOrderList(
self.trader_id,
strategy.id,
bracket,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Halt trading
self.risk_engine.set_trading_state(TradingState.HALTED)
# Act
self.risk_engine.execute(submit_bracket)
# Assert
assert self.risk_engine.command_count == 1 # <-- command never reaches engine
def test_cancel_order_when_already_pending_cancel_then_denies(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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
cancel = CancelOrder(
self.trader_id,
strategy.id,
order.instrument_id,
order.client_order_id,
VenueOrderId("1"),
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.risk_engine.execute(submit)
self.exec_engine.process(TestStubs.event_order_submitted(order))
self.exec_engine.process(TestStubs.event_order_accepted(order))
self.risk_engine.execute(cancel)
self.exec_engine.process(TestStubs.event_order_pending_cancel(order))
# Act
self.risk_engine.execute(cancel)
# Assert
assert self.exec_client.calls == [
"_start", "submit_order", "cancel_order"
]
assert self.risk_engine.command_count == 3
assert self.exec_engine.command_count == 2
def test_modify_order_with_default_settings_then_sends_to_client(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.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00010"),
)
submit = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
modify = ModifyOrder(
self.trader_id,
strategy.id,
order.instrument_id,
order.client_order_id,
VenueOrderId("1"),
order.quantity,
Price.from_str("1.00010"),
None,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.risk_engine.execute(submit)
# Act
self.risk_engine.execute(modify)
# Assert
assert self.exec_client.calls == [
"_start", "submit_order", "modify_order"
]
assert self.risk_engine.command_count == 2
assert self.exec_engine.command_count == 2
def trading_strategy():
strategy = TradingStrategy()
strategy.register(
trader_id=TraderId("TESTER-000"),
portfolio=TestComponentStubs.portfolio(),
msgbus=TestComponentStubs.msgbus(),
cache=TestComponentStubs.cache(),
logger=TestComponentStubs.logger(),
clock=TestComponentStubs.clock(),
)
return strategy
async def test_message_qsize_at_max_blocks_on_put_event(self):
# Arrange
# Deregister test fixture ExecutionEngine from msgbus)
self.msgbus.deregister(endpoint="ExecEngine.execute",
handler=self.exec_engine.execute)
self.msgbus.deregister(endpoint="ExecEngine.process",
handler=self.exec_engine.process)
self.exec_engine = LiveExecutionEngine(
loop=self.loop,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config=LiveExecEngineConfig(qsize=1),
)
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
event = TestStubs.event_order_submitted(order)
# Act
self.exec_engine.execute(submit_order)
self.exec_engine.process(event) # Add over max size
await asyncio.sleep(0.1)
# Assert
assert self.exec_engine.qsize() == 1
assert self.exec_engine.command_count == 0
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 test_message_qsize_at_max_blocks_on_put_command(self):
# Arrange
self.msgbus.deregister("RiskEngine.execute", self.risk_engine.execute)
self.risk_engine = LiveRiskEngine(
loop=self.loop,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config=LiveRiskEngineConfig(qsize=1),
)
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
self.risk_engine.execute(submit_order)
await asyncio.sleep(0.1)
# Assert
assert self.risk_engine.qsize() == 1
assert self.risk_engine.command_count == 0
def test_cancel_all_orders(self):
# Arrange
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
order1 = strategy.order_factory.stop_market(
USDJPY_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("90.007"),
)
order2 = strategy.order_factory.stop_market(
USDJPY_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("90.006"),
)
strategy.submit_order(order1)
self.exchange.process(0)
strategy.submit_order(order2)
self.exchange.process(0)
# Act
strategy.cancel_all_orders(USDJPY_SIM.id)
self.exchange.process(0)
# Assert
assert order1 in self.cache.orders()
assert order2 in self.cache.orders()
assert self.cache.orders()[0].status == OrderStatus.CANCELED
assert self.cache.orders()[1].status == OrderStatus.CANCELED
assert order1 in self.cache.orders_completed()
assert order2 in strategy.cache.orders_completed()
def test_load(self):
# Arrange
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
state = {}
# Act
strategy.load(state)
# Assert
# TODO: Write a users custom save method
assert True
def test_handle_trade_ticks_with_no_ticks_logs_and_continues(self):
# Arrange
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
ema = ExponentialMovingAverage(10)
strategy.register_indicator_for_trade_ticks(AUDUSD_SIM.id, ema)
# Act
strategy.handle_trade_ticks([])
# Assert
assert ema.count == 0
def test_submit_order_when_market_order_and_over_max_notional_then_denies(
self):
# Arrange
self.risk_engine.set_max_notional_per_order(AUDUSD_SIM.id, 1_000_000)
# Initialize market
quote = TestStubs.quote_tick_5decimal(AUDUSD_SIM.id)
self.cache.add_quote_tick(quote)
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(10000000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
# Assert
assert self.exec_engine.command_count == 0 # <-- command never reaches engine
async def test_reconcile_state_with_no_active_orders(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,
)
# Act
await self.exec_engine.reconcile_state(timeout_secs=10)
self.exec_engine.stop()
await asyncio.sleep(0.1)
# Assert
assert True # No exceptions raised
def test_handle_bars_with_no_bars_logs_and_continues(self):
# Arrange
bar_type = TestStubs.bartype_gbpusd_1sec_mid()
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
ema = ExponentialMovingAverage(10)
strategy.register_indicator_for_bars(bar_type, ema)
# Act
strategy.handle_bars([])
# Assert
assert ema.count == 0
async def test_execute_command_places_command_on_queue(self):
# Arrange
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.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
None,
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()
await self.risk_engine.get_run_queue_task()
def test_handle_bars_updates_indicator_registered_for_bars(self):
# Arrange
bar_type = TestStubs.bartype_audusd_1min_bid()
strategy = TradingStrategy()
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
ema = ExponentialMovingAverage(10)
strategy.register_indicator_for_bars(bar_type, ema)
bar = TestStubs.bar_5decimal()
# Act
strategy.handle_bars([bar])
# Assert
assert ema.count == 1
