def test_message_equality(self):
# Arrange
uuid = UUID4()
message1 = Message(
category=MessageCategory.COMMAND,
message_id=uuid,
ts_init=0,
)
message2 = Message(
category=MessageCategory.COMMAND,
message_id=uuid,
ts_init=0,
)
message3 = Message(
category=MessageCategory.DOCUMENT, # Different message type
message_id=uuid,
ts_init=0,
)
message4 = Message(
category=MessageCategory.DOCUMENT,
message_id=UUID4(), # Different UUID4
ts_init=0,
)
# Act, Assert
assert message1 == message1
assert message1 == message2
assert message1 != message3
assert message3 != message4
def test_add_position_state_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()
report = PositionStatusReport(
account_id=AccountId("IB", "U123456789"),
instrument_id=AUDUSD_IDEALPRO,
venue_position_id=PositionId("1"),
position_side=PositionSide.LONG,
quantity=Quantity.from_int(1_000_000),
report_id=report_id2,
ts_last=0,
ts_init=0,
)
# Act
mass_status.add_position_reports([report])
# Assert
assert mass_status.position_reports()[AUDUSD_IDEALPRO] == [report]
assert (
repr(mass_status)
== f"ExecutionMassStatus(client_id=IB, account_id=IB-U123456789, venue=IDEALPRO, order_reports={{}}, trade_reports={{}}, position_reports={{InstrumentId('AUD/USD.IDEALPRO'): [PositionStatusReport(account_id=IB-U123456789, instrument_id=AUD/USD.IDEALPRO, venue_position_id=1, position_side=LONG, quantity=1_000_000, net_qty=1000000, report_id={report_id2}, ts_last=0, ts_init=0)]}}, report_id={report_id1}, ts_init=0)" # noqa
)
assert (
repr(report)
== f"PositionStatusReport(account_id=IB-U123456789, instrument_id=AUD/USD.IDEALPRO, venue_position_id=1, position_side=LONG, quantity=1_000_000, net_qty=1000000, report_id={report_id2}, ts_last=0, ts_init=0)" # noqa
)
def test_hash(self):
# Arrange
uuid1 = UUID4("c2988650-5beb-8af8-e714-377a3a1c26ed")
uuid2 = UUID4("c2988650-5beb-8af8-e714-377a3a1c26ed")
# Act, Assert
assert isinstance((hash(uuid1)), int)
assert hash(uuid1) == hash(uuid2)
def test_add_order_status_reports(self):
# Arrange
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,
)
venue_order_id = VenueOrderId("2")
report_id2 = UUID4()
report = OrderStatusReport(
account_id=AccountId("IB", "U123456789"),
instrument_id=AUDUSD_IDEALPRO,
client_order_id=ClientOrderId("O-123456"),
order_list_id=OrderListId("1"),
venue_order_id=venue_order_id,
order_side=OrderSide.SELL,
order_type=OrderType.STOP_LIMIT,
contingency_type=ContingencyType.OCO,
time_in_force=TimeInForce.DAY,
expire_time=None,
order_status=OrderStatus.REJECTED,
price=Price.from_str("0.90090"),
trigger_price=Price.from_str("0.90100"),
trigger_type=TriggerType.DEFAULT,
limit_offset=None,
trailing_offset=Decimal("0.00010"),
offset_type=TrailingOffsetType.PRICE,
quantity=Quantity.from_int(1_000_000),
filled_qty=Quantity.from_int(0),
display_qty=None,
avg_px=None,
post_only=True,
reduce_only=False,
cancel_reason="SOME_REASON",
report_id=report_id2,
ts_accepted=1_000_000,
ts_triggered=0,
ts_last=2_000_000,
ts_init=3_000_000,
)
# Act
mass_status.add_order_reports([report])
# Assert
assert mass_status.order_reports()[venue_order_id] == report
assert (
repr(mass_status)
== f"ExecutionMassStatus(client_id=IB, account_id=IB-U123456789, venue=IDEALPRO, order_reports={{VenueOrderId('2'): OrderStatusReport(account_id=IB-U123456789, instrument_id=AUD/USD.IDEALPRO, client_order_id=O-123456, order_list_id=1, venue_order_id=2, order_side=SELL, order_type=STOP_LIMIT, contingency_type=OCO, time_in_force=DAY, expire_time=None, order_status=REJECTED, price=0.90090, trigger_price=0.90100, trigger_type=DEFAULT, limit_offset=None, trailing_offset=0.00010, offset_type=PRICE, quantity=1_000_000, filled_qty=0, leaves_qty=1_000_000, display_qty=None, avg_px=None, post_only=True, reduce_only=False, cancel_reason=SOME_REASON, report_id={report_id2}, ts_accepted=1000000, ts_triggered=0, ts_last=2000000, ts_init=3000000)}}, trade_reports={{}}, position_reports={{}}, report_id={report_id1}, ts_init=0)" # noqa
)
assert (
repr(report)
== f"OrderStatusReport(account_id=IB-U123456789, instrument_id=AUD/USD.IDEALPRO, client_order_id=O-123456, order_list_id=1, venue_order_id=2, order_side=SELL, order_type=STOP_LIMIT, contingency_type=OCO, time_in_force=DAY, expire_time=None, order_status=REJECTED, price=0.90090, trigger_price=0.90100, trigger_type=DEFAULT, limit_offset=None, trailing_offset=0.00010, offset_type=PRICE, quantity=1_000_000, filled_qty=0, leaves_qty=1_000_000, display_qty=None, avg_px=None, post_only=True, reduce_only=False, cancel_reason=SOME_REASON, report_id={report_id2}, ts_accepted=1000000, ts_triggered=0, ts_last=2000000, ts_init=3000000)" # noqa
)
def test_equality(self):
# Arrange
event1 = TimeEvent("EVENT_1", UUID4(), 0, 0)
event2 = TimeEvent("EVENT_1", UUID4(), 0, 0)
event3 = TimeEvent("EVENT_2", UUID4(), 0, 0)
# Act, Assert
assert event1 == event1
assert event1 == event2
assert event1 != event3
def test_equality(self):
# Arrange, Act
uuid1 = UUID4("c2988650-5beb-8af8-e714-377a3a1c26ed")
uuid2 = UUID4("c2988650-5beb-8af8-e714-377a3a1c26ed")
uuid3 = UUID4("a2988650-5beb-8af8-e714-377a3a1c26ed")
# Assert
assert uuid1 == uuid1
assert uuid1 == uuid2
assert uuid2 != uuid3
def test_apply_given_new_state_event_updates_correctly(self):
# Arrange
event1 = AccountState(
account_id=AccountId("SIM", "001"),
account_type=AccountType.BETTING,
base_currency=None, # Multi-currency
reported=True,
balances=[
AccountBalance(
GBP,
Money(10.00000000, GBP),
Money(0.00000000, GBP),
Money(10.00000000, GBP),
),
],
info={}, # No default currency set
event_id=UUID4(),
ts_event=0,
ts_init=0,
)
# Act
account = BettingAccount(event1)
event2 = AccountState(
account_id=AccountId("SIM", "001"),
account_type=AccountType.BETTING,
base_currency=None, # Multi-currency
reported=True,
balances=[
AccountBalance(
GBP,
Money(9.00000000, GBP),
Money(0.50000000, GBP),
Money(8.50000000, GBP),
),
],
info={}, # No default currency set
event_id=UUID4(),
ts_event=0,
ts_init=0,
)
# Act
account.apply(event=event2)
# Assert
assert account.last_event == event2
assert account.events == [event1, event2]
assert account.event_count == 2
assert account.balance_total(GBP) == Money(9.00000000, GBP)
assert account.balance_free(GBP) == Money(8.50000000, GBP)
assert account.balance_locked(GBP) == Money(0.50000000, GBP)
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_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_apply_order_denied_event(self):
# Arrange
order = self.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
denied = OrderDenied(
self.trader_id,
self.strategy_id,
AUDUSD_SIM.id,
order.client_order_id,
"SOME_REASON",
UUID4(),
0,
)
# Act
order.apply(denied)
# Assert
assert order.status == OrderStatus.DENIED
assert order.event_count == 2
assert order.last_event == denied
assert not order.is_active
assert order.is_completed
def test_account_when_account_returns_the_account_facade(self):
# Arrange
state = AccountState(
account_id=AccountId("BINANCE", "1513111"),
account_type=AccountType.CASH,
base_currency=None,
reported=True,
balances=[
AccountBalance(
BTC,
Money(10.00000000, BTC),
Money(0.00000000, BTC),
Money(10.00000000, BTC),
)
],
info={},
event_id=UUID4(),
ts_event=0,
ts_init=0,
)
self.portfolio.update_account(state)
# Act
result = self.portfolio.account(BINANCE)
# Assert
assert result.id.issuer == "BINANCE"
def test_instantiate_single_asset_cash_account(self):
# Arrange
event = AccountState(
account_id=AccountId("SIM", "000"),
account_type=AccountType.CASH,
base_currency=USD,
reported=True,
balances=[
AccountBalance(
Money(1_000_000, USD),
Money(0, USD),
Money(1_000_000, USD),
),
],
margins=[],
info={},
event_id=UUID4(),
ts_event=0,
ts_init=0,
)
# Act
account = CashAccount(event)
# Assert
assert account.base_currency == USD
assert account.last_event == event
assert account.events == [event]
assert account.event_count == 1
assert account.balance_total() == Money(1_000_000, USD)
assert account.balance_free() == Money(1_000_000, USD)
assert account.balance_locked() == Money(0, USD)
assert account.balances_total() == {USD: Money(1_000_000, USD)}
assert account.balances_free() == {USD: Money(1_000_000, USD)}
assert account.balances_locked() == {USD: Money(0, USD)}
def test_serialize_and_deserialize_account_state_without_base_currency_events(self):
# Arrange
event = AccountState(
account_id=AccountId("SIM", "000"),
account_type=AccountType.MARGIN,
base_currency=None,
reported=True,
balances=[
AccountBalance(
Money(10000, USDT),
Money(0, USDT),
Money(10000, USDT),
),
],
margins=[],
info={},
event_id=UUID4(),
ts_event=0,
ts_init=1_000_000_000,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == event
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_str_and_repr(self):
# Arrange
uuid = UUID4("c2988650-5beb-8af8-e714-377a3a1c26ed")
# Act, Assert
assert str(uuid) == "c2988650-5beb-8af8-e714-377a3a1c26ed"
assert repr(uuid) == "UUID4('c2988650-5beb-8af8-e714-377a3a1c26ed')"
def test_serialize_and_deserialize_submit_order_commands(self):
# Arrange
order = self.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000, precision=0),
)
command = SubmitOrder(
self.trader_id,
StrategyId("SCALPER-001"),
PositionId("P-123456"),
order,
UUID4(),
0,
ClientId("SIM"),
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == command
assert deserialized.order == order
print(command)
print(len(serialized))
print(serialized)
print(b64encode(serialized))
def test_instantiate_execution_mass_status_report(self):
# Arrange
client_id = ClientId("IB")
account_id = AccountId("IB", "U123456789")
# Act
report_id = UUID4()
report = ExecutionMassStatus(
client_id=client_id,
account_id=account_id,
venue=Venue("IDEALPRO"),
report_id=report_id,
ts_init=0,
)
# Assert
assert report.client_id == client_id
assert report.account_id == account_id
assert report.ts_init == 0
assert report.order_reports() == {}
assert report.position_reports() == {}
assert (
str(report)
== f"ExecutionMassStatus(client_id=IB, account_id=IB-U123456789, venue=IDEALPRO, order_reports={{}}, trade_reports={{}}, position_reports={{}}, report_id={report_id}, ts_init=0)" # noqa
)
assert (
repr(report)
== f"ExecutionMassStatus(client_id=IB, account_id=IB-U123456789, venue=IDEALPRO, order_reports={{}}, trade_reports={{}}, position_reports={{}}, report_id={report_id}, ts_init=0)" # noqa
)
async def test_submit_unsupported_order_logs_error(self, mocker):
# Arrange
mock_send_request = mocker.patch(
target=
"nautilus_trader.adapters.binance.http.client.BinanceHttpClient.send_request"
)
order = self.strategy.order_factory.market_to_limit(
instrument_id=ETHUSDT_BINANCE.id,
order_side=OrderSide.BUY,
quantity=Quantity.from_int(10),
)
self.cache.add_order(order, None)
submit_order = SubmitOrder(
trader_id=self.trader_id,
strategy_id=self.strategy.id,
position_id=None,
order=order,
command_id=UUID4(),
ts_init=0,
)
# Act
self.exec_client.submit_order(submit_order)
await asyncio.sleep(0.3)
# Assert
assert mock_send_request.call_args is None
def margin_account_state(account_id=None) -> AccountState:
return AccountState(
account_id=account_id or TestIdStubs.account_id(),
account_type=AccountType.MARGIN,
base_currency=USD,
reported=True, # reported
balances=[
AccountBalance(
Money(1_000_000, USD),
Money(0, USD),
Money(1_000_000, USD),
),
],
margins=[
MarginBalance(
Money(10_000, USD),
Money(50_000, USD),
TestIdStubs.audusd_id(),
),
],
info={},
event_id=UUID4(),
ts_event=0,
ts_init=0,
)
def position_closed(position) -> PositionClosed:
return PositionClosed.create(
position=position,
fill=position.last_event,
event_id=UUID4(),
ts_init=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_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_calculate_balance_locked_sell(self):
# Arrange
event = AccountState(
account_id=AccountId("SIM", "001"),
account_type=AccountType.CASH,
base_currency=USD,
reported=True,
balances=[
AccountBalance(
Money(1_000_000.00, USD),
Money(0.00, USD),
Money(1_000_000.00, USD),
),
],
margins=[],
info={}, # No default currency set
event_id=UUID4(),
ts_event=0,
ts_init=0,
)
account = CashAccount(event)
# Act
result = account.calculate_balance_locked(
instrument=AUDUSD_SIM,
side=OrderSide.SELL,
quantity=Quantity.from_int(1_000_000),
price=Price.from_str("0.80"),
)
# Assert
assert result == Money(1_000_040.00,
AUD) # Notional + expected commission
def test_apply_order_updated_venue_id_change(self):
# Arrange
order = self.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
order.apply(TestStubs.event_order_submitted(order))
order.apply(TestStubs.event_order_accepted(order))
order.apply(TestStubs.event_order_pending_update(order))
updated = OrderUpdated(
order.trader_id,
order.strategy_id,
order.account_id,
order.instrument_id,
order.client_order_id,
VenueOrderId("2"),
Quantity.from_int(120000),
Price.from_str("1.00001"),
None,
UUID4(),
0,
0,
)
# Act
order.apply(updated)
# Assert
assert order.venue_order_id == VenueOrderId("2")
assert order.venue_order_ids == [VenueOrderId("1")]
def test_instantiate_single_asset_cash_account(self):
# Arrange
event = AccountState(
account_id=AccountId("SIM", "000"),
account_type=AccountType.BETTING,
base_currency=GBP,
reported=True,
balances=[
AccountBalance(
GBP,
Money(1_000_000, GBP),
Money(0, GBP),
Money(1_000_000, GBP),
),
],
info={},
event_id=UUID4(),
ts_event=0,
ts_init=0,
)
# Act
account = BettingAccount(event)
# Assert
assert account.base_currency == GBP
assert account.last_event == event
assert account.events == [event]
assert account.event_count == 1
assert account.balance_total() == Money(1_000_000, GBP)
assert account.balance_free() == Money(1_000_000, GBP)
assert account.balance_locked() == Money(0, GBP)
assert account.balances_total() == {GBP: Money(1_000_000, GBP)}
assert account.balances_free() == {GBP: Money(1_000_000, GBP)}
assert account.balances_locked() == {GBP: Money(0, GBP)}
def test_serialize_and_deserialize_submit_order_list_commands(
self,
):
# Arrange
bracket = self.order_factory.bracket_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000, precision=0),
stop_loss=Price(0.99900, precision=5),
take_profit=Price(1.00010, precision=5),
)
command = SubmitOrderList(
client_id=ClientId("SIM"),
trader_id=self.trader_id,
strategy_id=StrategyId("SCALPER-001"),
order_list=bracket,
command_id=UUID4(),
ts_init=0,
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == command
assert deserialized.list == bracket
print(b64encode(serialized))
print(command)
def setup(self):
# Fixture Setup
self.venue = Venue("SIM")
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
self.order = self.order_factory.market(
AUDUSD,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.command = SubmitOrder(
self.trader_id,
StrategyId("SCALPER-001"),
PositionId("P-123456"),
self.order,
UUID4(),
0,
)
self.serializer = MsgPackSerializer()
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
)
