def test_initialize_bracket_order_market_with_no_take_profit(self):
# Arrange
entry_order = self.order_factory.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
# Act
bracket_order = self.order_factory.bracket(entry_order,
Price("0.99990"))
# Assert
self.assertEqual(AUDUSD_SIM.symbol, bracket_order.stop_loss.symbol)
self.assertFalse(bracket_order.take_profit is not None)
self.assertEqual(ClientOrderId("O-19700101-000000-000-001-1"),
bracket_order.entry.cl_ord_id)
self.assertEqual(ClientOrderId("O-19700101-000000-000-001-2"),
bracket_order.stop_loss.cl_ord_id)
self.assertEqual(OrderSide.SELL, bracket_order.stop_loss.side)
self.assertEqual(Quantity(100000), bracket_order.entry.quantity)
self.assertEqual(Quantity(100000), bracket_order.stop_loss.quantity)
self.assertEqual(Price("0.99990"), bracket_order.stop_loss.price)
self.assertEqual(TimeInForce.GTC,
bracket_order.stop_loss.time_in_force)
self.assertEqual(None, bracket_order.stop_loss.expire_time)
self.assertEqual(BracketOrderId("BO-19700101-000000-000-001-1"),
bracket_order.id)
self.assertEqual(UNIX_EPOCH, bracket_order.timestamp)
def test_order_initialized_event_to_from_dict_and_str_repr(self):
# Arrange
uuid = UUID4()
event = OrderInitialized(
trader_id=TraderId("TRADER-001"),
strategy_id=StrategyId("SCALPER-001"),
instrument_id=InstrumentId(Symbol("BTC/USDT"), Venue("BINANCE")),
client_order_id=ClientOrderId("O-2020872378423"),
order_side=OrderSide.BUY,
order_type=OrderType.LIMIT,
quantity=Quantity.from_str("0.561000"),
time_in_force=TimeInForce.DAY,
reduce_only=True,
options={"price": "15200.10"},
order_list_id=OrderListId("1"),
parent_order_id=None,
child_order_ids=[ClientOrderId("O-2020872378424")],
contingency=ContingencyType.OTO,
contingency_ids=[ClientOrderId("O-2020872378424")],
tags="ENTRY",
event_id=uuid,
ts_init=0,
)
# Act, Assert
assert OrderInitialized.from_dict(
OrderInitialized.to_dict(event)) == event
assert (
str(event) ==
f"OrderInitialized(instrument_id=BTC/USDT.BINANCE, client_order_id=O-2020872378423, side=BUY, type=LIMIT, quantity=0.561000, time_in_force=DAY, reduce_only=True, options={{'price': '15200.10'}}, order_list_id=1, parent_order_id=None, child_order_ids=['O-2020872378424'], contingency=OTO, contingency_ids=['O-2020872378424'], tags=ENTRY)" # noqa
)
assert (
repr(event) ==
f"OrderInitialized(trader_id=TRADER-001, strategy_id=SCALPER-001, instrument_id=BTC/USDT.BINANCE, client_order_id=O-2020872378423, side=BUY, type=LIMIT, quantity=0.561000, time_in_force=DAY, reduce_only=True, options={{'price': '15200.10'}}, order_list_id=1, parent_order_id=None, child_order_ids=['O-2020872378424'], contingency=OTO, contingency_ids=['O-2020872378424'], tags=ENTRY, event_id={uuid}, ts_init=0)" # noqa
)
def test_serialize_and_deserialize_stop_market_order_initialized_events(self):
# Arrange
options = {
"trigger_price": "1.0005",
}
event = OrderInitialized(
self.trader_id,
self.strategy_id,
AUDUSD_SIM.id,
ClientOrderId("O-123456"),
OrderSide.SELL,
OrderType.STOP_MARKET,
Quantity(100000, precision=0),
TimeInForce.DAY,
post_only=False,
reduce_only=True,
options=options,
order_list_id=OrderListId("1"),
contingency_type=ContingencyType.OTO,
linked_order_ids=[ClientOrderId("O-123457"), ClientOrderId("O-123458")],
parent_order_id=ClientOrderId("O-123455"),
tags=None,
event_id=UUID4(),
ts_init=0,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == event
assert deserialized.options == options
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
assert result1 == ClientOrderId("O-19700101-000000-001-001-1")
assert result2 == ClientOrderId("O-19700101-000000-001-001-2")
assert result3 == ClientOrderId("O-19700101-000000-001-001-3")
def test_initialize_bracket_order(self):
# Arrange
entry_order = self.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("0.99995"),
)
# Act
bracket_order = self.order_factory.bracket(
entry_order,
Price.from_str("0.99990"),
Price.from_str("1.00010"),
TimeInForce.GTC,
TimeInForce.GTC,
)
# Assert
self.assertEqual(AUDUSD_SIM.id, bracket_order.stop_loss.instrument_id)
self.assertTrue(bracket_order.take_profit is not None)
self.assertEqual(AUDUSD_SIM.id,
bracket_order.take_profit.instrument_id)
self.assertEqual(
ClientOrderId("O-19700101-000000-000-001-1"),
bracket_order.entry.client_order_id,
)
self.assertEqual(
ClientOrderId("O-19700101-000000-000-001-2"),
bracket_order.stop_loss.client_order_id,
)
self.assertEqual(
ClientOrderId("O-19700101-000000-000-001-3"),
bracket_order.take_profit.client_order_id,
)
self.assertEqual(OrderSide.SELL, bracket_order.stop_loss.side)
self.assertEqual(OrderSide.SELL, bracket_order.take_profit.side)
self.assertEqual(Quantity.from_int(100000),
bracket_order.stop_loss.quantity)
self.assertEqual(Quantity.from_int(100000),
bracket_order.take_profit.quantity)
self.assertEqual(Price.from_str("0.99990"),
bracket_order.stop_loss.price)
self.assertEqual(Price.from_str("1.00010"),
bracket_order.take_profit.price)
self.assertEqual(TimeInForce.GTC,
bracket_order.stop_loss.time_in_force)
self.assertEqual(TimeInForce.GTC,
bracket_order.take_profit.time_in_force)
self.assertEqual(None, bracket_order.entry.expire_time)
self.assertEqual(None, bracket_order.stop_loss.expire_time)
self.assertEqual(None, bracket_order.take_profit.expire_time)
self.assertEqual(ClientOrderLinkId("BO-19700101-000000-000-001-1"),
bracket_order.id)
self.assertEqual(0, bracket_order.timestamp_ns)
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(ClientOrderId("O-19700101-000000-001-001-1"), result1)
self.assertEqual(ClientOrderId("O-19700101-000000-001-001-2"), result2)
self.assertEqual(ClientOrderId("O-19700101-000000-001-001-3"), result3)
async def test_reconcile_state_no_cached_with_partially_filled_order_and_trade(
self):
# Arrange
venue_order_id = VenueOrderId("1")
order_report = OrderStatusReport(
account_id=self.account_id,
instrument_id=AUDUSD_SIM.id,
client_order_id=ClientOrderId("O-123456"),
venue_order_id=venue_order_id,
order_side=OrderSide.BUY,
order_type=OrderType.LIMIT,
time_in_force=TimeInForce.GTC,
order_status=OrderStatus.PARTIALLY_FILLED,
price=Price.from_str("1.00000"),
quantity=Quantity.from_int(10_000),
filled_qty=Quantity.from_int(5_000),
avg_px=Decimal("1.00000"),
post_only=True,
report_id=UUID4(),
ts_accepted=0,
ts_triggered=0,
ts_last=0,
ts_init=0,
)
trade_report = TradeReport(
account_id=self.account_id,
instrument_id=AUDUSD_SIM.id,
client_order_id=ClientOrderId("O-123456"),
venue_order_id=venue_order_id,
venue_position_id=None,
trade_id=TradeId("1"),
order_side=OrderSide.BUY,
last_qty=Quantity.from_int(5_000),
last_px=Price.from_str("1.00000"),
commission=Money(0, USD),
liquidity_side=LiquiditySide.MAKER,
report_id=UUID4(),
ts_event=0,
ts_init=0,
)
self.client.add_order_status_report(order_report)
self.client.add_trade_reports(venue_order_id, [trade_report])
# Act
result = await self.exec_engine.reconcile_state()
# Assert
assert result
assert len(self.cache.orders()) == 1
assert self.cache.orders()[0].status == OrderStatus.PARTIALLY_FILLED
def test_add_trade_reports(self):
report_id1 = UUID4()
mass_status = ExecutionMassStatus(
client_id=ClientId("IB"),
account_id=AccountId("IB", "U123456789"),
venue=Venue("IDEALPRO"),
report_id=report_id1,
ts_init=0,
)
report_id2 = UUID4()
report1 = TradeReport(
account_id=AccountId("IB", "U123456789"),
instrument_id=AUDUSD_IDEALPRO,
client_order_id=ClientOrderId("O-123456789"),
venue_order_id=VenueOrderId("1"),
venue_position_id=PositionId("2"),
trade_id=TradeId("3"),
order_side=OrderSide.BUY,
last_qty=Quantity.from_int(100),
last_px=Price.from_str("100.50"),
commission=Money("4.50", USD),
liquidity_side=LiquiditySide.TAKER,
report_id=report_id2,
ts_event=0,
ts_init=0,
)
report_id3 = UUID4()
report2 = TradeReport(
account_id=AccountId("IB", "U123456789"),
instrument_id=AUDUSD_IDEALPRO,
client_order_id=ClientOrderId("O-123456790"),
venue_order_id=VenueOrderId("1"),
venue_position_id=PositionId("2"),
trade_id=TradeId("4"),
order_side=OrderSide.BUY,
last_qty=Quantity.from_int(100),
last_px=Price.from_str("100.60"),
commission=Money("4.50", USD),
liquidity_side=LiquiditySide.TAKER,
report_id=report_id3,
ts_event=0,
ts_init=0,
)
# Act
mass_status.add_trade_reports([report1, report2])
# Assert
assert mass_status.trade_reports()[VenueOrderId("1")] == [report1, report2]
async def test_reconcile_state_no_cached_with_triggered_order(self):
# Arrange
report = OrderStatusReport(
account_id=self.account_id,
instrument_id=AUDUSD_SIM.id,
client_order_id=ClientOrderId("O-123456"),
venue_order_id=VenueOrderId("1"),
order_side=OrderSide.BUY,
order_type=OrderType.STOP_LIMIT,
time_in_force=TimeInForce.GTC,
order_status=OrderStatus.TRIGGERED,
price=Price.from_str("0.99500"),
trigger_price=Price.from_str("1.00000"),
trigger_type=TriggerType.BID_ASK,
offset_type=TrailingOffsetType.PRICE,
quantity=Quantity.from_int(10_000),
filled_qty=Quantity.from_int(0),
post_only=True,
report_id=UUID4(),
ts_accepted=1_000_000_000,
ts_triggered=2_000_000_000,
ts_last=2_000_000_000,
ts_init=3_000_000_000,
)
self.client.add_order_status_report(report)
# Act
result = await self.exec_engine.reconcile_state()
# Assert
assert result
assert len(self.cache.orders()) == 1
assert len(self.cache.orders_open()) == 1
assert self.cache.orders()[0].status == OrderStatus.TRIGGERED
async def test_order_multiple_fills(self):
# Arrange
self.exec_engine.start()
client_order_id = ClientOrderId("1")
venue_order_id = VenueOrderId("246938411724")
submitted = BetfairTestStubs.make_submitted_order(
client_order_id=client_order_id, quantity=Quantity.from_int(20))
self.cache.add_order(submitted,
position_id=BetfairTestStubs.position_id())
self.client.venue_order_id_to_client_order_id[
venue_order_id] = client_order_id
# Act
for update in BetfairStreaming.ocm_multiple_fills():
await self.client._handle_order_stream_update(update)
await asyncio.sleep(0.1)
# Assert
result = [fill.last_qty for fill in self.messages]
expected = [
Quantity.from_str("16.1900"),
Quantity.from_str("0.77"),
Quantity.from_str("0.77"),
]
assert result == expected
def _setup_exec_client_and_cache(self, update):
"""
Called before processing a test streaming update - ensure all orders are in the cache in `update`.
"""
venue_order_ids = self._prefill_venue_order_id_to_client_order_id(
update)
venue_order_id_to_client_order_id = {}
for c_id, v_id in enumerate(venue_order_ids):
client_order_id = ClientOrderId(str(c_id))
venue_order_id = VenueOrderId(str(v_id))
self._log.debug(
f"Adding client_order_id=[{c_id}], venue_order_id=[{v_id}] ")
order = BetfairTestStubs.make_accepted_order(
venue_order_id=venue_order_id, client_order_id=client_order_id)
self._log.debug(f"created order: {order}")
venue_order_id_to_client_order_id[v_id] = order.client_order_id
cache_order = self.cache.order(
client_order_id=order.client_order_id)
self._log.debug(f"Cached order: {order}")
if cache_order is None:
self._log.debug("Adding order to cache")
self.cache.add_order(order, position_id=PositionId(v_id.value))
assert self.cache.order(
client_order_id).venue_order_id == venue_order_id
self.cache.update_order(order)
self.client.venue_order_id_to_client_order_id = venue_order_id_to_client_order_id
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_pack_and_unpack_trailing_stop_market_orders_with_expiration(self):
# Arrange
order = TrailingStopMarketOrder(
self.trader_id,
self.strategy_id,
AUDUSD_SIM.id,
ClientOrderId("O-123456"),
OrderSide.BUY,
Quantity(100000, precision=0),
trigger_price=Price(1.00000, precision=5),
trigger_type=TriggerType.DEFAULT,
trailing_offset=Decimal("0.00010"),
offset_type=TrailingOffsetType.PRICE,
time_in_force=TimeInForce.GTD,
expire_time=UNIX_EPOCH + timedelta(minutes=1),
init_id=UUID4(),
ts_init=0,
)
# Act
packed = OrderInitialized.to_dict(order.last_event)
unpacked = self.unpacker.unpack(packed)
# Assert
assert unpacked == order
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
)
def test_serialize_and_deserialize_stop_limit_order_initialized_events(
self):
# Arrange
options = {
'Price': '1.0005',
'Trigger': '1.0010',
'PostOnly': True,
'ReduceOnly': False,
'Hidden': False,
}
event = OrderInitialized(
ClientOrderId("O-123456"),
StrategyId("S", "001"),
AUDUSD_SIM.id,
OrderSide.SELL,
OrderType.STOP_LIMIT,
Quantity(100000),
TimeInForce.DAY,
uuid4(),
UNIX_EPOCH,
options=options,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
self.assertEqual(options, event.options)
def test_serialize_and_deserialize_stop_limit_orders_with_expire_time(
self):
# Arrange
order = StopLimitOrder(
ClientOrderId("O-123456"),
StrategyId("S", "001"),
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
price=Price("1.00000"),
trigger=Price("1.00010"),
time_in_force=TimeInForce.GTD,
expire_time=UNIX_EPOCH,
init_id=uuid4(),
timestamp=UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(order)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(order, deserialized)
print(b64encode(serialized))
print(order)
def test_cancel_order_command_with_none_venue_order_id_to_from_dict_and_str_repr(
self):
# Arrange
uuid = self.uuid_factory.generate()
command = CancelOrder(
trader_id=TraderId("TRADER-001"),
strategy_id=StrategyId("S-001"),
instrument_id=AUDUSD_SIM.id,
client_order_id=ClientOrderId("O-123456"),
venue_order_id=None,
command_id=uuid,
ts_init=self.clock.timestamp_ns(),
)
# Act, Assert
assert CancelOrder.from_dict(CancelOrder.to_dict(command)) == command
assert (
str(command) ==
"CancelOrder(instrument_id=AUD/USD.SIM, client_order_id=O-123456, venue_order_id=None)" # noqa
)
assert (
repr(command) ==
f"CancelOrder(client_id=SIM, trader_id=TRADER-001, strategy_id=S-001, instrument_id=AUD/USD.SIM, client_order_id=O-123456, venue_order_id=None, command_id={uuid}, ts_init=0)" # noqa
)
def test_modify_order_command_with_none_venue_order_id_to_from_dict_and_str_repr(
self):
# Arrange
uuid = self.uuid_factory.generate()
command = ModifyOrder(
trader_id=TraderId("TRADER-001"),
strategy_id=StrategyId("S-001"),
instrument_id=AUDUSD_SIM.id,
client_order_id=ClientOrderId("O-123456"),
venue_order_id=None,
price=Price.from_str("1.00000"),
trigger_price=Price.from_str("1.00010"),
quantity=Quantity.from_int(100000),
command_id=uuid,
ts_init=self.clock.timestamp_ns(),
)
# Act, Assert
assert ModifyOrder.from_dict(ModifyOrder.to_dict(command)) == command
assert (
str(command) ==
"ModifyOrder(instrument_id=AUD/USD.SIM, client_order_id=O-123456, venue_order_id=None, quantity=100_000, price=1.00000, trigger_price=1.00010)" # noqa
)
assert (
repr(command) ==
f"ModifyOrder(client_id=None, trader_id=TRADER-001, strategy_id=S-001, instrument_id=AUD/USD.SIM, client_order_id=O-123456, venue_order_id=None, quantity=100_000, price=1.00000, trigger_price=1.00010, command_id={uuid}, ts_init=0)" # noqa
)
def test_instantiate_trade_report(self):
# Arrange, Act
report_id = UUID4()
report = TradeReport(
account_id=AccountId("SIM", "001"),
instrument_id=AUDUSD_IDEALPRO,
client_order_id=ClientOrderId("O-123456789"),
venue_order_id=VenueOrderId("1"),
venue_position_id=PositionId("2"),
trade_id=TradeId("3"),
order_side=OrderSide.BUY,
last_qty=Quantity.from_int(10000000),
last_px=Price.from_str("100.50"),
commission=Money("4.50", USD),
liquidity_side=LiquiditySide.TAKER,
report_id=report_id,
ts_event=0,
ts_init=0,
)
# Assert
assert (
str(report)
== f"TradeReport(account_id=SIM-001, instrument_id=AUD/USD.IDEALPRO, client_order_id=O-123456789, venue_order_id=1, venue_position_id=2, trade_id=3, order_side=BUY, last_qty=10_000_000, last_px=100.50, commission=4.50 USD, liquidity_side=TAKER, report_id={report_id}, ts_event=0, ts_init=0)" # noqa
)
assert (
repr(report)
== f"TradeReport(account_id=SIM-001, instrument_id=AUD/USD.IDEALPRO, client_order_id=O-123456789, venue_order_id=1, venue_position_id=2, trade_id=3, order_side=BUY, last_qty=10_000_000, last_px=100.50, commission=4.50 USD, liquidity_side=TAKER, report_id={report_id}, ts_event=0, ts_init=0)" # noqa
)
async def test_reconcile_state_no_cached_with_filled_order_and_no_trades(
self):
# Arrange
report = OrderStatusReport(
account_id=self.account_id,
instrument_id=AUDUSD_SIM.id,
client_order_id=ClientOrderId("O-123456"),
venue_order_id=VenueOrderId("1"),
order_side=OrderSide.BUY,
order_type=OrderType.LIMIT,
time_in_force=TimeInForce.GTC,
order_status=OrderStatus.FILLED,
price=Price.from_str("1.00000"),
quantity=Quantity.from_int(10_000),
filled_qty=Quantity.from_int(10_000),
avg_px=Decimal("1.00000"),
post_only=True,
report_id=UUID4(),
ts_accepted=0,
ts_triggered=0,
ts_last=0,
ts_init=0,
)
self.client.add_order_status_report(report)
# Act
result = await self.exec_engine.reconcile_state()
# Assert
assert result
assert len(self.cache.orders()) == 1
assert self.cache.orders()[0].status == OrderStatus.FILLED
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_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))
async def test_post_order_submit_success(execution_client, exec_engine):
f = asyncio.Future()
f.set_result(BetfairTestStubs.place_orders_success())
execution_client._post_submit_order(
f, ClientOrderId("O-20210327-091154-001-001-2"))
await asyncio.sleep(0)
assert isinstance(exec_engine.events[0], OrderAccepted)
def test_pack_and_unpack_trailing_stop_limit_orders_with_no_initial_prices(self):
# Arrange
order = TrailingStopLimitOrder(
self.trader_id,
self.strategy_id,
AUDUSD_SIM.id,
ClientOrderId("O-123456"),
OrderSide.BUY,
Quantity(100000, precision=0),
price=None,
trigger_price=None,
trigger_type=TriggerType.MARK,
limit_offset=Decimal("50"),
trailing_offset=Decimal("50"),
offset_type=TrailingOffsetType.TICKS,
time_in_force=TimeInForce.GTD,
expire_time=UNIX_EPOCH + timedelta(minutes=1),
init_id=UUID4(),
ts_init=0,
)
# Act
packed = OrderInitialized.to_dict(order.last_event)
unpacked = self.unpacker.unpack(packed)
# Assert
assert unpacked == order
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_serialize_and_deserialize_stop_limit_order_initialized_events(
self):
# Arrange
options = {
"ExpireTime": None,
"Price": "1.0005",
"Trigger": "1.0010",
"PostOnly": True,
"ReduceOnly": False,
"Hidden": False,
}
event = OrderInitialized(
ClientOrderId("O-123456"),
StrategyId("S-001"),
AUDUSD_SIM.id,
OrderSide.SELL,
OrderType.STOP_LIMIT,
Quantity(100000, precision=0),
TimeInForce.DAY,
uuid4(),
0,
options=options,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == event
assert deserialized.options == options
def make_order(
factory=None,
instrument_id: Optional[InstrumentId] = None,
side: Optional[OrderSide] = None,
price: Optional[Price] = None,
quantity: Optional[Quantity] = None,
client_order_id: Optional[ClientOrderId] = None,
) -> LimitOrder:
order_factory = factory or BetfairTestStubs.order_factory()
return LimitOrder(
trader_id=order_factory.trader_id,
strategy_id=order_factory.strategy_id,
instrument_id=instrument_id or BetfairTestStubs.instrument_id(),
client_order_id=client_order_id
or ClientOrderId(str(order_factory.count)),
order_side=side or OrderSide.BUY,
quantity=quantity or Quantity.from_str("10"),
price=price or Price.from_str("0.5"),
time_in_force=TimeInForce.GTC,
expire_time=None,
init_id=BetfairTestStubs.uuid(),
ts_init=0,
post_only=False,
reduce_only=False,
)
def test_serialize_and_deserialize_order_partially_filled_events(self):
# Arrange
event = OrderFilled(
self.trader_id,
self.strategy_id,
self.account_id,
AUDUSD_SIM.id,
ClientOrderId("O-123456"),
VenueOrderId("1"),
TradeId("E123456"),
PositionId("T123456"),
OrderSide.SELL,
OrderType.MARKET,
Quantity(50000, precision=0),
Price(1.00000, precision=5),
AUDUSD_SIM.quote_currency,
Money(0, USD),
LiquiditySide.MAKER,
UUID4(),
0,
0,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == event
def test_serialize_and_deserialize_order_filled_events(self):
# Arrange
event = OrderFilled(
self.account_id,
ClientOrderId("O-123456"),
VenueOrderId("1"),
ExecutionId("E123456"),
PositionId("T123456"),
StrategyId("S-001"),
AUDUSD_SIM.id,
OrderSide.SELL,
Quantity(100000, precision=0),
Price(1.00000, precision=5),
AUDUSD_SIM.quote_currency,
Money(0, USD),
LiquiditySide.TAKER,
0,
uuid4(),
0,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == event
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
