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, )