def test_handle_trade_tick_when_volume_at_threshold_sends_bar_to_handler(
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(3000),
aggressor_side=AggressorSide.BUY,
trade_id=TradeId("123456"),
ts_event=0,
ts_init=0,
)
tick2 = TradeTick(
instrument_id=instrument.id,
price=Price.from_str("1.00002"),
size=Quantity.from_int(4000),
aggressor_side=AggressorSide.BUY,
trade_id=TradeId("123457"),
ts_event=0,
ts_init=0,
)
tick3 = TradeTick(
instrument_id=instrument.id,
price=Price.from_str("1.00000"),
size=Quantity.from_int(3000),
aggressor_side=AggressorSide.BUY,
trade_id=TradeId("123458"),
ts_event=0,
ts_init=0,
)
# Act
aggregator.handle_trade_tick(tick1)
aggregator.handle_trade_tick(tick2)
aggregator.handle_trade_tick(tick3)
# Assert
assert len(bar_store.get_store()) == 1
assert bar_store.get_store()[0].open == Price.from_str("1.00001")
assert bar_store.get_store()[0].high == Price.from_str("1.00002")
assert bar_store.get_store()[0].low == Price.from_str("1.00000")
assert bar_store.get_store()[0].close == Price.from_str("1.00000")
assert bar_store.get_store()[0].volume == Quantity.from_int(10000)
def test_handle_quote_tick_when_volume_at_threshold_sends_bar_to_handler(
self):
# Arrange
bar_store = ObjectStorer()
handler = bar_store.store
instrument = AUDUSD_SIM
bar_spec = BarSpecification(10000, BarAggregation.VOLUME,
PriceType.BID)
bar_type = BarType(instrument.id, bar_spec)
aggregator = VolumeBarAggregator(
instrument,
bar_type,
handler,
Logger(TestClock()),
)
tick1 = QuoteTick(
instrument_id=instrument.id,
bid=Price.from_str("1.00001"),
ask=Price.from_str("1.00004"),
bid_size=Quantity.from_int(3000),
ask_size=Quantity.from_int(2000),
ts_event=0,
ts_init=0,
)
tick2 = QuoteTick(
instrument_id=instrument.id,
bid=Price.from_str("1.00002"),
ask=Price.from_str("1.00005"),
bid_size=Quantity.from_int(4000),
ask_size=Quantity.from_int(2000),
ts_event=0,
ts_init=0,
)
tick3 = QuoteTick(
instrument_id=instrument.id,
bid=Price.from_str("1.00000"),
ask=Price.from_str("1.00003"),
bid_size=Quantity.from_int(3000),
ask_size=Quantity.from_int(2000),
ts_event=0,
ts_init=0,
)
# Act
aggregator.handle_quote_tick(tick1)
aggregator.handle_quote_tick(tick2)
aggregator.handle_quote_tick(tick3)
# Assert
assert len(bar_store.get_store()) == 1
assert bar_store.get_store()[0].open == Price.from_str("1.00001")
assert bar_store.get_store()[0].high == Price.from_str("1.00002")
assert bar_store.get_store()[0].low == Price.from_str("1.00000")
assert bar_store.get_store()[0].close == Price.from_str("1.00000")
assert bar_store.get_store()[0].volume == Quantity.from_int(10000)
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER", "000")
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S", "001"),
clock=self.clock,
)
self.random_order_factory = OrderFactory(
trader_id=TraderId("RANDOM", "042"),
strategy_id=StrategyId("S", "042"),
clock=self.clock,
)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.database = BypassExecutionDatabase(trader_id=self.trader_id,
logger=self.logger)
self.engine = LiveExecutionEngine(
loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.instrument_provider = InstrumentProvider()
self.instrument_provider.add(AUDUSD_SIM)
self.instrument_provider.add(GBPUSD_SIM)
self.client = MockLiveExecutionClient(
name=SIM.value,
account_id=self.account_id,
engine=self.engine,
instrument_provider=self.instrument_provider,
clock=self.clock,
logger=self.logger,
)
self.engine.register_client(self.client)
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.logger = Logger(self.clock)
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 = Cache(
database=None,
logger=self.logger,
)
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.strategy = TradingStrategy()
self.strategy.register(
trader_id=self.trader_id,
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
def test_handle_trade_tick_when_volume_beyond_threshold_sends_bars_to_handler(self):
# Arrange
bar_store = ObjectStorer()
handler = bar_store.store
instrument_id = TestStubs.audusd_id()
bar_spec = BarSpecification(100000, BarAggregation.VALUE, PriceType.LAST)
bar_type = BarType(instrument_id, bar_spec)
aggregator = ValueBarAggregator(bar_type, handler, Logger(TestClock()))
tick1 = TradeTick(
instrument_id=AUDUSD_SIM.id,
price=Price("20.00001"),
size=Quantity("3000.00"),
side=OrderSide.BUY,
match_id=TradeMatchId("123456"),
timestamp_ns=0,
)
tick2 = TradeTick(
instrument_id=AUDUSD_SIM.id,
price=Price("20.00002"),
size=Quantity("4000.00"),
side=OrderSide.BUY,
match_id=TradeMatchId("123457"),
timestamp_ns=0,
)
tick3 = TradeTick(
instrument_id=AUDUSD_SIM.id,
price=Price("20.00000"),
size=Quantity("5000.00"),
side=OrderSide.BUY,
match_id=TradeMatchId("123458"),
timestamp_ns=0,
)
# Act
aggregator.handle_trade_tick(tick1)
aggregator.handle_trade_tick(tick2)
aggregator.handle_trade_tick(tick3)
# Assert
self.assertEqual(2, len(bar_store.get_store()))
self.assertEqual(Price("20.00001"), bar_store.get_store()[0].open)
self.assertEqual(Price("20.00002"), bar_store.get_store()[0].high)
self.assertEqual(Price("20.00001"), bar_store.get_store()[0].low)
self.assertEqual(Price("20.00002"), bar_store.get_store()[0].close)
# self.assertEqual(Quantity("5000.00"), bar_store.get_store()[0].volume) # TODO: WIP - intermittent?
self.assertEqual(Price("20.00002"), bar_store.get_store()[1].open)
self.assertEqual(Price("20.00002"), bar_store.get_store()[1].high)
self.assertEqual(Price("20.00000"), bar_store.get_store()[1].low)
self.assertEqual(Price("20.00000"), bar_store.get_store()[1].close)
# self.assertEqual(Quantity("5000.00"), bar_store.get_store()[1].volume) # TODO: WIP - intermittent?
self.assertEqual(
Decimal("40000.11000"), aggregator.get_cumulative_value()
) # TODO: WIP - Should be 40000
def test_handle_trade_tick_when_count_at_threshold_sends_bar_to_handler(
self):
# Arrange
bar_store = ObjectStorer()
handler = bar_store.store
instrument_id = TestStubs.audusd_id()
bar_spec = BarSpecification(3, BarAggregation.TICK, PriceType.LAST)
bar_type = BarType(instrument_id, bar_spec)
aggregator = TickBarAggregator(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,
)
tick2 = TradeTick(
instrument_id=AUDUSD_SIM.id,
price=Price.from_str("1.00002"),
size=Quantity.from_int(1),
aggressor_side=AggressorSide.BUY,
match_id=TradeMatchId("123457"),
timestamp_origin_ns=0,
timestamp_ns=0,
)
tick3 = TradeTick(
instrument_id=AUDUSD_SIM.id,
price=Price.from_str("1.00000"),
size=Quantity.from_int(1),
aggressor_side=AggressorSide.BUY,
match_id=TradeMatchId("123458"),
timestamp_origin_ns=0,
timestamp_ns=0,
)
# Act
aggregator.handle_trade_tick(tick1)
aggregator.handle_trade_tick(tick2)
aggregator.handle_trade_tick(tick3)
# Assert
self.assertEqual(1, len(bar_store.get_store()))
self.assertEqual(Price.from_str("1.00001"),
bar_store.get_store()[0].open)
self.assertEqual(Price.from_str("1.00002"),
bar_store.get_store()[0].high)
self.assertEqual(Price.from_str("1.00000"),
bar_store.get_store()[0].low)
self.assertEqual(Price.from_str("1.00000"),
bar_store.get_store()[0].close)
self.assertEqual(Quantity.from_int(3), bar_store.get_store()[0].volume)
def test_handle_quote_tick_when_count_at_threshold_sends_bar_to_handler(
self):
# Arrange
bar_store = ObjectStorer()
handler = bar_store.store
instrument_id = TestStubs.audusd_id()
bar_spec = BarSpecification(3, BarAggregation.TICK, PriceType.MID)
bar_type = BarType(instrument_id, bar_spec)
aggregator = TickBarAggregator(bar_type, handler, Logger(TestClock()))
tick1 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price.from_str("1.00001"),
ask=Price.from_str("1.00004"),
bid_size=Quantity.from_int(1),
ask_size=Quantity.from_int(1),
timestamp_origin_ns=0,
timestamp_ns=0,
)
tick2 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price.from_str("1.00002"),
ask=Price.from_str("1.00005"),
bid_size=Quantity.from_int(1),
ask_size=Quantity.from_int(1),
timestamp_origin_ns=0,
timestamp_ns=0,
)
tick3 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price.from_str("1.00000"),
ask=Price.from_str("1.00003"),
bid_size=Quantity.from_int(1),
ask_size=Quantity.from_int(1),
timestamp_origin_ns=0,
timestamp_ns=0,
)
# Act
aggregator.handle_quote_tick(tick1)
aggregator.handle_quote_tick(tick2)
aggregator.handle_quote_tick(tick3)
# Assert
self.assertEqual(1, len(bar_store.get_store()))
self.assertEqual(Price.from_str("1.000025"),
bar_store.get_store()[0].open)
self.assertEqual(Price.from_str("1.000035"),
bar_store.get_store()[0].high)
self.assertEqual(Price.from_str("1.000015"),
bar_store.get_store()[0].low)
self.assertEqual(Price.from_str("1.000015"),
bar_store.get_store()[0].close)
self.assertEqual(Quantity.from_int(3), bar_store.get_store()[0].volume)
def test_log_info_messages_to_console(self):
# Arrange
logger = Logger(clock=TestClock(), level_stdout=LogLevel.INFO)
logger_adapter = LoggerAdapter(component="TEST_LOGGER", logger=logger)
# Act
logger_adapter.info("This is a log message.")
# Assert
assert True # No exceptions raised
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER", "000")
self.account_id = AccountId("BINANCE", "000")
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
database = BypassExecutionDatabase(
trader_id=self.trader_id,
logger=self.logger,
)
self.exec_engine = ExecutionEngine(
database=database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.exchange = SimulatedExchange(
venue=Venue("BINANCE"),
oms_type=OMSType.NETTING,
is_frozen_account=False,
starting_balances=[Money(1_000_000, USD)],
instruments=[ETHUSDT_BINANCE],
modules=[],
exec_cache=self.exec_engine.cache,
fill_model=FillModel(),
clock=self.clock,
logger=self.logger,
)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=self.account_id,
engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("SCALPER", "000"),
clock=self.clock,
)
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.account_id = TestIdStubs.account_id()
self.component_id = "MyComponent-001"
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestComponentStubs.cache()
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.data_client = BacktestMarketDataClient(
client_id=ClientId("SIM"),
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_engine.register_client(self.data_client)
# Add instruments
self.data_engine.process(AUDUSD_SIM)
self.data_engine.process(GBPUSD_SIM)
self.data_engine.process(USDJPY_SIM)
self.cache.add_instrument(AUDUSD_SIM)
self.cache.add_instrument(GBPUSD_SIM)
self.cache.add_instrument(USDJPY_SIM)
self.data_engine.start()
self.exec_engine.start()
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER-000")
self.account_id = AccountId("BINANCE", "000")
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exec_engine = ExecutionEngine(
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exchange = SimulatedExchange(
venue=Venue("BINANCE"),
venue_type=VenueType.EXCHANGE,
oms_type=OMSType.NETTING,
account_type=AccountType.CASH,
base_currency=None, # Multi-currency account
starting_balances=[Money(1_000_000, USDT)],
is_frozen_account=False,
instruments=[ETHUSDT_BINANCE],
modules=[],
cache=self.exec_engine.cache,
fill_model=FillModel(),
clock=self.clock,
logger=self.logger,
)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=self.account_id,
account_type=AccountType.CASH,
base_currency=None, # Multi-currency account
engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("SCALPER-001"),
clock=self.clock,
)
def test_log_critical_messages_to_console(self):
# Arrange
logger = Logger(clock=TestClock(), level_stdout=LogLevel.CRITICAL)
logger_adapter = LoggerAdapter(component_name="TEST_LOGGER",
logger=logger)
# Act
logger_adapter.critical("This is a log message.")
# Assert
assert True # No exceptions raised
def test_log_warning_messages_to_console(self):
# Arrange
logger = Logger(clock=TestClock(), level_stdout=LogLevel.WARNING)
logger_adapter = LoggerAdapter(component_name="TEST_LOGGER",
logger=logger)
# Act
logger_adapter.warning("This is a log message.")
# Assert
assert True # No exceptions raised
def test_log_info_messages_to_console_with_green_colour(self):
# Arrange
logger = Logger(clock=TestClock(), level_stdout=LogLevel.INFO)
logger_adapter = LoggerAdapter(component_name="TEST_LOGGER",
logger=logger)
# Act
logger_adapter.info("This is a log message.", color=LogColor.GREEN)
# Assert
assert True # No exceptions raised
def setUp(self):
# Fixture Setup
self.clock = TestClock()
logger = Logger(self.clock)
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER", "000"),
strategy_id=StrategyId("S", "001"),
clock=TestClock(),
)
self.portfolio = Portfolio(self.clock, logger)
self.portfolio.register_cache(DataCache(logger))
def test_log_info_with_annotation_sends_to_stdout(self):
# Arrange
logger = Logger(clock=TestClock(), level_stdout=LogLevel.INFO)
logger_adapter = LoggerAdapter(component="TEST_LOGGER", logger=logger)
annotations = {"my_tag": "something"}
# Act
logger_adapter.info("This is a log message.", annotations=annotations)
# Assert
assert True # No exceptions raised
def test_log_exception_messages_to_console(self):
# Arrange
logger = Logger(clock=TestClock(), level_stdout=LogLevel.CRITICAL)
logger_adapter = LoggerAdapter(component_name="TEST_LOGGER",
logger=logger)
# Act
logger_adapter.exception("We intentionally divided by zero!",
ZeroDivisionError("Oops"))
# Assert
assert True # No exceptions raised
def test_handle_quote_tick_when_value_beyond_threshold_sends_bar_to_handler(
self):
# Arrange
bar_store = ObjectStorer()
handler = bar_store.store
instrument_id = TestStubs.audusd_id()
bar_spec = BarSpecification(100000, BarAggregation.VALUE,
PriceType.BID)
bar_type = BarType(instrument_id, bar_spec)
aggregator = ValueBarAggregator(bar_type, handler, Logger(TestClock()))
tick1 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price("1.00001"),
ask=Price("1.00004"),
bid_size=Quantity(20000),
ask_size=Quantity(20000),
timestamp_ns=0,
)
tick2 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price("1.00002"),
ask=Price("1.00005"),
bid_size=Quantity(60000),
ask_size=Quantity(20000),
timestamp_ns=0,
)
tick3 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price("1.00000"),
ask=Price("1.00003"),
bid_size=Quantity(30500),
ask_size=Quantity(20000),
timestamp_ns=0,
)
# Act
aggregator.handle_quote_tick(tick1)
aggregator.handle_quote_tick(tick2)
aggregator.handle_quote_tick(tick3)
# Assert
self.assertEqual(1, len(bar_store.get_store()))
self.assertEqual(Price("1.00001"), bar_store.get_store()[0].open)
self.assertEqual(Price("1.00002"), bar_store.get_store()[0].high)
self.assertEqual(Price("1.00000"), bar_store.get_store()[0].low)
self.assertEqual(Price("1.00000"), bar_store.get_store()[0].close)
self.assertEqual(Quantity("99999"), bar_store.get_store()[0].volume)
self.assertEqual(Decimal("10501.400"),
aggregator.get_cumulative_value())
def test_update_timed_with_test_clock_sends_single_bar_to_handler(self):
# Arrange
clock = TestClock()
bar_store = ObjectStorer()
handler = bar_store.store
instrument_id = TestStubs.audusd_id()
bar_spec = BarSpecification(1, BarAggregation.MINUTE, PriceType.MID)
bar_type = BarType(instrument_id, bar_spec)
aggregator = TimeBarAggregator(
bar_type, handler, True, TestClock(), Logger(clock)
)
tick1 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price("1.00001"),
ask=Price("1.00004"),
bid_size=Quantity(1),
ask_size=Quantity(1),
timestamp_ns=0,
)
tick2 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price("1.00002"),
ask=Price("1.00005"),
bid_size=Quantity(1),
ask_size=Quantity(1),
timestamp_ns=0,
)
tick3 = QuoteTick(
instrument_id=AUDUSD_SIM.id,
bid=Price("1.00000"),
ask=Price("1.00003"),
bid_size=Quantity(1),
ask_size=Quantity(1),
timestamp_ns=2 * 60 * 1_000_000_000, # 2 minutes in nanoseconds
)
# Act
aggregator.handle_quote_tick(tick1)
aggregator.handle_quote_tick(tick2)
aggregator.handle_quote_tick(tick3)
# Assert
self.assertEqual(1, len(bar_store.get_store()))
self.assertEqual(Price("1.000025"), bar_store.get_store()[0].open)
self.assertEqual(Price("1.000035"), bar_store.get_store()[0].high)
self.assertEqual(Price("1.000025"), bar_store.get_store()[0].low)
self.assertEqual(Price("1.000035"), bar_store.get_store()[0].close)
self.assertEqual(Quantity(2), bar_store.get_store()[0].volume)
self.assertEqual(60_000_000_000, bar_store.get_store()[0].timestamp_ns)
def setUp(self):
# Fixture Setup
clock = TestClock()
logger = Logger(clock, level_stdout=LogLevel.DEBUG)
trader_id = TraderId("TESTER-000")
self.order_factory = OrderFactory(
trader_id=trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
cache_db = BypassCacheDatabase(
trader_id=trader_id,
logger=logger,
)
self.cache = Cache(
database=cache_db,
logger=logger,
)
self.portfolio = Portfolio(
cache=self.cache,
clock=clock,
logger=logger,
)
self.exec_engine = ExecutionEngine(
portfolio=self.portfolio,
cache=self.cache,
clock=clock,
logger=logger,
)
self.risk_engine = RiskEngine(
exec_engine=self.exec_engine,
portfolio=self.portfolio,
cache=self.cache,
clock=clock,
logger=logger,
)
# Wire up components
self.exec_engine.register_risk_engine(self.risk_engine)
# Prepare components
self.cache.add_instrument(AUDUSD_SIM)
self.cache.add_instrument(GBPUSD_SIM)
self.cache.add_instrument(BTCUSDT_BINANCE)
self.cache.add_instrument(BTCUSD_BITMEX)
self.cache.add_instrument(ETHUSD_BITMEX)
def setup(self):
# Fixture Setup
clock = LiveClock()
logger = Logger(clock=clock)
self.client = BinanceHttpClient( # noqa: S106 (no hardcoded password)
loop=asyncio.get_event_loop(),
clock=clock,
logger=logger,
key="SOME_BINANCE_API_KEY",
secret="SOME_BINANCE_API_SECRET",
)
self.api = BinanceSpotMarketHttpAPI(self.client)
def test_register_sink_sends_records_to_sink(self):
# Arrange
sink = []
logger = Logger(clock=TestClock(), level_stdout=LogLevel.CRITICAL)
logger_adapter = LoggerAdapter(component_name="TEST_LOGGER",
logger=logger)
# Act
logger.register_sink(sink.append)
logger_adapter.info("A log event", annotations={"tag": "risk"})
# Assert
assert sink[0] == {
"component": "TEST_LOGGER",
"machine_id": socket.gethostname(),
"level": "INF",
"msg": "A log event",
"instance_id": f"{logger.instance_id.value}",
"tag": "risk",
"timestamp": 0,
"trader_id": "TRADER-000",
}
def setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.loop.set_debug(True)
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(clock=self.clock)
self.trader_id = TestIdStubs.trader_id()
self.venue = BINANCE_VENUE
self.account_id = AccountId(self.venue.value, "001")
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestComponentStubs.cache()
self.http_client = BinanceHttpClient( # noqa: S106 (no hardcoded password)
loop=asyncio.get_event_loop(),
clock=self.clock,
logger=self.logger,
key="SOME_BINANCE_API_KEY",
secret="SOME_BINANCE_API_SECRET",
)
self.provider = BinanceSpotInstrumentProvider(
client=self.http_client,
logger=self.logger,
config=InstrumentProviderConfig(load_all=True),
)
self.data_engine = DataEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_client = BinanceDataClient(
loop=self.loop,
client=self.http_client,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
instrument_provider=self.provider,
)
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TestIdStubs.trader_id()
self.handler = []
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
async def test_binance_spot_market_http_client():
loop = asyncio.get_event_loop()
clock = LiveClock()
client = get_cached_binance_http_client(
loop=loop,
clock=clock,
logger=Logger(clock=clock),
key=os.getenv("BINANCE_API_KEY"),
secret=os.getenv("BINANCE_API_SECRET"),
)
await client.connect()
provider = BinanceSpotInstrumentProvider(
client=client,
logger=Logger(clock=clock),
)
await provider.load_all_async()
print(provider.count)
await client.disconnect()
def setup(self):
# Fixture setup
self.clock = TestClock()
self.logger = Logger(self.clock, bypass_logging=True)
self.handler = []
self.throttler = Throttler(
name="Throttler-1",
limit=10000,
interval=timedelta(seconds=1),
output=self.handler.append,
clock=self.clock,
logger=self.logger,
)
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
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.exec_engine = ExecutionEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.venue = Venue("SIM")
self.client = ExecutionClient(
client_id=ClientId(self.venue.value),
venue_type=VenueType.ECN,
account_id=TestStubs.account_id(),
account_type=AccountType.MARGIN,
base_currency=USD,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER-000"),
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.trader_id = TraderId("TESTER", "000")
self.logger = Logger(self.clock, bypass_logging=True)
self.account_id = AccountId("BINANCE", "001")
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.portfolio.register_cache(DataCache(self.logger))
self.analyzer = PerformanceAnalyzer()
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
database = BypassExecutionDatabase(trader_id=self.trader_id, logger=self.logger)
self.exec_engine = LiveExecutionEngine(
loop=self.loop,
database=database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
exec_client = MockExecutionClient(
client_id=ClientId("BINANCE"),
account_id=self.account_id,
engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
self.exec_engine.register_client(exec_client)
self.exec_engine.process(TestStubs.event_account_state(self.account_id))
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(self.strategy)
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER-000")
self.account_id = TestStubs.account_id()
self.venue = Venue("SIM")
self.portfolio = Portfolio(
cache=TestStubs.cache(),
clock=self.clock,
logger=self.logger,
)
self.exec_engine = ExecutionEngine(
portfolio=self.portfolio,
cache=TestStubs.cache(),
clock=self.clock,
logger=self.logger,
)
self.risk_engine = RiskEngine(
exec_engine=self.exec_engine,
portfolio=self.portfolio,
cache=TestStubs.cache(),
clock=self.clock,
logger=self.logger,
config={},
)
self.exec_client = MockExecutionClient(
client_id=ClientId(self.venue.value),
venue_type=VenueType.ECN,
account_id=self.account_id,
account_type=AccountType.MARGIN,
base_currency=USD,
engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
# Wire up components
self.exec_engine.register_risk_engine(self.risk_engine)
self.exec_engine.register_client(self.exec_client)
# Prepare data
self.exec_engine.cache.add_instrument(AUDUSD_SIM)
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.logger = Logger(self.clock)
self.handler = []
self.throttler = Throttler(
name="Buffer",
limit=5,
interval=timedelta(seconds=1),
output_send=self.handler.append,
output_drop=None, # <-- no dropping handler so will buffer
clock=self.clock,
logger=self.logger,
)
