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 )