def test_can_initialize_atomic_order_market_with_no_take_profit_or_label(
self):
# Arrange
# Act
atomic_order = self.order_factory.atomic_market(
AUDUSD_FXCM, OrderSide.BUY, Quantity(100000), Price(0.99990, 5))
# Assert
self.assertEqual(AUDUSD_FXCM, atomic_order.stop_loss.symbol)
self.assertFalse(atomic_order.has_take_profit)
self.assertEqual(OrderId('O-19700101-000000-001-001-1'),
atomic_order.entry.id)
self.assertEqual(OrderId('O-19700101-000000-001-001-2'),
atomic_order.stop_loss.id)
self.assertEqual(OrderSide.SELL, atomic_order.stop_loss.side)
self.assertEqual(Quantity(100000), atomic_order.entry.quantity)
self.assertEqual(Quantity(100000), atomic_order.stop_loss.quantity)
self.assertEqual(Price(0.99990, 5), atomic_order.stop_loss.price)
self.assertEqual(None, atomic_order.entry.label)
self.assertEqual(None, atomic_order.stop_loss.label)
self.assertEqual(TimeInForce.GTC, atomic_order.stop_loss.time_in_force)
self.assertEqual(None, atomic_order.entry.expire_time)
self.assertEqual(None, atomic_order.stop_loss.expire_time)
self.assertEqual(AtomicOrderId('AO-19700101-000000-001-001-1'),
atomic_order.id)
self.assertEqual(UNIX_EPOCH, atomic_order.timestamp)
def test_can_track_orders_for_an_opened_position(self):
# Arrange
bar_type = TestStubs.bartype_audusd_1min_bid()
strategy = TestStrategy1(bar_type)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(USDJPY_FXCM, OrderSide.BUY,
Quantity(100000))
strategy.submit_order(order, strategy.position_id_generator.generate())
# Act
# Assert
self.assertTrue(
OrderId('O-19700101-000000-000-001-1') in strategy.orders())
self.assertTrue(
PositionId('P-19700101-000000-000-001-1') in strategy.positions())
self.assertEqual(0, len(strategy.orders_working()))
self.assertEqual(order, strategy.orders_completed()[order.id])
self.assertEqual(0, len(strategy.positions_closed()))
self.assertTrue(
OrderId('O-19700101-000000-000-001-1') in
strategy.orders_completed())
self.assertTrue(
PositionId('P-19700101-000000-000-001-1') in
strategy.positions_open())
self.assertFalse(strategy.is_flat())
def test_apply_order_amended_event_to_stop_order(self):
# Arrange
order = self.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
order.apply(TestStubs.event_order_submitted(order))
order.apply(TestStubs.event_order_accepted(order))
amended = OrderAmended(
self.account_id,
order.cl_ord_id,
OrderId("1"),
Quantity(120000),
Price("1.00001"),
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
order.apply(amended)
# Assert
self.assertEqual(OrderState.ACCEPTED, order.state)
self.assertEqual(OrderId("1"), order.id)
self.assertEqual(Quantity(120000), order.quantity)
self.assertEqual(Price("1.00001"), order.price)
self.assertTrue(order.is_active)
self.assertTrue(order.is_working)
self.assertFalse(order.is_completed)
self.assertEqual(4, order.event_count)
def test_generate_order_id(self):
# Arrange
# Act
result1 = self.order_id_generator.generate()
result2 = self.order_id_generator.generate()
result3 = self.order_id_generator.generate()
# Assert
self.assertEqual(OrderId('O-19700101-000000-001-001-1'), result1)
self.assertEqual(OrderId('O-19700101-000000-001-001-2'), result2)
self.assertEqual(OrderId('O-19700101-000000-001-001-3'), result3)
def test_serialize_and_deserialize_order_working_events_with_expire_time(
self):
# Arrange
event = OrderWorking(
self.account_id,
ClientOrderId("O-123456"),
OrderId("B-123456"),
AUDUSD_SIM.symbol,
OrderSide.SELL,
OrderType.STOP_MARKET,
Quantity(100000),
Price("1.50000"),
TimeInForce.DAY,
UNIX_EPOCH,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
def test_can_apply_order_working_event_to_stop_order(self):
# Arrange
order = self.order_factory.stop(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
order.apply(submitted)
order.apply(accepted)
# Act
order.apply(working)
# Assert
# print(order)
self.assertEqual(OrderState.WORKING, order.state())
self.assertEqual(OrderId("1"), order.id)
self.assertFalse(order.is_completed())
self.assertTrue(order.is_working())
self.assertEqual(None, order.filled_timestamp)
def test_order_working(self):
# Arrange
uuid = uuid4()
event = OrderWorking(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
symbol=Symbol("BTC/USDT", Exchange("BINANCE")),
order_side=OrderSide.BUY,
order_type=OrderType.LIMIT,
quantity=Quantity("0.561000"),
price=Price("21015.00"),
time_in_force=TimeInForce.DAY,
expire_time=None,
working_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
self.assertEqual(
f"OrderWorking(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, BUY 0.561000 BTC/USDT.BINANCE LIMIT @ 21015.00 DAY, "
f"id={uuid})", str(event))
self.assertEqual(
f"OrderWorking(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, BUY 0.561000 BTC/USDT.BINANCE LIMIT @ 21015.00 DAY, "
f"id={uuid})", repr(event))
def test_serialize_and_deserialize_order_filled_events(self):
# Arrange
event = OrderFilled(
self.account_id,
ClientOrderId("O-123456"),
OrderId("1"),
ExecutionId("E123456"),
PositionId("T123456"),
StrategyId("S", "001"),
AUDUSD_SIM.symbol,
OrderSide.SELL,
Quantity(100000),
Quantity(100000),
Quantity(),
Price("1.00000"),
AUDUSD_SIM.quote_currency,
AUDUSD_SIM.is_inverse,
Money(0, USD),
LiquiditySide.TAKER,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
def test_get_position_when_no_position_returns_none(self):
# Arrange
order_id = OrderId('O-201908080101-000-001')
# Act
result = self.database.get_order(order_id)
# Assert
self.assertIsNone(result)
def test_mixed_identifier_equality(self):
# Arrange
id1 = OrderId('O-123456')
id2 = PositionId('P-123456')
# Act
# Assert
self.assertTrue(id1 == id1)
self.assertFalse(id1 == id2)
def test_getting_order_which_does_not_exist_returns_none(self):
# Arrange
strategy = TradingStrategy(order_id_tag='001')
self.exec_engine.register_strategy(strategy)
# Act
result = strategy.order(OrderId('O-123456'))
# Assert
self.assertIsNone(result)
def event_order_expired(order) -> OrderExpired:
return OrderExpired(
TestStubs.account_id(),
order.cl_ord_id,
OrderId("1"),
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
def test_position_filled_with_buy_order_returns_expected_attributes(self):
# Arrange
order = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
order_filled = OrderFilled(
self.account_id,
order.id,
ExecutionId('E123456'),
PositionIdBroker('T123456'),
order.symbol,
order.side,
order.quantity,
Price(1.00001, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
last = Tick(AUDUSD_FXCM,
Price(1.00050, 5),
Price(1.00048, 5),
Volume(1),
Volume(1),
UNIX_EPOCH)
# Act
position = Position(PositionId('P-123456'), order_filled)
# Assert
self.assertEqual(OrderId('O-19700101-000000-001-001-1'), position.from_order_id)
self.assertEqual(Quantity(100000), position.quantity)
self.assertEqual(Quantity(100000), position.peak_quantity)
self.assertEqual(OrderSide.BUY, position.entry_direction)
self.assertEqual(MarketPosition.LONG, position.market_position)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertIsNone(position.open_duration)
self.assertEqual(1.00001, position.average_open_price)
self.assertEqual(1, position.event_count)
self.assertEqual([order.id], position.get_order_ids())
self.assertEqual([ExecutionId('E123456')], position.get_execution_ids())
self.assertEqual(ExecutionId('E123456'), position.last_execution_id)
self.assertEqual(PositionIdBroker('T123456'), position.id_broker)
self.assertTrue(position.is_long)
self.assertFalse(position.is_short)
self.assertFalse(position.is_closed)
self.assertEqual(0.0, position.realized_points)
self.assertEqual(0.0, position.realized_return)
self.assertEqual(Money(0, Currency.USD), position.realized_pnl)
self.assertEqual(0.0004899999999998794, position.unrealized_points(last))
self.assertEqual(0.0004899951000488789, position.unrealized_return(last))
self.assertEqual(Money(49.00, Currency.USD), position.unrealized_pnl(last))
self.assertEqual(0.0004899999999998794, position.total_points(last))
self.assertEqual(0.0004899951000488789, position.total_return(last))
self.assertEqual(Money(49.00, Currency.USD), position.total_pnl(last))
def event_order_accepted(order, order_id=None) -> OrderAccepted:
if order_id is None:
order_id = OrderId("1")
return OrderAccepted(
TestStubs.account_id(),
order.cl_ord_id,
order_id,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
def test_can_reset_order_factory(self):
# Arrange
self.order_factory.limit(AUDUSD_FXCM, OrderSide.BUY, Quantity(100000),
Price(1.00000, 5))
# Act
self.order_factory.reset()
order2 = self.order_factory.limit(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000), Price(1.00000, 5))
self.assertEqual(OrderId('O-19700101-000000-001-001-1'), order2.id)
def test_can_reset_id_generator(self):
# Arrange
self.order_id_generator.generate()
self.order_id_generator.generate()
self.order_id_generator.generate()
# Act
self.order_id_generator.reset()
result1 = self.order_id_generator.generate()
# Assert
self.assertEqual(OrderId('O-19700101-000000-001-001-1'), result1)
def test_stop_order_with_zero_price_input_raises_exception(self):
# Arrange
# Act
self.assertRaises(ValueError,
Order,
OrderId('O-123456'),
AUDUSD_FXCM,
OrderSide.BUY,
OrderType.STOP,
Quantity(100000),
GUID(uuid.uuid4()),
UNIX_EPOCH,
price=None)
def test_market_order_with_price_input_raises_exception(self):
# Arrange
# Act
self.assertRaises(ValueError,
Order,
OrderId('O-123456'),
AUDUSD_FXCM,
OrderSide.BUY,
OrderType.MARKET,
Quantity(100000),
GUID(uuid.uuid4()),
UNIX_EPOCH,
price=Price(1.00000, 5))
def test_apply_order_modified_event_to_stop_order(self):
# Arrange
order = self.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
modified = OrderModified(
self.account_id,
order.cl_ord_id,
OrderId("1"),
Quantity(120000),
Price("1.00001"),
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
order.apply(submitted)
order.apply(accepted)
order.apply(working)
# Act
order.apply(modified)
# Assert
self.assertEqual(OrderState.WORKING, order.state)
self.assertEqual(OrderId("1"), order.id)
self.assertEqual(Quantity(120000), order.quantity)
self.assertEqual(Price("1.00001"), order.price)
self.assertTrue(order.is_working)
self.assertFalse(order.is_completed)
self.assertEqual(5, order.event_count)
def test_apply_order_partially_filled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
partially = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("1"),
ExecutionId("E-1"),
PositionId("P-1"),
StrategyId.null(),
order.symbol,
order.side,
Quantity(50000),
Quantity(50000),
Quantity(50000),
Price("0.999999"),
AUDUSD_SIM.quote_currency,
AUDUSD_SIM.is_inverse,
Money(0, USD),
LiquiditySide.MAKER,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
order.apply(submitted)
order.apply(accepted)
order.apply(working)
# Act
order.apply(partially)
# Assert
self.assertEqual(OrderState.PARTIALLY_FILLED, order.state)
self.assertEqual(Quantity(50000), order.filled_qty)
self.assertEqual(Price("1.00000"), order.price)
self.assertEqual(Decimal("0.999999"), order.avg_price)
self.assertEqual(Decimal("-0.000001"), order.slippage)
self.assertFalse(order.is_completed)
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_cancel_order_raises_not_implemented_error(self):
# Arrange
# Act
command = CancelOrder(
self.venue,
self.trader_id,
self.account_id,
ClientOrderId("O-123456789"),
OrderId("001"),
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Assert
self.assertRaises(NotImplementedError, self.client.cancel_order, command)
def test_can_apply_order_filled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"))
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
filled = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("1"),
ExecutionId("E-1"),
PositionId("P-1"),
StrategyId("S", "NULL"),
order.symbol,
order.side,
order.quantity,
Quantity(),
Price("1.00001"),
Money(0, USD),
LiquiditySide.MAKER,
USD,
USD,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
order.apply(submitted)
order.apply(accepted)
order.apply(working)
# Act
order.apply(filled)
# Assert
self.assertEqual(OrderState.FILLED, order.state())
self.assertEqual(Quantity(100000), order.filled_qty)
self.assertEqual(Price("1.00000"), order.price)
self.assertEqual(Price("1.00001"), order.avg_price)
self.assertEqual(Decimal("0.00001"), order.slippage)
self.assertTrue(order.is_completed())
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_priced_order_with_GTD_time_in_force_and_expire_time_none_raises_exception(
self):
# Arrange
# Act
self.assertRaises(ValueError,
Order,
OrderId('O-123456'),
AUDUSD_FXCM,
OrderSide.BUY,
OrderType.LIMIT,
Quantity(100000),
GUID(uuid.uuid4()),
UNIX_EPOCH,
price=Price(1.00000, 5),
time_in_force=TimeInForce.GTD,
expire_time=None)
def test_order_expired(self):
# Arrange
uuid = uuid4()
event = OrderExpired(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
expired_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
assert f"OrderExpired(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id=123456, event_id={uuid})" == str(
event)
assert f"OrderExpired(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id=123456, event_id={uuid})" == repr(
event)
def event_order_filled(
order,
instrument,
position_id=None,
strategy_id=None,
fill_price=None,
fill_qty=None,
liquidity_side=LiquiditySide.TAKER,
) -> OrderFilled:
if position_id is None:
position_id = PositionId(order.cl_ord_id.value.replace("P", "T"))
if strategy_id is None:
strategy_id = StrategyId.null()
if fill_price is None:
fill_price = Price("1.00000")
if fill_qty is None:
fill_qty = order.quantity
commission = instrument.calculate_commission(
quantity=order.quantity,
avg_price=fill_price,
liquidity_side=liquidity_side,
)
return OrderFilled(
account_id=TestStubs.account_id(),
cl_ord_id=order.cl_ord_id,
order_id=OrderId("1"),
execution_id=ExecutionId(order.cl_ord_id.value.replace("O", "E")),
position_id=position_id,
strategy_id=strategy_id,
symbol=order.symbol,
order_side=order.side,
fill_qty=fill_qty,
cum_qty=Quantity(order.filled_qty + fill_qty),
leaves_qty=Quantity(
max(0, order.quantity - order.filled_qty - fill_qty)),
fill_price=order.price if fill_price is None else fill_price,
currency=instrument.quote_currency,
is_inverse=instrument.is_inverse,
commission=commission,
liquidity_side=liquidity_side,
execution_time=UNIX_EPOCH,
event_id=uuid4(),
event_timestamp=UNIX_EPOCH,
)
def test_order_cancelled(self):
# Arrange
uuid = uuid4()
event = OrderCancelled(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
cancelled_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
self.assertEqual(f"OrderCancelled(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, event_id={uuid})", str(event))
self.assertEqual(f"OrderCancelled(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, event_id={uuid})", repr(event))
def test_apply_order_filled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
order.apply(TestStubs.event_order_submitted(order))
order.apply(TestStubs.event_order_accepted(order))
filled = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("1"),
ExecutionId("E-1"),
PositionId("P-1"),
StrategyId.null(),
order.instrument_id,
order.side,
order.quantity,
order.quantity,
Quantity(),
Price("1.00001"),
AUDUSD_SIM.quote_currency,
AUDUSD_SIM.is_inverse,
Money(0, USD),
LiquiditySide.MAKER,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
order.apply(filled)
# Assert
self.assertEqual(OrderState.FILLED, order.state)
self.assertEqual(Quantity(100000), order.filled_qty)
self.assertEqual(Price("1.00000"), order.price)
self.assertEqual(Decimal("1.00001"), order.avg_price)
self.assertEqual(Decimal("0.00001"), order.slippage)
self.assertFalse(order.is_working)
self.assertTrue(order.is_completed)
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_cancel_stop_order_when_order_does_not_exist_generates_cancel_reject(self):
# Arrange
command = CancelOrder(
venue=SIM,
trader_id=self.trader_id,
account_id=self.account_id,
cl_ord_id=ClientOrderId("O-123456"),
order_id=OrderId("001"),
command_id=self.uuid_factory.generate(),
command_timestamp=UNIX_EPOCH,
)
# Act
self.exchange.handle_cancel_order(command)
# Assert
self.assertEqual(2, self.exec_engine.event_count)
def test_serialize_and_deserialize_order_expired_events(self):
# Arrange
event = OrderExpired(
self.account_id,
ClientOrderId("O-123456"),
OrderId("1"),
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
def event_order_working(order, working_price=None) -> OrderWorking:
if working_price is None:
working_price = Price("1.00000")
return OrderWorking(
TestStubs.account_id(),
order.cl_ord_id,
OrderId("1"),
order.symbol,
order.side,
order.type,
order.quantity,
order.price if working_price is None else working_price,
order.time_in_force,
order.expire_time,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)