def test_reset(self):
# Arrange
bar_type = TestStubs.bartype_audusd_1min_bid()
strategy = MockStrategy(bar_type)
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
bar = Bar(
bar_type,
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,
)
strategy.handle_bar(bar)
# Act
strategy.reset()
# Assert
assert "on_reset" in strategy.calls
assert strategy.is_initialized
assert strategy.ema1.count == 0
assert strategy.ema2.count == 0
def test_stop_cancels_a_running_timer(self):
# Arrange
bar_type = TestStubs.bartype_audusd_1min_bid()
strategy = MockStrategy(bar_type)
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
start_time = datetime.now(pytz.utc) + timedelta(milliseconds=100)
strategy.clock.set_timer("test_timer",
timedelta(milliseconds=100),
start_time,
stop_time=None)
# Act
strategy.start()
strategy.stop()
# Assert
assert len(strategy.clock.timer_names()) == 0
def test_update_strategy(self):
# Arrange
strategy = MockStrategy(TestStubs.bartype_btcusdt_binance_100tick_last())
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Act
self.database.update_strategy(strategy)
result = self.database.load_strategy(strategy.id)
# Assert
assert result == {"UserState": b"1"}
def test_save_load(self):
# Arrange
bar_type = TestStubs.bartype_audusd_1min_bid()
strategy = MockStrategy(bar_type)
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Act
state = strategy.save()
strategy.load(state)
# Assert
assert state == {"UserState": b"1"}
assert "on_save" in strategy.calls
assert strategy.is_initialized
def test_dispose(self):
# Arrange
bar_type = TestStubs.bartype_audusd_1min_bid()
strategy = MockStrategy(bar_type)
strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
strategy.reset()
# Act
strategy.dispose()
# Assert
assert "on_dispose" in strategy.calls
assert strategy.is_disposed
class TestSimulatedExchangeContingencyAdvancedOrders:
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(
clock=self.clock,
level_stdout=LogLevel.INFO,
)
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_engine = DataEngine(
msgbus=self.msgbus,
clock=self.clock,
cache=self.cache,
logger=self.logger,
)
self.exec_engine = ExecutionEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.risk_engine = RiskEngine(
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exchange = SimulatedExchange(
venue=FTX,
venue_type=VenueType.EXCHANGE,
oms_type=OMSType.NETTING,
account_type=AccountType.MARGIN,
base_currency=None, # Multi-asset wallet
starting_balances=[Money(200, ETH),
Money(1_000_000, USD)],
default_leverage=Decimal(100),
leverages={},
is_frozen_account=False,
instruments=[ETHUSD_FTX],
modules=[],
fill_model=FillModel(),
cache=self.cache,
clock=self.clock,
logger=self.logger,
latency_model=LatencyModel(0),
)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=AccountId("FTX", "001"),
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Wire up components
self.exec_engine.register_client(self.exec_client)
self.exchange.register_client(self.exec_client)
self.cache.add_instrument(ETHUSD_FTX)
# Create mock strategy
self.strategy = MockStrategy(
bar_type=TestStubs.bartype_usdjpy_1min_bid())
self.strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Start components
self.exchange.reset()
self.data_engine.start()
self.exec_engine.start()
self.strategy.start()
def test_submit_bracket_market_buy_accepts_sl_and_tp(self):
# Arrange: Prepare market
tick = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick)
self.exchange.process_tick(tick)
bracket = self.strategy.order_factory.bracket_market(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
# Act
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Assert
assert bracket.orders[0].status == OrderStatus.FILLED
assert bracket.orders[1].status == OrderStatus.ACCEPTED
assert bracket.orders[2].status == OrderStatus.ACCEPTED
def test_submit_bracket_market_sell_accepts_sl_and_tp(self):
# Arrange: Prepare market
tick = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick)
self.exchange.process_tick(tick)
bracket = self.strategy.order_factory.bracket_market(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.SELL,
quantity=ETHUSD_FTX.make_qty(10.000),
stop_loss=ETHUSD_FTX.make_price(3150.0),
take_profit=ETHUSD_FTX.make_price(3050.0),
)
# Act
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Assert
assert bracket.orders[0].status == OrderStatus.FILLED
assert bracket.orders[1].status == OrderStatus.ACCEPTED
assert bracket.orders[2].status == OrderStatus.ACCEPTED
def test_submit_bracket_limit_buy_has_sl_tp_pending(self):
# Arrange: Prepare market
tick = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick)
self.exchange.process_tick(tick)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3090.0),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
# Act
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
#
# # Assert
assert bracket.orders[0].status == OrderStatus.ACCEPTED
assert bracket.orders[1].status == OrderStatus.SUBMITTED
assert bracket.orders[2].status == OrderStatus.SUBMITTED
def test_submit_bracket_limit_sell_has_sl_tp_pending(self):
# Arrange: Prepare market
tick = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick)
self.exchange.process_tick(tick)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.SELL,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3100.0),
stop_loss=ETHUSD_FTX.make_price(3150.0),
take_profit=ETHUSD_FTX.make_price(3050.0),
)
# Act
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
#
# # Assert
assert bracket.orders[0].status == OrderStatus.ACCEPTED
assert bracket.orders[1].status == OrderStatus.SUBMITTED
assert bracket.orders[2].status == OrderStatus.SUBMITTED
def test_submit_bracket_limit_buy_fills_then_triggers_sl_and_tp(self):
# Arrange: Prepare market
tick = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick)
self.exchange.process_tick(tick)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3100.0),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
# Act
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Assert
assert bracket.orders[0].status == OrderStatus.FILLED
assert bracket.orders[1].status == OrderStatus.ACCEPTED
assert bracket.orders[2].status == OrderStatus.ACCEPTED
assert len(self.exchange.get_working_orders()) == 2
assert bracket.orders[1] in self.exchange.get_working_orders()
assert bracket.orders[2] in self.exchange.get_working_orders()
def test_submit_bracket_limit_sell_fills_then_triggers_sl_and_tp(self):
# Arrange: Prepare market
tick = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick)
self.exchange.process_tick(tick)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.SELL,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3050.0),
stop_loss=ETHUSD_FTX.make_price(3150.0),
take_profit=ETHUSD_FTX.make_price(3000.0),
)
# Act
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Assert
assert bracket.orders[0].status == OrderStatus.FILLED
assert bracket.orders[1].status == OrderStatus.ACCEPTED
assert bracket.orders[2].status == OrderStatus.ACCEPTED
assert len(self.exchange.get_working_orders()) == 2
assert bracket.orders[1] in self.exchange.get_working_orders()
assert bracket.orders[2] in self.exchange.get_working_orders()
def test_reject_bracket_entry_then_rejects_sl_and_tp(self):
# Arrange: Prepare market
tick = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick)
self.exchange.process_tick(tick)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.SELL,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3050.0), # <-- in the market
stop_loss=ETHUSD_FTX.make_price(3150.0),
take_profit=ETHUSD_FTX.make_price(3000.0),
post_only=True, # <-- will reject placed into the market
)
# Act
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Assert
assert bracket.orders[0].status == OrderStatus.REJECTED
assert bracket.orders[1].status == OrderStatus.REJECTED
assert bracket.orders[2].status == OrderStatus.REJECTED
assert len(self.exchange.get_working_orders()) == 0
assert bracket.orders[1] not in self.exchange.get_working_orders()
assert bracket.orders[2] not in self.exchange.get_working_orders()
def test_filling_bracket_sl_cancels_tp_order(self):
# Arrange: Prepare market
tick1 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick1)
self.exchange.process_tick(tick1)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3100.0),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
tick2 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3150.0),
ask=ETHUSD_FTX.make_price(3151.0),
bid_size=ETHUSD_FTX.make_qty(10.000),
ask_size=ETHUSD_FTX.make_qty(10.000),
ts_event=0,
ts_init=0,
)
# Act
self.exchange.process_tick(tick2)
# Assert
assert bracket.orders[0].status == OrderStatus.FILLED
assert bracket.orders[1].status == OrderStatus.CANCELED
assert bracket.orders[2].status == OrderStatus.FILLED
assert len(self.exchange.get_working_orders()) == 0
assert len(self.exchange.cache.positions_open()) == 0
def test_filling_bracket_tp_cancels_sl_order(self):
# Arrange: Prepare market
tick1 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick1)
self.exchange.process_tick(tick1)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3100.0),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Act
tick2 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3150.0),
ask=ETHUSD_FTX.make_price(3151.0),
bid_size=ETHUSD_FTX.make_qty(10.000),
ask_size=ETHUSD_FTX.make_qty(10.000),
ts_event=0,
ts_init=0,
)
self.exchange.process_tick(tick2)
# Assert
assert bracket.orders[0].status == OrderStatus.FILLED
assert bracket.orders[1].status == OrderStatus.CANCELED
assert bracket.orders[2].status == OrderStatus.FILLED
assert len(self.exchange.get_working_orders()) == 0
assert len(self.exchange.cache.positions_open()) == 0
def test_partial_fill_bracket_tp_updates_sl_order(self):
# Arrange: Prepare market
tick1 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick1)
self.exchange.process_tick(tick1)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3100.0),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
en = bracket.orders[0]
sl = bracket.orders[1]
tp = bracket.orders[2]
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Act
tick2 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3150.0),
ask=ETHUSD_FTX.make_price(3151.0),
bid_size=ETHUSD_FTX.make_qty(5.000),
ask_size=ETHUSD_FTX.make_qty(5.1000),
ts_event=0,
ts_init=0,
)
self.exchange.process_tick(tick2)
# Assert
assert en.status == OrderStatus.FILLED
assert sl.status == OrderStatus.ACCEPTED
assert tp.status == OrderStatus.PARTIALLY_FILLED
assert sl.quantity == Quantity.from_int(5)
assert tp.leaves_qty == Quantity.from_int(5)
assert tp.quantity == Quantity.from_int(10)
assert len(self.exchange.get_working_orders()) == 2
assert len(self.exchange.cache.positions_open()) == 1
def test_modifying_bracket_tp_updates_sl_order(self):
# Arrange: Prepare market
tick1 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick1)
self.exchange.process_tick(tick1)
bracket = self.strategy.order_factory.bracket_limit(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
entry=ETHUSD_FTX.make_price(3100.0),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
en = bracket.orders[0]
sl = bracket.orders[1]
tp = bracket.orders[2]
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Act
self.strategy.modify_order(
order=sl,
quantity=Quantity.from_int(5),
price=sl.price,
)
self.exchange.process(0)
# Assert
assert en.status == OrderStatus.FILLED
assert sl.status == OrderStatus.ACCEPTED
assert tp.status == OrderStatus.ACCEPTED
assert sl.quantity == Quantity.from_int(5)
assert tp.quantity == Quantity.from_int(5)
assert len(self.exchange.get_working_orders()) == 2
assert len(self.exchange.cache.positions_open()) == 1
def test_closing_position_cancels_bracket_ocos(self):
# Arrange: Prepare market
tick1 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick1)
self.exchange.process_tick(tick1)
bracket = self.strategy.order_factory.bracket_market(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
en = bracket.orders[0]
sl = bracket.orders[1]
tp = bracket.orders[2]
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Act
self.strategy.flatten_position(
self.strategy.cache.position(en.position_id))
self.exchange.process(0)
# Assert
assert en.status == OrderStatus.FILLED
assert sl.status == OrderStatus.CANCELED
assert tp.status == OrderStatus.CANCELED
assert len(self.exchange.get_working_orders()) == 0
assert len(self.exchange.cache.positions_open()) == 0
def test_partially_filling_position_updates_bracket_ocos(self):
# Arrange: Prepare market
tick1 = QuoteTick(
instrument_id=ETHUSD_FTX.id,
bid=ETHUSD_FTX.make_price(3090.2),
ask=ETHUSD_FTX.make_price(3090.5),
bid_size=ETHUSD_FTX.make_qty(15.100),
ask_size=ETHUSD_FTX.make_qty(15.100),
ts_event=0,
ts_init=0,
)
self.data_engine.process(tick1)
self.exchange.process_tick(tick1)
bracket = self.strategy.order_factory.bracket_market(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.BUY,
quantity=ETHUSD_FTX.make_qty(10.000),
stop_loss=ETHUSD_FTX.make_price(3050.0),
take_profit=ETHUSD_FTX.make_price(3150.0),
)
en = bracket.orders[0]
sl = bracket.orders[1]
tp = bracket.orders[2]
self.strategy.submit_order_list(bracket)
self.exchange.process(0)
# Act
reduce_order = self.strategy.order_factory.market(
instrument_id=ETHUSD_FTX.id,
order_side=OrderSide.SELL,
quantity=ETHUSD_FTX.make_qty(5.000),
)
self.strategy.submit_order(
reduce_order,
position_id=self.cache.position_for_order(en.client_order_id).id,
)
self.exchange.process(0)
# Assert
assert en.status == OrderStatus.FILLED
assert sl.status == OrderStatus.ACCEPTED
assert tp.status == OrderStatus.ACCEPTED
assert sl.quantity == ETHUSD_FTX.make_qty(5.000)
assert tp.quantity == ETHUSD_FTX.make_qty(5.000)
assert len(self.exchange.get_working_orders()) == 2
assert len(self.exchange.cache.positions_open()) == 1
class TestL2OrderBookExchange:
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(
clock=self.clock,
level_stdout=LogLevel.DEBUG,
)
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_engine = DataEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exec_engine = ExecutionEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.risk_engine = RiskEngine(
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exchange = SimulatedExchange(
venue=SIM,
venue_type=VenueType.ECN,
oms_type=OMSType.HEDGING,
account_type=AccountType.MARGIN,
base_currency=USD,
starting_balances=[Money(1_000_000, USD)],
default_leverage=Decimal(50),
leverages={},
is_frozen_account=False,
instruments=[USDJPY_SIM],
modules=[],
fill_model=FillModel(),
cache=self.cache,
clock=self.clock,
logger=self.logger,
book_type=BookType.L2_MBP,
latency_model=LatencyModel(0),
)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=self.account_id,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Prepare components
self.cache.add_instrument(USDJPY_SIM)
self.cache.add_order_book(
OrderBook.create(
instrument=USDJPY_SIM,
book_type=BookType.L2_MBP,
))
self.exec_engine.register_client(self.exec_client)
self.exchange.register_client(self.exec_client)
self.strategy = MockStrategy(
bar_type=TestStubs.bartype_usdjpy_1min_bid())
self.strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exchange.reset()
self.data_engine.start()
self.exec_engine.start()
self.strategy.start()
def test_submit_limit_order_aggressive_multiple_levels(self):
# Arrange: Prepare market
self.cache.add_instrument(USDJPY_SIM)
quote = QuoteTick(
instrument_id=USDJPY_SIM.id,
bid=Price.from_str("110.000"),
ask=Price.from_str("110.010"),
bid_size=Quantity.from_int(1500000),
ask_size=Quantity.from_int(1500000),
ts_event=0,
ts_init=0,
)
self.data_engine.process(quote)
snapshot = TestStubs.order_book_snapshot(
instrument_id=USDJPY_SIM.id,
bid_volume=1000,
ask_volume=1000,
)
self.data_engine.process(snapshot)
self.exchange.process_order_book(snapshot)
# Create order
order = self.strategy.order_factory.limit(
instrument_id=USDJPY_SIM.id,
order_side=OrderSide.BUY,
quantity=Quantity.from_int(2000),
price=Price.from_int(20),
post_only=False,
)
# Act
self.strategy.submit_order(order)
self.exchange.process(0)
# Assert
assert order.status == OrderStatus.FILLED
assert order.filled_qty == Decimal("2000.0") # No slippage
assert order.avg_px == Decimal("15.33333333333333333333333333")
assert self.exchange.get_account().balance_total(USD) == Money(
999999.96, USD)
def test_aggressive_partial_fill(self):
# Arrange: Prepare market
self.cache.add_instrument(USDJPY_SIM)
quote = QuoteTick(
instrument_id=USDJPY_SIM.id,
bid=Price.from_str("110.000"),
ask=Price.from_str("110.010"),
bid_size=Quantity.from_int(1500000),
ask_size=Quantity.from_int(1500000),
ts_event=0,
ts_init=0,
)
self.data_engine.process(quote)
snapshot = TestStubs.order_book_snapshot(
instrument_id=USDJPY_SIM.id,
bid_volume=1000,
ask_volume=1000,
)
self.data_engine.process(snapshot)
self.exchange.process_order_book(snapshot)
# Act
order = self.strategy.order_factory.limit(
instrument_id=USDJPY_SIM.id,
order_side=OrderSide.BUY,
quantity=Quantity.from_int(7000),
price=Price.from_int(20),
post_only=False,
)
self.strategy.submit_order(order)
self.exchange.process(0)
# Assert
assert order.status == OrderStatus.PARTIALLY_FILLED
assert order.filled_qty == Quantity.from_str("6000.0") # No slippage
assert order.avg_px == Decimal("15.93333333333333333333333333")
assert self.exchange.get_account().balance_total(USD) == Money(
999999.88, USD)
def test_passive_post_only_insert(self):
# Arrange: Prepare market
self.cache.add_instrument(USDJPY_SIM)
# Market is 10 @ 15
snapshot = TestStubs.order_book_snapshot(instrument_id=USDJPY_SIM.id,
bid_volume=1000,
ask_volume=1000)
self.data_engine.process(snapshot)
self.exchange.process_order_book(snapshot)
# Act
order = self.strategy.order_factory.limit(
instrument_id=USDJPY_SIM.id,
order_side=OrderSide.SELL,
quantity=Quantity.from_int(2000),
price=Price.from_str("14"),
post_only=True,
)
self.strategy.submit_order(order)
self.exchange.process(0)
# Assert
assert order.status == OrderStatus.ACCEPTED
# TODO - Need to discuss how we are going to support passive quotes trading now
@pytest.mark.skip
def test_passive_partial_fill(self):
# Arrange: Prepare market
self.cache.add_instrument(USDJPY_SIM)
# Market is 10 @ 15
snapshot = TestStubs.order_book_snapshot(instrument_id=USDJPY_SIM.id,
bid_volume=1000,
ask_volume=1000)
self.data_engine.process(snapshot)
self.exchange.process_order_book(snapshot)
order = self.strategy.order_factory.limit(
instrument_id=USDJPY_SIM.id,
order_side=OrderSide.SELL,
quantity=Quantity.from_int(1000),
price=Price.from_str("14"),
post_only=False,
)
self.strategy.submit_order(order)
# Act
tick = TestStubs.quote_tick_3decimal(
instrument_id=USDJPY_SIM.id,
bid=Price.from_str("15"),
bid_volume=Quantity.from_int(1000),
ask=Price.from_str("16"),
ask_volume=Quantity.from_int(1000),
)
# New tick will be in cross with our order
self.exchange.process_tick(tick)
# Assert
assert order.status == OrderStatus.PARTIALLY_FILLED
assert order.filled_qty == Quantity.from_str("1000.0")
assert order.avg_px == Decimal("15.0")
# TODO - Need to discuss how we are going to support passive quotes trading now
@pytest.mark.skip
def test_passive_fill_on_trade_tick(self):
# Arrange: Prepare market
# Market is 10 @ 15
snapshot = TestStubs.order_book_snapshot(instrument_id=USDJPY_SIM.id,
bid_volume=1000,
ask_volume=1000)
self.data_engine.process(snapshot)
self.exchange.process_order_book(snapshot)
order = self.strategy.order_factory.limit(
instrument_id=USDJPY_SIM.id,
order_side=OrderSide.SELL,
quantity=Quantity.from_int(2000),
price=Price.from_str("14"),
post_only=False,
)
self.strategy.submit_order(order)
# Act
tick1 = TradeTick(
instrument_id=USDJPY_SIM.id,
price=Price.from_str("14.0"),
size=Quantity.from_int(1000),
aggressor_side=AggressorSide.SELL,
trade_id="123456789",
ts_event=0,
ts_init=0,
)
self.exchange.process_tick(tick1)
# Assert
assert order.status == OrderStatus.PARTIALLY_FILLED
assert order.filled_qty == Quantity.from_int(1000.0) # No slippage
assert order.avg_px == Decimal("14.0")