def test_create_level_fail():
# Arrange
# Act
# Assert
with pytest.raises(ValueError):
OrderBook.create(
instrument=AUDUSD_SIM,
book_type=0,
)
def test_add_l1_fails():
book = OrderBook.create(
instrument=AUDUSD_SIM,
level=OrderBookLevel.L1,
)
with pytest.raises(NotImplementedError):
book.add(TestStubs.order(price=10.0, side=OrderSide.BUY))
def order_book(
instrument=None,
book_type=BookType.L2_MBP,
bid_price=10,
ask_price=15,
bid_levels=3,
ask_levels=3,
bid_volume=10,
ask_volume=10,
) -> OrderBook:
instrument = instrument or TestInstrumentProvider.default_fx_ccy(
"AUD/USD")
order_book = OrderBook.create(
instrument=instrument,
book_type=book_type,
)
snapshot = TestDataStubs.order_book_snapshot(
instrument_id=instrument.id,
bid_price=bid_price,
ask_price=ask_price,
bid_levels=bid_levels,
ask_levels=ask_levels,
bid_volume=bid_volume,
ask_volume=ask_volume,
)
order_book.apply_snapshot(snapshot)
return order_book
def on_start(self):
"""Actions to be performed on strategy start."""
self.instrument = self.cache.instrument(self.instrument_id)
if self.instrument is None:
self.log.error(f"Could not find instrument for {self.instrument_id}")
self.stop()
return
if self.config.book_type:
self.book = OrderBook.create(
instrument=self.instrument, book_type=self.config.book_type
)
if self.config.snapshots:
self.subscribe_order_book_snapshots(
instrument_id=self.instrument_id, book_type=self.config.book_type
)
else:
self.subscribe_order_book_deltas(
instrument_id=self.instrument_id, book_type=self.config.book_type
)
if self.config.trade_ticks:
self.subscribe_trade_ticks(instrument_id=self.instrument_id)
if self.config.quote_ticks:
self.subscribe_quote_ticks(instrument_id=self.instrument_id)
def test_delete_l1():
book = OrderBook.create(
instrument=AUDUSD_SIM,
level=OrderBookLevel.L1,
)
order = TestStubs.order(price=10.0, side=OrderSide.BUY)
book.update(order)
book.delete(order)
def test_delete_l1():
book = OrderBook.create(
instrument=AUDUSD_SIM,
book_type=BookType.L1_TBBO,
)
order = TestStubs.order(price=10.0, side=OrderSide.BUY)
book.update(order)
book.delete(order)
def test_spread_with_no_orders_returns_none():
# Arrange
book = OrderBook.create(
instrument=AUDUSD_SIM,
level=OrderBookLevel.L2,
)
# Act
# Assert
assert book.spread() is None
def test_spread_with_no_orders_returns_none():
# Arrange
book = OrderBook.create(
instrument=AUDUSD_SIM,
book_type=BookType.L2_MBP,
)
# Act
# Assert
assert book.spread() is None
def test_best_bid_or_ask_qty_with_no_orders_returns_none():
# Arrange
book = OrderBook.create(
instrument=AUDUSD_SIM,
level=OrderBookLevel.L2,
)
# Act
# Assert
assert book.best_bid_qty() is None
assert book.best_ask_qty() is None
def test_best_bid_or_ask_qty_with_no_orders_returns_none():
# Arrange
book = OrderBook.create(
instrument=AUDUSD_SIM,
book_type=BookType.L2_MBP,
)
# Act
# Assert
assert book.best_bid_qty() is None
assert book.best_ask_qty() is None
def test_spread_with_no_orders_returns_none(self):
# Arrange
book = OrderBook.create(
instrument_id=AUDUSD,
level=OrderBookLevel.L2,
price_precision=2,
size_precision=2,
)
# Act
# Assert
assert book.spread() is None
def on_start(self):
self.instrument = self.cache.instrument(self.instrument_id)
if self.instrument is None:
self.log.error(f"Could not find instrument for {self.instrument_id}")
self.stop()
return
# Create orderbook
self._book = OrderBook.create(instrument=self.instrument, book_type=BookType.L2_MBP)
# Subscribe to live data
self.subscribe_order_book_deltas(self.instrument_id)
def test_repr():
book = OrderBook.create(
instrument=AUDUSD_SIM,
level=OrderBookLevel.L2,
)
# Act
book.add(Order(price=10.0, volume=5.0, side=OrderSide.BUY))
book.add(Order(price=11.0, volume=6.0, side=OrderSide.SELL))
# Assert
assert isinstance(repr(book), str) # <-- calls pprint internally
def test_repr():
book = OrderBook.create(
instrument=AUDUSD_SIM,
book_type=BookType.L2_MBP,
)
# Act
book.add(Order(price=10.0, size=5.0, side=OrderSide.BUY))
book.add(Order(price=11.0, size=6.0, side=OrderSide.SELL))
# Assert
assert isinstance(repr(book), str) # <-- calls pprint internally
def on_start(self):
"""Actions to be performed on strategy start."""
# self.request_data(
# "BETFAIR", DataType(InstrumentSearch, metadata=self.instrument_filter)
# )
self.subscribe_order_book_deltas(
instrument_id=self.instrument.id,
level=BookLevel.L2,
)
self._book = OrderBook.create(
instrument=self.instrument,
level=BookLevel.L2,
)
def test_create_level_3_order_book(self):
# Arrange
# Act
book = OrderBook.create(
instrument_id=AUDUSD,
level=OrderBookLevel.L3,
price_precision=2,
size_precision=2,
)
# Assert
assert isinstance(book, L3OrderBook)
assert book.level == OrderBookLevel.L3
def test_repr(self):
book = OrderBook.create(
instrument_id=AUDUSD,
level=OrderBookLevel.L2,
price_precision=2,
size_precision=2,
)
# Act
book.add(Order(price=10, volume=5, side=OrderSide.BUY))
book.add(Order(price=11, volume=6, side=OrderSide.SELL))
# Assert
assert isinstance(repr(book), str) # <-- calls pprint internally
def test_create_level_3_order_book():
# Arrange
# Act
book = OrderBook.create(
instrument=AUDUSD_SIM,
book_type=BookType.L3_MBO,
)
# Assert
assert isinstance(book, L3OrderBook)
assert book.type == BookType.L3_MBO
assert isinstance(book.bids, Ladder) and isinstance(book.asks, Ladder)
assert book.bids.reverse
assert not book.asks.reverse
def test_create_level_3_order_book():
# Arrange
# Act
book = OrderBook.create(
instrument=AUDUSD_SIM,
level=OrderBookLevel.L3,
)
# Assert
assert isinstance(book, L3OrderBook)
assert book.level == OrderBookLevel.L3
assert isinstance(book.bids, Ladder) and isinstance(book.asks, Ladder)
assert book.bids.reverse
assert not book.asks.reverse
def test_add_orders_to_book():
# Arrange
book = OrderBook.create(
instrument=AUDUSD_SIM,
book_type=BookType.L2_MBP,
)
# Act
book.add(Order(price=10.0, size=5.0, side=OrderSide.BUY))
book.add(Order(price=11.0, size=6.0, side=OrderSide.SELL))
# Assert
assert book.best_bid_price() == 10.0
assert book.best_ask_price() == 11.0
assert book.best_bid_qty() == 5.0
assert book.best_ask_qty() == 6.0
assert book.spread() == 1
def on_start(self):
"""Actions to be performed on strategy start."""
self.instrument = self.cache.instrument(self.instrument_id)
if self.instrument is None:
self.log.error(
f"Could not find instrument for {self.instrument_id}")
self.stop()
return
self.subscribe_order_book_deltas(
instrument_id=self.instrument.id,
book_type=BookType.L2_MBP,
)
self._book = OrderBook.create(
instrument=self.instrument,
book_type=BookType.L2_MBP,
)
def test_add_orders_to_book():
# Arrange
book = OrderBook.create(
instrument=AUDUSD_SIM,
level=OrderBookLevel.L2,
)
# Act
book.add(Order(price=10.0, volume=5.0, side=OrderSide.BUY))
book.add(Order(price=11.0, volume=6.0, side=OrderSide.SELL))
# Assert
assert book.best_bid_price() == 10.0
assert book.best_ask_price() == 11.0
assert book.best_bid_qty() == 5.0
assert book.best_ask_qty() == 6.0
assert book.spread() == 1
def test_add_orders_to_book(self):
# Arrange
book = OrderBook.create(
instrument_id=AUDUSD,
level=OrderBookLevel.L2,
price_precision=2,
size_precision=2,
)
# Act
book.add(Order(price=10, volume=5, side=OrderSide.BUY))
book.add(Order(price=11, volume=6, side=OrderSide.SELL))
# Assert
assert book.best_bid_price() == 10
assert book.best_ask_price() == 11
assert book.best_bid_qty() == 5
assert book.best_ask_qty() == 6
assert book.spread() == 1
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 = TestIdStubs.trader_id()
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestComponentStubs.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,
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,
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=TestDataStubs.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()