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_cancel_order(self):
# Arrange
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
clock=self.clock,
uuid_factory=self.uuid_factory,
logger=self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.stop(
USDJPY_FXCM,
OrderSide.BUY,
Quantity(100000),
Price("90.005"),
)
strategy.submit_order(order)
# Act
strategy.cancel_order(order)
# Assert
self.assertTrue(order in strategy.execution.orders())
self.assertEqual(OrderState.CANCELLED, strategy.execution.orders()[0].state())
self.assertEqual(order.cl_ord_id, strategy.execution.orders_completed()[0].cl_ord_id)
self.assertTrue(order.cl_ord_id not in strategy.execution.orders_working())
self.assertTrue(strategy.execution.order_exists(order.cl_ord_id))
self.assertFalse(strategy.execution.is_order_working(order.cl_ord_id))
self.assertTrue(strategy.execution.is_order_completed(order.cl_ord_id))
def test_can_cancel_order(self):
# Arrange
strategy = TradingStrategy(order_id_tag='001')
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.stop(USDJPY_FXCM, OrderSide.BUY,
Quantity(100000), Price(90.005, 3))
strategy.submit_order(order, strategy.position_id_generator.generate())
# Act
strategy.cancel_order(order)
# Assert
self.assertEqual(order, strategy.orders()[order.id])
self.assertEqual(OrderState.CANCELLED,
strategy.orders()[order.id].state)
self.assertTrue(order.id in strategy.orders_completed())
self.assertTrue(order.id not in strategy.orders_working())
self.assertTrue(strategy.order_exists(order.id))
self.assertFalse(strategy.is_order_working(order.id))
self.assertTrue(strategy.is_order_completed(order.id))