def test_submit_bracket_order_command_to_from_dict_and_str_repr(self): # Arrange uuid = self.uuid_factory.generate() bracket = self.order_factory.bracket_market( instrument_id=AUDUSD_SIM.id, order_side=OrderSide.BUY, quantity=Quantity.from_int(100000), stop_loss=Price.from_str("1.00000"), take_profit=Price.from_str("1.00100"), ) command = SubmitOrderList( trader_id=TraderId("TRADER-001"), strategy_id=StrategyId("S-001"), order_list=bracket, command_id=uuid, ts_init=self.clock.timestamp_ns(), ) # Act, Assert assert SubmitOrderList.from_dict( SubmitOrderList.to_dict(command)) == command assert ( str(command) == "SubmitOrderList(instrument_id=AUD/USD.SIM, order_list=OrderList(id=1, instrument_id=AUD/USD.SIM, orders=[MarketOrder(BUY 100_000 AUD/USD.SIM MARKET GTC, status=INITIALIZED, client_order_id=O-19700101-000000-000-001-1, venue_order_id=None, tags=ENTRY), StopMarketOrder(SELL 100_000 AUD/USD.SIM STOP_MARKET @ 1.00000 GTC, status=INITIALIZED, client_order_id=O-19700101-000000-000-001-2, venue_order_id=None, tags=STOP_LOSS), LimitOrder(SELL 100_000 AUD/USD.SIM LIMIT @ 1.00100 GTC, status=INITIALIZED, client_order_id=O-19700101-000000-000-001-3, venue_order_id=None, tags=TAKE_PROFIT)]))" # noqa ) assert ( repr(command) == f"SubmitOrderList(trader_id=TRADER-001, strategy_id=S-001, instrument_id=AUD/USD.SIM, order_list=OrderList(id=1, instrument_id=AUD/USD.SIM, orders=[MarketOrder(BUY 100_000 AUD/USD.SIM MARKET GTC, status=INITIALIZED, client_order_id=O-19700101-000000-000-001-1, venue_order_id=None, tags=ENTRY), StopMarketOrder(SELL 100_000 AUD/USD.SIM STOP_MARKET @ 1.00000 GTC, status=INITIALIZED, client_order_id=O-19700101-000000-000-001-2, venue_order_id=None, tags=STOP_LOSS), LimitOrder(SELL 100_000 AUD/USD.SIM LIMIT @ 1.00100 GTC, status=INITIALIZED, client_order_id=O-19700101-000000-000-001-3, venue_order_id=None, tags=TAKE_PROFIT)]), command_id={uuid}, ts_init=0)" # noqa )
def test_submit_order_with_default_settings_sends_to_client(self): # Arrange self.exec_engine.start() strategy = TradingStrategy(order_id_tag="001") strategy.register_trader( TraderId("TESTER-000"), self.clock, self.logger, ) self.exec_engine.register_strategy(strategy) order = strategy.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) submit_order = SubmitOrder( self.trader_id, strategy.id, PositionId.null(), order, self.uuid_factory.generate(), self.clock.timestamp_ns(), ) # Act self.risk_engine.execute(submit_order) # Assert assert self.exec_client.calls == ["connect", "submit_order"]
def test_to_dict_returns_expected_dict(self): # Arrange tick = TradeTick( instrument_id=AUDUSD_SIM.id, price=Price.from_str("1.00000"), size=Quantity.from_int(10000), aggressor_side=AggressorSide.BUY, trade_id="123456789", ts_event=0, ts_init=0, ) # Act result = TradeTick.to_dict(tick) # Assert assert result == { "type": "TradeTick", "instrument_id": "AUD/USD.SIM", "price": "1.00000", "size": "10000", "aggressor_side": "BUY", "trade_id": "123456789", "ts_event": 0, "ts_init": 0, }
def test_bracket_order_str_and_repr(self): # Arrange # Act entry_order = self.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) bracket_order = self.order_factory.bracket( entry_order, Price.from_str("0.99990"), Price.from_str("1.00010"), ) # Assert self.assertEqual( "BracketOrder(id=BO-19700101-000000-000-001-1, " "EntryMarketOrder(BUY 100_000 AUD/USD.SIM MARKET GTC, " "state=INITIALIZED, client_order_id=O-19700101-000000-000-001-1), " "SL=0.99990, TP=1.00010)", str(bracket_order), ) # noqa self.assertEqual( "BracketOrder(id=BO-19700101-000000-000-001-1, " "EntryMarketOrder(BUY 100_000 AUD/USD.SIM MARKET GTC, " "state=INITIALIZED, client_order_id=O-19700101-000000-000-001-1), " "SL=0.99990, TP=1.00010)", repr(bracket_order), ) # noqa
def test_calculate_unrealized_pnl_for_long_inverse(self): # Arrange order = self.order_factory.market( XBTUSD_BITMEX.id, OrderSide.BUY, Quantity.from_int(100000), ) fill = TestStubs.event_order_filled( order, instrument=XBTUSD_BITMEX, position_id=PositionId("P-123456"), strategy_id=StrategyId("S-001"), last_px=Price.from_str("10500.00"), ) position = Position(XBTUSD_BITMEX, fill) # Act pnl = position.unrealized_pnl(Price.from_str("11505.60")) # Assert assert pnl == Money(0.83238969, BTC) assert position.realized_pnl == Money(-0.00714286, BTC) assert position.commissions() == [Money(0.00714286, BTC)]
def xbtusd_bitmex() -> CryptoSwap: """ Return the BitMEX XBT/USD perpetual contract for backtesting. Returns ------- CryptoSwap """ return CryptoSwap( instrument_id=InstrumentId( symbol=Symbol("XBT/USD"), venue=Venue("BITMEX"), ), base_currency=BTC, quote_currency=USD, settlement_currency=BTC, is_inverse=True, price_precision=1, size_precision=0, price_increment=Price.from_str("0.5"), size_increment=Quantity.from_int(1), max_quantity=None, min_quantity=None, max_notional=Money(10_000_000.00, USD), min_notional=Money(1.00, USD), max_price=Price.from_str("1000000.0"), min_price=Price(0.5, precision=1), margin_init=Decimal("0.01"), margin_maint=Decimal("0.0035"), maker_fee=Decimal("-0.00025"), taker_fee=Decimal("0.00075"), ts_event_ns=0, ts_recv_ns=0, )
def test_order_to_dict(self): # Arrange order = self.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) # Act result = order.to_dict() # Assert assert result == { "type": "MarketOrder", "client_order_id": "O-19700101-000000-000-001-1", "venue_order_id": "NULL", "position_id": "NULL", "strategy_id": "S-001", "account_id": None, "execution_id": None, "instrument_id": "AUD/USD.SIM", "order_side": "BUY", "order_type": "MARKET", "quantity": "100000", "timestamp_ns": 0, "time_in_force": "GTC", "filled_qty": "0", "ts_filled_ns": 0, "avg_px": None, "slippage": "0", "init_id": order.init_id.value, "state": "INITIALIZED", }
def test_run_trade_ticks_through_aggregator_results_in_expected_bars(self): # Arrange bar_store = ObjectStorer() handler = bar_store.store instrument = ETHUSDT_BINANCE bar_spec = BarSpecification(1000, BarAggregation.VOLUME, PriceType.LAST) bar_type = BarType(instrument.id, bar_spec) aggregator = VolumeBarAggregator( instrument, bar_type, handler, Logger(TestClock()), ) wrangler = TradeTickDataWrangler(instrument=ETHUSDT_BINANCE) provider = TestDataProvider() ticks = wrangler.process( provider.read_csv_ticks("binance-ethusdt-trades.csv")[:10000]) # Act for tick in ticks: aggregator.handle_trade_tick(tick) # Assert last_bar = bar_store.get_store()[-1] assert len(bar_store.get_store()) == 26 assert last_bar.open == Price.from_str("425.17") assert last_bar.high == Price.from_str("425.24") assert last_bar.low == Price.from_str("424.69") assert last_bar.close == Price.from_str("425.14") assert last_bar.volume == Quantity.from_int(1000)
async def test_handle_position_opening_with_position_id_none(self): # Arrange self.risk_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, ) order = strategy.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) event = TestEventStubs.order_submitted(order) # Act self.risk_engine.process(event) await asyncio.sleep(0.1) # Assert assert self.risk_engine.qsize() == 0 assert self.risk_engine.event_count == 1 # Tear Down self.risk_engine.stop() await self.risk_engine.get_run_queue_task()
def test_handle_trade_tick_when_volume_below_threshold_updates(self): # Arrange bar_store = ObjectStorer() handler = bar_store.store instrument = AUDUSD_SIM bar_spec = BarSpecification(10000, BarAggregation.VOLUME, PriceType.LAST) bar_type = BarType(instrument.id, bar_spec) aggregator = VolumeBarAggregator( instrument, bar_type, handler, Logger(TestClock()), ) tick1 = TradeTick( instrument_id=instrument.id, price=Price.from_str("1.00001"), size=Quantity.from_int(1), aggressor_side=AggressorSide.BUY, trade_id=TradeId("123456"), ts_event=0, ts_init=0, ) # Act aggregator.handle_trade_tick(tick1) # Assert assert len(bar_store.get_store()) == 0
def test_run_quote_ticks_through_aggregator_results_in_expected_bars(self): # Arrange bar_store = ObjectStorer() handler = bar_store.store instrument = AUDUSD_SIM bar_spec = BarSpecification(1000, BarAggregation.VOLUME, PriceType.MID) bar_type = BarType(instrument.id, bar_spec) aggregator = VolumeBarAggregator( instrument, bar_type, handler, Logger(TestClock()), ) # Setup data wrangler = QuoteTickDataWrangler(instrument) provider = TestDataProvider() ticks = wrangler.process( data=provider.read_csv_ticks("truefx-audusd-ticks.csv")[:10000], default_volume=1, ) # Act for tick in ticks: aggregator.handle_quote_tick(tick) # Assert last_bar = bar_store.get_store()[-1] assert len(bar_store.get_store()) == 10 assert last_bar.open == Price.from_str("0.670635") assert last_bar.high == Price.from_str("0.670705") assert last_bar.low == Price.from_str("0.670370") assert last_bar.close == Price.from_str("0.670655") assert last_bar.volume == Quantity.from_int(1000)
def test_run_trade_ticks_through_aggregator_results_in_expected_bars(self): # Arrange bar_store = ObjectStorer() handler = bar_store.store bar_spec = BarSpecification(1000, BarAggregation.VOLUME, PriceType.LAST) bar_type = BarType(ETHUSDT_BINANCE.id, bar_spec) aggregator = VolumeBarAggregator(bar_type, handler, Logger(TestClock())) wrangler = TradeTickDataWrangler( instrument=ETHUSDT_BINANCE, data=TestDataProvider.ethusdt_trades(), ) wrangler.pre_process(instrument_indexer=0) ticks = wrangler.build_ticks() # Act for tick in ticks: aggregator.handle_trade_tick(tick) # Assert last_bar = bar_store.get_store()[-1] self.assertEqual(187, len(bar_store.get_store())) self.assertEqual(Price.from_str("426.44"), last_bar.open) self.assertEqual(Price.from_str("426.84"), last_bar.high) self.assertEqual(Price.from_str("426.00"), last_bar.low) self.assertEqual(Price.from_str("426.82"), last_bar.close) self.assertEqual(Quantity.from_int(1000), last_bar.volume)
def test_run_quote_ticks_through_aggregator_results_in_expected_bars(self): # Arrange bar_store = ObjectStorer() handler = bar_store.store instrument_id = TestStubs.audusd_id() bar_spec = BarSpecification(1000, BarAggregation.VOLUME, PriceType.MID) bar_type = BarType(instrument_id, bar_spec) aggregator = VolumeBarAggregator(bar_type, handler, Logger(TestClock())) wrangler = QuoteTickDataWrangler( instrument=AUDUSD_SIM, data_quotes=TestDataProvider.audusd_ticks(), ) wrangler.pre_process(instrument_indexer=0, default_volume=1) ticks = wrangler.build_ticks() # Act for tick in ticks: aggregator.handle_quote_tick(tick) # Assert last_bar = bar_store.get_store()[-1] self.assertEqual(99, len(bar_store.get_store())) self.assertEqual(Price.from_str("0.669325"), last_bar.open) self.assertEqual(Price.from_str("0.669485"), last_bar.high) self.assertEqual(Price.from_str("0.66917"), last_bar.low) self.assertEqual(Price.from_str("0.66935"), last_bar.close) self.assertEqual(Quantity.from_int(1000), last_bar.volume)
def test_handle_trade_tick_when_volume_below_threshold_updates(self): # Arrange bar_store = ObjectStorer() handler = bar_store.store instrument_id = TestStubs.audusd_id() bar_spec = BarSpecification(10000, BarAggregation.VOLUME, PriceType.LAST) bar_type = BarType(instrument_id, bar_spec) aggregator = VolumeBarAggregator(bar_type, handler, Logger(TestClock())) tick1 = TradeTick( instrument_id=AUDUSD_SIM.id, price=Price.from_str("1.00001"), size=Quantity.from_int(1), aggressor_side=AggressorSide.BUY, match_id=TradeMatchId("123456"), timestamp_origin_ns=0, timestamp_ns=0, ) # Act aggregator.handle_trade_tick(tick1) # Assert self.assertEqual(0, len(bar_store.get_store()))
def setup(self): # Fixture Setup _reset() self.catalog = DataCatalog(path="/root", fs_protocol="memory") self.order_factory = OrderFactory( trader_id=TraderId("T-001"), strategy_id=StrategyId("S-001"), clock=TestClock(), ) self.order = self.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) self.order_submitted = copy.copy(self.order) self.order_submitted.apply(TestEventStubs.order_submitted(self.order)) self.order_accepted = copy.copy(self.order_submitted) self.order_accepted.apply( TestEventStubs.order_accepted(self.order_submitted)) self.order_pending_cancel = copy.copy(self.order_accepted) self.order_pending_cancel.apply( TestEventStubs.order_pending_cancel(self.order_accepted)) self.order_cancelled = copy.copy(self.order_pending_cancel) self.order_cancelled.apply( TestEventStubs.order_canceled(self.order_pending_cancel))
def test_update_position_when_not_already_exists_logs(self): # Arrange order = self.strategy.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) self.database.add_order(order) position_id = PositionId("P-1") fill = TestEventStubs.order_filled( order, instrument=AUDUSD_SIM, position_id=position_id, last_px=Price.from_str("1.00000"), ) position = Position(instrument=AUDUSD_SIM, fill=fill) # Act self.database.update_position(position) # Assert assert True # No exception raised
def test_process_trade_tick_when_subscriber_then_sends_to_registered_handler( self): # Arrange self.data_engine.register_client(self.binance_client) self.binance_client.connect() handler = [] subscribe = Subscribe( client_id=ClientId(BINANCE.value), data_type=DataType(TradeTick, metadata={"instrument_id": ETHUSDT_BINANCE.id}), handler=handler.append, command_id=self.uuid_factory.generate(), timestamp_ns=self.clock.timestamp_ns(), ) self.data_engine.execute(subscribe) tick = TradeTick( ETHUSDT_BINANCE.id, Price.from_str("1050.00000"), Quantity.from_int(100), AggressorSide.BUY, "123456789", 0, 0, ) # Act self.data_engine.process(tick) # Assert self.assertEqual([tick], handler)
def test_submit_bracket_order_when_not_connected_logs_and_does_not_send( self): # Arrange strategy = TradingStrategy("000") entry = self.order_factory.market( ETHUSDT_BINANCE.id, OrderSide.BUY, Quantity.from_int(100), ) bracket = self.order_factory.bracket( entry, Price.from_str("500.00000"), Price.from_str("600.00000"), ) command = SubmitBracketOrder( self.trader_id, strategy.id, bracket, self.uuid_factory.generate(), self.clock.timestamp_ns(), ) # Act self.exec_client.submit_bracket_order(command) # Assert assert entry.state == OrderState.INITIALIZED
def test_initialize_buy_market_order(self): # Arrange # Act order = self.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) # Assert self.assertEqual(AUDUSD_SIM.id.symbol, order.symbol) self.assertEqual(AUDUSD_SIM.id.venue, order.venue) self.assertEqual(OrderType.MARKET, order.type) self.assertEqual(OrderState.INITIALIZED, order.state) self.assertEqual(1, order.event_count) self.assertTrue(isinstance(order.last_event, OrderInitialized)) self.assertFalse(order.is_working) self.assertFalse(order.is_completed) self.assertTrue(order.is_buy) self.assertFalse(order.is_sell) self.assertFalse(order.is_passive) self.assertTrue(order.is_aggressive) self.assertEqual(0, order.ts_filled_ns) self.assertEqual(0, order.last_event.timestamp_ns) self.assertEqual(OrderInitialized, type(order.init_event)) self.assertTrue(order == order) self.assertFalse(order != order)
def test_update_order_for_completed_order(self): # Arrange order = self.strategy.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) self.database.add_order(order) order.apply(TestStubs.event_order_submitted(order)) self.database.update_order(order) order.apply(TestStubs.event_order_accepted(order)) self.database.update_order(order) fill = TestStubs.event_order_filled( order, instrument=AUDUSD_SIM, last_px=Price.from_str("1.00001"), ) order.apply(fill) # Act self.database.update_order(order) # Assert assert self.database.load_order(order.client_order_id) == order
def test_initialize_stop_limit_order(self): # Arrange # Act order = self.order_factory.stop_limit( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), Price.from_str("1.00000"), Price.from_str("1.10010"), ) # Assert self.assertEqual(OrderType.STOP_LIMIT, order.type) self.assertEqual(OrderState.INITIALIZED, order.state) self.assertEqual(TimeInForce.GTC, order.time_in_force) self.assertTrue(order.is_passive) self.assertFalse(order.is_aggressive) self.assertFalse(order.is_completed) self.assertEqual(OrderInitialized, type(order.init_event)) self.assertEqual( "StopLimitOrder(BUY 100_000 AUD/USD.SIM STOP_LIMIT @ 1.00000 GTC, " "trigger=1.10010, state=INITIALIZED, client_order_id=O-19700101-000000-000-001-1)", str(order), ) self.assertEqual( "StopLimitOrder(BUY 100_000 AUD/USD.SIM STOP_LIMIT @ 1.00000 GTC, " "trigger=1.10010, state=INITIALIZED, client_order_id=O-19700101-000000-000-001-1)", repr(order), )
def test_load_order_when_position_in_database_returns_position(self): # Arrange self.database.add_instrument(AUDUSD_SIM) order = self.strategy.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) self.database.add_order(order) position_id = PositionId("P-1") fill = TestStubs.event_order_filled( order, instrument=AUDUSD_SIM, position_id=position_id, last_px=Price.from_str("1.00000"), ) position = Position(instrument=AUDUSD_SIM, fill=fill) self.database.add_position(position) # Act result = self.database.load_position(position_id) # Assert assert result == position
def test_apply_order_accepted_event(self): # Arrange order = self.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) order.apply(TestStubs.event_order_submitted(order)) # Act order.apply(TestStubs.event_order_accepted(order)) # Assert self.assertEqual(OrderState.ACCEPTED, order.state) self.assertTrue(order.is_working) self.assertFalse(order.is_completed) self.assertEqual( "MarketOrder(BUY 100_000 AUD/USD.SIM MARKET GTC, state=ACCEPTED, " "client_order_id=O-19700101-000000-000-001-1, venue_order_id=1)", str(order), ) self.assertEqual( "MarketOrder(BUY 100_000 AUD/USD.SIM MARKET GTC, state=ACCEPTED, " "client_order_id=O-19700101-000000-000-001-1, venue_order_id=1)", repr(order), )
def test_load_positions_cache_when_one_position_in_database(self): # Arrange self.database.add_instrument(AUDUSD_SIM) order1 = self.strategy.order_factory.stop_market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), Price.from_str("1.00000"), ) self.database.add_order(order1) position_id = PositionId("P-1") order1.apply(TestStubs.event_order_submitted(order1)) order1.apply(TestStubs.event_order_accepted(order1)) order1.apply( TestStubs.event_order_filled( order1, instrument=AUDUSD_SIM, position_id=position_id, last_px=Price.from_str("1.00001"), )) position = Position(instrument=AUDUSD_SIM, fill=order1.last_event) self.database.add_position(position) # Act result = self.database.load_positions() # Assert assert result == {position.id: position}
def test_calculate_unrealized_pnl_for_short_inverse(self): # Arrange order = self.order_factory.market( XBTUSD_BITMEX.id, OrderSide.SELL, Quantity.from_int(1250000), ) fill = TestStubs.event_order_filled( order, instrument=XBTUSD_BITMEX, position_id=PositionId("P-123456"), strategy_id=StrategyId("S-001"), last_px=Price.from_str("15500.00"), ) position = Position(XBTUSD_BITMEX, fill) # Act pnl = position.unrealized_pnl(Price.from_str("12506.65")) # Assert assert pnl == Money(19.30166700, BTC) assert position.realized_pnl == Money(-0.06048387, BTC) assert position.commissions() == [Money(0.06048387, BTC)]
def test_to_dict(self): # Arrange bar = Bar( AUDUSD_1_MIN_BID, Price.from_str("1.00001"), Price.from_str("1.00004"), Price.from_str("1.00002"), Price.from_str("1.00003"), Quantity.from_int(100000), 0, 0, ) # Act values = Bar.to_dict(bar) # Assert assert values == { "type": "Bar", "bar_type": "AUD/USD.SIM-1-MINUTE-BID-EXTERNAL", "open": "1.00001", "high": "1.00004", "low": "1.00002", "close": "1.00003", "volume": "100000", "ts_event": 0, "ts_init": 0, }
def setup(self): # Fixture Setup self.venue = Venue("SIM") self.trader_id = TestStubs.trader_id() self.account_id = TestStubs.account_id() self.serializer = MsgPackCommandSerializer() 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, )
def es_future(): return Future( instrument_id=InstrumentId(symbol=Symbol("ESZ21"), venue=Venue("CME")), native_symbol=Symbol("ESZ21"), asset_class=AssetClass.INDEX, currency=USD, price_precision=2, price_increment=Price.from_str("0.01"), multiplier=Quantity.from_int(1), lot_size=Quantity.from_int(1), underlying="ES", expiry_date=date(2021, 12, 17), ts_event=0, ts_init=0, )
def test_tick_hash_str_and_repr(self): # Arrange tick = QuoteTick( instrument_id=AUDUSD_SIM.id, bid=Price.from_str("1.00000"), ask=Price.from_str("1.00001"), bid_size=Quantity.from_int(1), ask_size=Quantity.from_int(1), ts_event=0, ts_init=0, ) # Act, Assert assert isinstance(hash(tick), int) assert str(tick) == "AUD/USD.SIM,1.00000,1.00001,1,1,0" assert repr(tick) == "QuoteTick(AUD/USD.SIM,1.00000,1.00001,1,1,0)"
def test_submit_order_command_to_from_dict_and_str_repr(self): # Arrange uuid = self.uuid_factory.generate() order = self.order_factory.market( AUDUSD_SIM.id, OrderSide.BUY, Quantity.from_int(100000), ) command = SubmitOrder( trader_id=TraderId("TRADER-001"), strategy_id=StrategyId("S-001"), position_id=PositionId("P-001"), order=order, command_id=uuid, ts_init=self.clock.timestamp_ns(), ) # Act, Assert assert SubmitOrder.from_dict(SubmitOrder.to_dict(command)) == command assert ( str(command) == "SubmitOrder(instrument_id=AUD/USD.SIM, client_order_id=O-19700101-000000-000-001-1, position_id=P-001, order=BUY 100_000 AUD/USD.SIM MARKET GTC)" # noqa ) assert ( repr(command) == f"SubmitOrder(trader_id=TRADER-001, strategy_id=S-001, instrument_id=AUD/USD.SIM, client_order_id=O-19700101-000000-000-001-1, position_id=P-001, order=BUY 100_000 AUD/USD.SIM MARKET GTC, command_id={uuid}, ts_init=0)" # noqa )