def setUp(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock, level_stdout=LogLevel.DEBUG)
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.engine = LiveDataEngine(
loop=self.loop,
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
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(self.clock)
self.trader_id = TestStubs.trader_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.engine = LiveDataEngine(
loop=self.loop,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
def instrument_list(mock_load_markets_metadata,
loop: asyncio.AbstractEventLoop):
"""Prefill `INSTRUMENTS` cache for tests"""
global INSTRUMENTS
# Setup
logger = LiveLogger(loop=loop,
clock=LiveClock(),
level_stdout=LogLevel.ERROR)
client = BetfairTestStubs.betfair_client(loop=loop, logger=logger)
logger = LiveLogger(loop=loop,
clock=LiveClock(),
level_stdout=LogLevel.DEBUG)
instrument_provider = BetfairInstrumentProvider(client=client,
logger=logger,
market_filter={})
# Load instruments
market_ids = BetfairDataProvider.market_ids()
catalog = {
r["marketId"]: r
for r in BetfairResponses.betting_list_market_catalogue()["result"]
if r["marketId"] in market_ids
}
mock_load_markets_metadata.return_value = catalog
t = loop.create_task(
instrument_provider.load_all_async(
market_filter={"market_id": market_ids}))
loop.run_until_complete(t)
# Fill INSTRUMENTS global cache
INSTRUMENTS.extend(instrument_provider.list_all())
assert INSTRUMENTS
def setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.loop.set_debug(True)
self.handler = []
self.clock = LiveClock(loop=self.loop)
self.clock.register_default_handler(self.handler.append)
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.trader_id = TraderId("TESTER-001")
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.executor = concurrent.futures.ThreadPoolExecutor()
self.loop.set_default_executor(self.executor)
self.loop.set_debug(True)
# Setup logging
logger = LiveLogger(
loop=self.loop,
clock=self.clock,
trader_id=self.trader_id,
level_stdout=LogLevel.DEBUG,
)
self.logger = LiveLogger(
loop=self.loop,
clock=self.clock,
)
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_engine = LiveDataEngine(
loop=self.loop,
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.mock_oanda = MagicMock()
self.client = OandaDataClient(
client=self.mock_oanda,
account_id="001",
engine=self.data_engine,
clock=self.clock,
logger=logger,
)
self.data_engine.register_client(self.client)
with open(TEST_PATH + "instruments.json") as response:
instruments = json.load(response)
self.mock_oanda.request.return_value = instruments
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):
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
# Fixture Setup
self.handler = []
self.clock = LiveClock(loop=self.loop)
self.clock.register_default_handler(self.handler.append)
def setUp(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = TestLogger(self.clock, bypass_logging=True)
self.trader_id = TraderId("TESTER", "000")
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(
venue=Venue("BINANCE"),
account_id=self.account_id,
exec_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.loop = asyncio.get_event_loop()
self.clock = LiveClock()
self.logger = LiveLogger(loop=self.loop, clock=self.clock)
self.client = BetfairTestStubs.betfair_client(loop=self.loop,
logger=self.logger)
async def test_ftx_http_client():
loop = asyncio.get_event_loop()
clock = LiveClock()
client: FTXHttpClient = get_cached_ftx_http_client(
loop=loop,
clock=clock,
logger=Logger(clock=clock),
key=os.getenv("FTX_API_KEY"),
secret=os.getenv("FTX_API_SECRET"),
)
await client.connect()
response = await client.list_markets(
# market="ETH-PERP",
)
print(json.dumps(response, indent=4))
provider = FTXInstrumentProvider(
client=client,
logger=Logger(clock=clock),
)
await provider.load_all_async()
# for instrument in provider.get_all().values():
# print(instrument)
await client.disconnect()
def setUp(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock, level_stdout=LogLevel.DEBUG)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.engine = LiveDataEngine(
loop=self.loop,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.client = LiveDataClient(
client_id=ClientId("BLOOMBERG"),
engine=self.engine,
clock=self.clock,
logger=self.logger,
)
async def run_test():
# Arrange
logger = LiveLogger(
loop=self.loop,
clock=LiveClock(),
maxsize=5,
)
logger_adapter = LoggerAdapter(component="LIVE_LOGGER",
logger=logger)
logger.start()
# Act
logger_adapter.info("A log message.")
logger_adapter.info("A log message.") # <-- blocks
logger_adapter.info("A different log message.") # <-- blocks
logger_adapter.info("A log message.") # <-- blocks
logger_adapter.info("A different log message.") # <-- blocks
logger_adapter.info("A log message.") # <-- blocks
await asyncio.sleep(0.1) # <-- processes all log messages
self.logger.stop()
# Assert
assert not self.logger.is_running
async def test_log_when_queue_over_maxsize_blocks(self):
# Arrange
logger = LiveLogger(
loop=self.loop,
clock=LiveClock(),
maxsize=5,
)
logger_adapter = LoggerAdapter(component_name="LIVE_LOGGER",
logger=logger)
logger.start()
# Act
logger_adapter.info("A log message.")
logger_adapter.info("A log message.") # <-- blocks
logger_adapter.info("A different log message.") # <-- blocks
logger_adapter.info("A log message.") # <-- blocks
logger_adapter.info("A different log message.") # <-- blocks
logger_adapter.info("A log message.") # <-- blocks
await asyncio.sleep(0.3) # <-- processes all log messages
logger.stop()
await asyncio.sleep(0.3)
# Assert
assert not logger.is_running
def setUp(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = TestLogger(self.clock, level_console=LogLevel.DEBUG)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.engine = LiveDataEngine(
loop=self.loop,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.client = LiveDataClient(
venue=BINANCE,
engine=self.engine,
clock=self.clock,
logger=self.logger,
)
def setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.clock = LiveClock()
self.logger = LiveLogger(
loop=self.loop,
clock=self.clock,
level_stdout=LogLevel.DEBUG,
)
self.trader_id = TestStubs.trader_id()
self.strategy_id = TestStubs.strategy_id()
self.account_id = TestStubs.account_id()
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache_db = MockCacheDatabase(logger=self.logger, )
self.cache = Cache(
database=self.cache_db,
logger=self.logger,
)
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.trader_id = TraderId("TESTER", "001")
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.logger = LiveLogger(
loop=self.loop,
clock=self.clock,
)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.data_engine = LiveDataEngine(
loop=self.loop,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
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,
)
def position(number=1, entry_price=None) -> Position:
if entry_price is None:
entry_price = Price("1.00000")
generator = PositionIdGenerator(id_tag_trader=IdTag("001"))
for _i in range(number):
generator.generate(TestStubs.symbol_audusd_fxcm())
order_factory = OrderFactory(
strategy_id=StrategyId("S", "001"),
id_tag_trader=IdTag("001"),
id_tag_strategy=IdTag("001"),
clock=LiveClock(),
)
order = order_factory.market(
TestStubs.symbol_audusd_fxcm(),
OrderSide.BUY,
Quantity(100000),
)
position_id = PositionId(TestStubs.symbol_audusd_fxcm().value)
order_filled = TestStubs.event_order_filled(
order,
position_id=position_id,
fill_price=entry_price,
)
position = Position(event=order_filled)
return position
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()
market = BinanceSpotMarketHttpAPI(client=client)
response = await market.exchange_info(symbols=["BTCUSDT", "ETHUSDT"])
print(json.dumps(response, indent=4))
provider = BinanceInstrumentProvider(
client=client,
logger=Logger(clock=clock),
)
await provider.load_all_async()
print(provider.count)
await client.disconnect()
async def test_binance_websocket_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()
user = BinanceUserDataHttpAPI(client=client)
response = await user.create_listen_key_spot()
key = response["listenKey"]
ws = BinanceUserDataWebSocket(
loop=loop,
clock=clock,
logger=LiveLogger(loop=loop, clock=clock),
handler=print,
)
ws.subscribe(key=key)
await ws.connect(start=True)
await asyncio.sleep(4)
await ws.close()
await client.disconnect()
def setup(self):
os.environ.update(
{
"TWS_USERNAME": "******",
"TWS_PASSWORD": "******",
}
)
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.clock = LiveClock()
self.logger = LiveLogger(
loop=self.loop,
clock=self.clock,
level_stdout=LogLevel.DEBUG,
)
self.trader_id = TestIdStubs.trader_id()
self.strategy_id = TestIdStubs.strategy_id()
self.account_id = TestIdStubs.account_id()
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache_db = MockCacheDatabase(
logger=self.logger,
)
self.cache = Cache(
database=self.cache_db,
logger=self.logger,
)
with patch("nautilus_trader.adapters.interactive_brokers.factories.get_cached_ib_client"):
self.data_client = InteractiveBrokersLiveDataClientFactory.create(
loop=self.loop,
name="IB",
config=InteractiveBrokersDataClientConfig( # noqa: S106
username="******", password="******"
),
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
with patch("nautilus_trader.adapters.interactive_brokers.factories.get_cached_ib_client"):
self.exec_client = InteractiveBrokersLiveExecClientFactory.create(
loop=self.loop,
name="IB",
config=InteractiveBrokersExecClientConfig( # noqa: S106
username="******", password="******"
),
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
def setUp(self):
# Fixture Setup
self.generator = ClientOrderIdGenerator(IdTag("001"), IdTag("001"),
LiveClock())
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", "001")
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
# Setup logging
logger = LiveLogger(
clock=self.clock,
name=self.trader_id.value,
level_console=LogLevel.INFO,
level_file=LogLevel.DEBUG,
level_store=LogLevel.WARNING,
)
self.logger = LiveLogger(self.clock)
self.portfolio = Portfolio(
clock=self.clock,
logger=self.logger,
)
self.data_engine = LiveDataEngine(
loop=self.loop,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
)
self.mock_ccxt = MagicMock()
self.mock_ccxt.name = "Binance"
self.client = CCXTDataClient(
client=self.mock_ccxt,
engine=self.data_engine,
clock=self.clock,
logger=logger,
)
self.data_engine.register_client(self.client)
def setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.clock = LiveClock()
self.logger = LiveLogger(loop=self.loop, clock=self.clock)
self.instrument = BetfairTestStubs.betting_instrument()
self.client = BetfairTestStubs.betfair_client(loop=self.loop,
logger=self.logger)
self.provider = BetfairTestStubs.instrument_provider(self.client)
self.uuid = UUID4()
def setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.clock = LiveClock()
self.logger = LiveLogger(loop=self.loop, clock=self.clock)
self.client = BetfairTestStubs.betfair_client(loop=self.loop,
logger=self.logger)
self.provider = BetfairInstrumentProvider(
client=self.client,
logger=TestComponentStubs.logger(),
)
def setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.clock = LiveClock()
self.logger = LiveLogger(loop=self.loop, clock=self.clock)
self.client = BetfairTestStubs.betfair_client(loop=self.loop,
logger=self.logger)
self.provider = BetfairInstrumentProvider(
client=self.client,
logger=BetfairTestStubs.live_logger(BetfairTestStubs.clock()),
market_filter=None,
)
def setup(self):
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.logger = LiveLogger(
loop=self.loop,
clock=LiveClock(),
)
self.logger_adapter = LoggerAdapter(component="LIVER_LOGGER",
logger=self.logger)
def test_stop_when_running_in_process(self):
# Arrange
logger = LiveLogger(clock=LiveClock(), run_in_process=True)
logger_adapter = LoggerAdapter("LIVE_LOGGER", logger)
logger_adapter.info("A log message.")
# Act
logger.stop()
# Assert
self.assertTrue(True) # No exception raised
def setup(self):
# Fixture Setup
self.generator = ClientOrderIdGenerator(
trader_id=TraderId("TRADER-001"),
strategy_id=StrategyId("S-001"),
clock=LiveClock(),
)
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER-000"),
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
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 setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.loop.set_debug(True)
self.logger = LiveLogger(
loop=self.loop,
clock=LiveClock(),
level_stdout=LogLevel.DEBUG,
)
self.logger_adapter = LoggerAdapter(component_name="LIVER_LOGGER",
logger=self.logger)
