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
)