def setup(self):
# Fixture Setup
self.clock = TestClock()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER-000")
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(self.trader_id, self.clock, self.logger)
config = {
"host": "localhost",
"port": 6379,
}
self.database = RedisCacheDatabase(
trader_id=self.trader_id,
logger=self.logger,
instrument_serializer=MsgPackInstrumentSerializer(),
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config=config,
)
self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
class TestRedisExecutionDatabase:
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER-000")
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(self.trader_id, self.clock, self.logger)
config = {
"host": "localhost",
"port": 6379,
}
self.database = RedisCacheDatabase(
trader_id=self.trader_id,
logger=self.logger,
instrument_serializer=MsgPackInstrumentSerializer(),
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config=config,
)
self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
def teardown(self):
# Tests will start failing if redis is not flushed on tear down
self.test_redis.flushall(
) # Comment this line out to preserve data between tests
def test_add_currency(self):
# Arrange
currency = Currency(
code="1INCH",
precision=8,
iso4217=0,
name="1INCH",
currency_type=CurrencyType.CRYPTO,
)
# Act
self.database.add_currency(currency)
# Assert
assert self.database.load_currency(currency.code) == currency
def test_add_account(self):
# Arrange
event = TestStubs.event_account_state()
account = Account(event)
# Act
self.database.add_account(account)
# Assert
assert self.database.load_account(account.id) == account
def test_add_instrument(self):
# Arrange, Act
self.database.add_instrument(AUDUSD_SIM)
# Assert
assert self.database.load_instrument(AUDUSD_SIM.id) == AUDUSD_SIM
def test_add_order(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
# Act
self.database.add_order(order)
# Assert
assert self.database.load_order(order.client_order_id) == order
def test_add_position(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_instrument(AUDUSD_SIM)
self.database.add_order(order)
position_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00000"),
)
position = Position(instrument=AUDUSD_SIM, fill=fill)
# Act
self.database.add_position(position)
# Assert
assert self.database.load_position(position.id) == position
def test_update_account(self):
# Arrange
event = TestStubs.event_account_state()
account = Account(event)
self.database.add_account(account)
# Act
self.database.update_account(account)
# Assert
assert self.database.load_account(account.id) == account
def test_update_order_for_working_order(self):
# Arrange
order = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order)
order.apply(TestStubs.event_order_submitted(order))
self.database.update_order(order)
order.apply(TestStubs.event_order_accepted(order))
# Act
self.database.update_order(order)
# Assert
assert self.database.load_order(order.client_order_id) == order
def test_update_order_for_completed_order(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
order.apply(TestStubs.event_order_submitted(order))
self.database.update_order(order)
order.apply(TestStubs.event_order_accepted(order))
self.database.update_order(order)
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
last_px=Price.from_str("1.00001"),
)
order.apply(fill)
# Act
self.database.update_order(order)
# Assert
assert self.database.load_order(order.client_order_id) == order
def test_update_position_for_closed_position(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
order1 = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
position_id = PositionId("P-1")
self.database.add_order(order1)
order1.apply(TestStubs.event_order_submitted(order1))
self.database.update_order(order1)
order1.apply(TestStubs.event_order_accepted(order1))
self.database.update_order(order1)
order1.apply(
TestStubs.event_order_filled(
order1,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00001"),
))
self.database.update_order(order1)
# Act
position = Position(instrument=AUDUSD_SIM, fill=order1.last_event)
self.database.add_position(position)
order2 = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.SELL,
Quantity.from_int(100000),
)
self.database.add_order(order2)
order2.apply(TestStubs.event_order_submitted(order2))
self.database.update_order(order2)
order2.apply(TestStubs.event_order_accepted(order2))
self.database.update_order(order2)
filled = TestStubs.event_order_filled(
order2,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00001"),
)
order2.apply(filled)
self.database.update_order(order2)
position.apply(filled)
# Act
self.database.update_position(position)
# Assert
assert self.database.load_position(position.id) == position
def test_update_strategy(self):
# Arrange
strategy = MockStrategy(
TestStubs.bartype_btcusdt_binance_100tick_last())
strategy.register_trader(self.trader_id, self.clock, self.logger)
# Act
self.database.update_strategy(strategy)
result = self.database.load_strategy(strategy.id)
# Assert
assert result == {"UserState": b"1"}
def test_load_account_when_no_account_in_database_returns_none(self):
# Arrange
event = TestStubs.event_account_state()
account = Account(event)
# Act
result = self.database.load_account(account.id)
# Assert
assert result is None
def test_load_account_when_account_in_database_returns_account(self):
# Arrange
event = TestStubs.event_account_state()
account = Account(event)
self.database.add_account(account)
# Act
result = self.database.load_account(account.id)
# Assert
assert result == account
def test_load_order_when_no_order_in_database_returns_none(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result is None
def test_load_order_when_market_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
def test_load_order_when_limit_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
def test_load_order_when_stop_market_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
def test_load_order_when_stop_limit_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.stop_limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
price=Price.from_str("1.00000"),
trigger=Price.from_str("1.00010"),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
assert result.price == order.price
assert result.trigger == order.trigger
def test_load_position_when_no_position_in_database_returns_none(self):
# Arrange
position_id = PositionId("P-1")
# Act
result = self.database.load_position(position_id)
# Assert
assert result is None
def test_load_order_when_position_in_database_returns_position(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
position_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00000"),
)
position = Position(instrument=AUDUSD_SIM, fill=fill)
self.database.add_position(position)
# Act
result = self.database.load_position(position_id)
# Assert
assert result == position
def test_load_accounts_when_no_accounts_returns_empty_dict(self):
# Arrange
# Act
result = self.database.load_accounts()
# Assert
assert result == {}
def test_load_accounts_cache_when_one_account_in_database(self):
# Arrange
event = TestStubs.event_account_state()
account = Account(event)
self.database.add_account(account)
# Act
# Assert
assert self.database.load_accounts() == {account.id: account}
def test_load_orders_cache_when_no_orders(self):
# Arrange
# Act
self.database.load_orders()
# Assert
assert self.database.load_orders() == {}
def test_load_orders_cache_when_one_order_in_database(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
# Act
result = self.database.load_orders()
# Assert
assert result == {order.client_order_id: order}
def test_load_positions_cache_when_no_positions(self):
# Arrange
# Act
self.database.load_positions()
# Assert
assert self.database.load_positions() == {}
def test_load_positions_cache_when_one_position_in_database(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
order1 = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order1)
position_id = PositionId("P-1")
order1.apply(TestStubs.event_order_submitted(order1))
order1.apply(TestStubs.event_order_accepted(order1))
order1.apply(
TestStubs.event_order_filled(
order1,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00001"),
))
position = Position(instrument=AUDUSD_SIM, fill=order1.last_event)
self.database.add_position(position)
# Act
result = self.database.load_positions()
# Assert
assert result == {position.id: position}
def test_delete_strategy(self):
# Arrange
# Act
self.database.delete_strategy(self.strategy.id)
result = self.database.load_strategy(self.strategy.id)
# Assert
assert result == {}
def test_flush(self):
# Arrange
order1 = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order1)
position1_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order1,
instrument=AUDUSD_SIM,
position_id=position1_id,
last_px=Price.from_str("1.00000"),
)
position1 = Position(instrument=AUDUSD_SIM, fill=fill)
self.database.update_order(order1)
self.database.add_position(position1)
order2 = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order2)
order2.apply(TestStubs.event_order_submitted(order2))
order2.apply(TestStubs.event_order_accepted(order2))
self.database.update_order(order2)
# Act
self.database.flush()
# Assert
assert self.database.load_order(order1.client_order_id) is None
assert self.database.load_order(order2.client_order_id) is None
assert self.database.load_position(position1.id) is None
def setup(self):
# Fixture Setup
self.clock = TestClock()
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.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,
)
self.database = RedisCacheDatabase(
trader_id=self.trader_id,
logger=self.logger,
serializer=MsgPackSerializer(timestamps_as_str=True),
)
self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
class TestRedisCacheDatabase:
def setup(self):
# Fixture Setup
self.clock = TestClock()
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.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,
)
self.database = RedisCacheDatabase(
trader_id=self.trader_id,
logger=self.logger,
serializer=MsgPackSerializer(timestamps_as_str=True),
)
self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
def teardown(self):
# Tests will start failing if redis is not flushed on tear down
self.test_redis.flushall() # Comment this line out to preserve data between tests
def test_add_currency(self):
# Arrange
currency = Currency(
code="1INCH",
precision=8,
iso4217=0,
name="1INCH",
currency_type=CurrencyType.CRYPTO,
)
# Act
self.database.add_currency(currency)
# Assert
assert self.database.load_currency(currency.code) == currency
def test_add_account(self):
# Arrange
account = TestStubs.cash_account()
# Act
self.database.add_account(account)
# Assert
assert self.database.load_account(account.id) == account
def test_add_instrument(self):
# Arrange, Act
self.database.add_instrument(AUDUSD_SIM)
# Assert
assert self.database.load_instrument(AUDUSD_SIM.id) == AUDUSD_SIM
def test_add_order(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
# Act
self.database.add_order(order)
# Assert
assert self.database.load_order(order.client_order_id) == order
def test_add_position(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_instrument(AUDUSD_SIM)
self.database.add_order(order)
position_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00000"),
)
position = Position(instrument=AUDUSD_SIM, fill=fill)
# Act
self.database.add_position(position)
# Assert
assert self.database.load_position(position.id) == position
def test_update_account(self):
# Arrange
account = TestStubs.cash_account()
self.database.add_account(account)
# Act
self.database.update_account(account)
# Assert
assert self.database.load_account(account.id) == account
def test_update_order_when_not_already_exists_logs(self):
# Arrange
order = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
# Act
self.database.update_order(order)
# Assert
assert True # No exceptions raised
def test_update_order_for_working_order(self):
# Arrange
order = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order)
order.apply(TestStubs.event_order_submitted(order))
self.database.update_order(order)
order.apply(TestStubs.event_order_accepted(order))
# Act
self.database.update_order(order)
# Assert
assert self.database.load_order(order.client_order_id) == order
def test_update_order_for_completed_order(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
order.apply(TestStubs.event_order_submitted(order))
self.database.update_order(order)
order.apply(TestStubs.event_order_accepted(order))
self.database.update_order(order)
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
last_px=Price.from_str("1.00001"),
)
order.apply(fill)
# Act
self.database.update_order(order)
# Assert
assert self.database.load_order(order.client_order_id) == order
def test_update_position_for_closed_position(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
order1 = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
position_id = PositionId("P-1")
self.database.add_order(order1)
order1.apply(TestStubs.event_order_submitted(order1))
self.database.update_order(order1)
order1.apply(TestStubs.event_order_accepted(order1))
self.database.update_order(order1)
order1.apply(
TestStubs.event_order_filled(
order1,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00001"),
)
)
self.database.update_order(order1)
# Act
position = Position(instrument=AUDUSD_SIM, fill=order1.last_event)
self.database.add_position(position)
order2 = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.SELL,
Quantity.from_int(100000),
)
self.database.add_order(order2)
order2.apply(TestStubs.event_order_submitted(order2))
self.database.update_order(order2)
order2.apply(TestStubs.event_order_accepted(order2))
self.database.update_order(order2)
filled = TestStubs.event_order_filled(
order2,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00001"),
)
order2.apply(filled)
self.database.update_order(order2)
position.apply(filled)
# Act
self.database.update_position(position)
# Assert
assert self.database.load_position(position.id) == position
def test_update_position_when_not_already_exists_logs(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
position_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00000"),
)
position = Position(instrument=AUDUSD_SIM, fill=fill)
# Act
self.database.update_position(position)
# Assert
assert True # No exception raised
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_load_currency_when_no_currencies_in_database_returns_none(self):
# Arrange, Act
result = self.database.load_currency("ONEINCH")
# Assert
assert result is None
def test_load_currency_when_currency_in_database_returns_expected(self):
# Arrange
aud = Currency.from_str("AUD")
self.database.add_currency(aud)
# Act
result = self.database.load_currency("AUD")
# Assert
assert result == aud
def test_load_currencies_when_currencies_in_database_returns_expected(self):
# Arrange
aud = Currency.from_str("AUD")
self.database.add_currency(aud)
# Act
result = self.database.load_currencies()
# Assert
assert result == {"AUD": aud}
def test_load_instrument_when_no_instrument_in_database_returns_none(self):
# Arrange, Act
result = self.database.load_instrument(AUDUSD_SIM.id)
# Assert
assert result is None
def test_load_instrument_when_instrument_in_database_returns_expected(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
# Act
result = self.database.load_instrument(AUDUSD_SIM.id)
# Assert
assert result == AUDUSD_SIM
def test_load_instruments_when_instrument_in_database_returns_expected(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
# Act
result = self.database.load_instruments()
# Assert
assert result == {AUDUSD_SIM.id: AUDUSD_SIM}
def test_load_account_when_no_account_in_database_returns_none(self):
# Arrange
account = TestStubs.cash_account()
# Act
result = self.database.load_account(account.id)
# Assert
assert result is None
def test_load_account_when_account_in_database_returns_account(self):
# Arrange
account = TestStubs.cash_account()
self.database.add_account(account)
# Act
result = self.database.load_account(account.id)
# Assert
assert result == account
def test_load_order_when_no_order_in_database_returns_none(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result is None
def test_load_order_when_market_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
def test_load_order_when_limit_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
def test_load_order_when_stop_market_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
def test_load_order_when_stop_limit_order_in_database_returns_order(self):
# Arrange
order = self.strategy.order_factory.stop_limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
price=Price.from_str("1.00000"),
trigger=Price.from_str("1.00010"),
)
self.database.add_order(order)
# Act
result = self.database.load_order(order.client_order_id)
# Assert
assert result == order
assert result.price == order.price
assert result.trigger == order.trigger
def test_load_position_when_no_position_in_database_returns_none(self):
# Arrange
position_id = PositionId("P-1")
# Act
result = self.database.load_position(position_id)
# Assert
assert result is None
def test_load_position_when_instrument_in_database_returns_none(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
position_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00000"),
)
position = Position(instrument=AUDUSD_SIM, fill=fill)
self.database.add_position(position)
# Act
result = self.database.load_position(position.id)
# Assert
assert result is None
def test_load_order_when_position_in_database_returns_position(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
position_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00000"),
)
position = Position(instrument=AUDUSD_SIM, fill=fill)
self.database.add_position(position)
# Act
result = self.database.load_position(position_id)
# Assert
assert result == position
def test_load_accounts_when_no_accounts_returns_empty_dict(self):
# Arrange, Act
result = self.database.load_accounts()
# Assert
assert result == {}
def test_load_accounts_cache_when_one_account_in_database(self):
# Arrange
account = TestStubs.cash_account()
# Act
self.database.add_account(account)
# Assert
assert self.database.load_accounts() == {account.id: account}
def test_load_orders_cache_when_no_orders(self):
# Arrange, Act
self.database.load_orders()
# Assert
assert self.database.load_orders() == {}
def test_load_orders_cache_when_one_order_in_database(self):
# Arrange
order = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order)
# Act
result = self.database.load_orders()
# Assert
assert result == {order.client_order_id: order}
def test_load_positions_cache_when_no_positions(self):
# Arrange, Act
self.database.load_positions()
# Assert
assert self.database.load_positions() == {}
def test_load_positions_cache_when_one_position_in_database(self):
# Arrange
self.database.add_instrument(AUDUSD_SIM)
order1 = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order1)
position_id = PositionId("P-1")
order1.apply(TestStubs.event_order_submitted(order1))
order1.apply(TestStubs.event_order_accepted(order1))
order1.apply(
TestStubs.event_order_filled(
order1,
instrument=AUDUSD_SIM,
position_id=position_id,
last_px=Price.from_str("1.00001"),
)
)
position = Position(instrument=AUDUSD_SIM, fill=order1.last_event)
self.database.add_position(position)
# Act
result = self.database.load_positions()
# Assert
assert result == {position.id: position}
def test_delete_strategy(self):
# Arrange, Act
self.database.delete_strategy(self.strategy.id)
result = self.database.load_strategy(self.strategy.id)
# Assert
assert result == {}
def test_flush(self):
# Arrange
order1 = self.strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.database.add_order(order1)
position1_id = PositionId("P-1")
fill = TestStubs.event_order_filled(
order1,
instrument=AUDUSD_SIM,
position_id=position1_id,
last_px=Price.from_str("1.00000"),
)
position1 = Position(instrument=AUDUSD_SIM, fill=fill)
self.database.update_order(order1)
self.database.add_position(position1)
order2 = self.strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
self.database.add_order(order2)
order2.apply(TestStubs.event_order_submitted(order2))
order2.apply(TestStubs.event_order_accepted(order2))
self.database.update_order(order2)
# Act
self.database.flush()
# Assert
assert self.database.load_order(order1.client_order_id) is None
assert self.database.load_order(order2.client_order_id) is None
assert self.database.load_position(position1.id) is None
def __init__(self, config: Optional[TradingNodeConfig] = None):
if config is None:
config = TradingNodeConfig()
PyCondition.not_none(config, "config")
PyCondition.type(config, TradingNodeConfig, "config")
# Configuration
self._config = config
# Setup loop
self._loop = asyncio.get_event_loop()
self._executor = concurrent.futures.ThreadPoolExecutor()
self._loop.set_default_executor(self._executor)
self._loop.set_debug(config.loop_debug)
# Components
self._clock = LiveClock(loop=self._loop)
self._uuid_factory = UUIDFactory()
self.created_time = self._clock.utc_now()
self._is_running = False
# Identifiers
self.trader_id = TraderId(config.trader_id)
self.machine_id = socket.gethostname()
self.instance_id = self._uuid_factory.generate()
# Setup logging
self._logger = LiveLogger(
loop=self._loop,
clock=self._clock,
trader_id=self.trader_id,
machine_id=self.machine_id,
instance_id=self.instance_id,
level_stdout=LogLevelParser.from_str_py(config.log_level.upper()),
)
self._log = LoggerAdapter(
component_name=type(self).__name__,
logger=self._logger,
)
self._log_header()
self._log.info("Building...")
if platform.system() != "Windows":
# Windows does not support signal handling
# https://stackoverflow.com/questions/45987985/asyncio-loops-add-signal-handler-in-windows
self._setup_loop()
########################################################################
# Build platform
########################################################################
if config.cache_database is None or config.cache_database.type == "in-memory":
cache_db = None
elif config.cache_database.type == "redis":
cache_db = RedisCacheDatabase(
trader_id=self.trader_id,
logger=self._logger,
serializer=MsgPackSerializer(timestamps_as_str=True),
config=config.cache_database,
)
else: # pragma: no cover (design-time error)
raise ValueError(
"The cache_db_type in the configuration is unrecognized, "
"can one of {{'in-memory', 'redis'}}.",
)
self._msgbus = MessageBus(
trader_id=self.trader_id,
clock=self._clock,
logger=self._logger,
)
self._cache = Cache(
database=cache_db,
logger=self._logger,
config=config.cache,
)
self.portfolio = Portfolio(
msgbus=self._msgbus,
cache=self._cache,
clock=self._clock,
logger=self._logger,
)
self._data_engine = LiveDataEngine(
loop=self._loop,
msgbus=self._msgbus,
cache=self._cache,
clock=self._clock,
logger=self._logger,
config=config.data_engine,
)
self._exec_engine = LiveExecutionEngine(
loop=self._loop,
msgbus=self._msgbus,
cache=self._cache,
clock=self._clock,
logger=self._logger,
config=config.exec_engine,
)
self._exec_engine.load_cache()
self._risk_engine = LiveRiskEngine(
loop=self._loop,
portfolio=self.portfolio,
msgbus=self._msgbus,
cache=self._cache,
clock=self._clock,
logger=self._logger,
config=config.risk_engine,
)
self.trader = Trader(
trader_id=self.trader_id,
msgbus=self._msgbus,
cache=self._cache,
portfolio=self.portfolio,
data_engine=self._data_engine,
risk_engine=self._risk_engine,
exec_engine=self._exec_engine,
clock=self._clock,
logger=self._logger,
)
if config.load_strategy_state:
self.trader.load()
# Setup persistence (requires trader)
self.persistence_writers: List[Any] = []
if config.persistence:
self._setup_persistence(config=config.persistence)
self._builder = TradingNodeBuilder(
loop=self._loop,
data_engine=self._data_engine,
exec_engine=self._exec_engine,
msgbus=self._msgbus,
cache=self._cache,
clock=self._clock,
logger=self._logger,
log=self._log,
)
self._log.info("INITIALIZED.")
self.time_to_initialize = self._clock.delta(self.created_time)
self._log.info(f"Initialized in {int(self.time_to_initialize.total_seconds() * 1000)}ms.")
self._is_built = False
def __init__(
self,
strategies: List[TradingStrategy],
config: Dict[str, object],
):
"""
Initialize a new instance of the TradingNode class.
Parameters
----------
strategies : list[TradingStrategy]
The list of strategies to run on the trading node.
config : dict[str, object]
The configuration for the trading node.
Raises
------
ValueError
If strategies is None or empty.
ValueError
If config is None or empty.
"""
PyCondition.not_none(strategies, "strategies")
PyCondition.not_none(config, "config")
PyCondition.not_empty(strategies, "strategies")
PyCondition.not_empty(config, "config")
self._config = config
# Extract configs
config_trader = config.get("trader", {})
config_system = config.get("system", {})
config_log = config.get("logging", {})
config_cache_db = config.get("cache_database", {})
config_cache = config.get("cache", {})
config_data = config.get("data_engine", {})
config_risk = config.get("risk_engine", {})
config_exec = config.get("exec_engine", {})
config_strategy = config.get("strategy", {})
# System config
self._timeout_connection = config_system.get("timeout_connection", 5.0)
self._timeout_reconciliation = config_system.get(
"timeout_reconciliation", 10.0)
self._timeout_portfolio = config_system.get("timeout_portfolio", 10.0)
self._timeout_disconnection = config_system.get(
"timeout_disconnection", 5.0)
self._check_residuals_delay = config_system.get(
"check_residuals_delay", 5.0)
self._load_strategy_state = config_strategy.get("load_state", True)
self._save_strategy_state = config_strategy.get("save_state", True)
# Setup loop
self._loop = asyncio.get_event_loop()
self._executor = concurrent.futures.ThreadPoolExecutor()
self._loop.set_default_executor(self._executor)
self._loop.set_debug(config_system.get("loop_debug", False))
# Components
self._clock = LiveClock(loop=self._loop)
self._uuid_factory = UUIDFactory()
self.system_id = self._uuid_factory.generate()
self.created_time = self._clock.utc_now()
self._is_running = False
# Setup identifiers
self.trader_id = TraderId(
f"{config_trader['name']}-{config_trader['id_tag']}", )
# Setup logging
level_stdout = LogLevelParser.from_str_py(
config_log.get("level_stdout"))
self._logger = LiveLogger(
loop=self._loop,
clock=self._clock,
trader_id=self.trader_id,
system_id=self.system_id,
level_stdout=level_stdout,
)
self._log = LoggerAdapter(
component=self.__class__.__name__,
logger=self._logger,
)
self._log_header()
self._log.info("Building...")
if platform.system() != "Windows":
# Requires the logger to be initialized
# Windows does not support signal handling
# https://stackoverflow.com/questions/45987985/asyncio-loops-add-signal-handler-in-windows
self._setup_loop()
# Build platform
# ----------------------------------------------------------------------
if config_cache_db["type"] == "redis":
cache_db = RedisCacheDatabase(
trader_id=self.trader_id,
logger=self._logger,
instrument_serializer=MsgPackInstrumentSerializer(),
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config={
"host": config_cache_db["host"],
"port": config_cache_db["port"],
},
)
else:
cache_db = BypassCacheDatabase(
trader_id=self.trader_id,
logger=self._logger,
)
cache = Cache(
database=cache_db,
logger=self._logger,
config=config_cache,
)
self.portfolio = Portfolio(
cache=cache,
clock=self._clock,
logger=self._logger,
)
self._data_engine = LiveDataEngine(
loop=self._loop,
portfolio=self.portfolio,
cache=cache,
clock=self._clock,
logger=self._logger,
config=config_data,
)
self._exec_engine = LiveExecutionEngine(
loop=self._loop,
portfolio=self.portfolio,
cache=cache,
clock=self._clock,
logger=self._logger,
config=config_exec,
)
self._risk_engine = LiveRiskEngine(
loop=self._loop,
exec_engine=self._exec_engine,
portfolio=self.portfolio,
cache=cache,
clock=self._clock,
logger=self._logger,
config=config_risk,
)
# Wire up components
self._exec_engine.register_risk_engine(self._risk_engine)
self._exec_engine.load_cache()
self.trader = Trader(
trader_id=self.trader_id,
strategies=strategies,
portfolio=self.portfolio,
data_engine=self._data_engine,
risk_engine=self._risk_engine,
exec_engine=self._exec_engine,
clock=self._clock,
logger=self._logger,
)
if self._load_strategy_state:
self.trader.load()
self._builder = TradingNodeBuilder(
data_engine=self._data_engine,
exec_engine=self._exec_engine,
clock=self._clock,
logger=self._logger,
log=self._log,
)
self._log.info("state=INITIALIZED.")
self.time_to_initialize = self._clock.delta(self.created_time)
self._log.info(
f"Initialized in {self.time_to_initialize.total_seconds():.3f}s.")
self._is_built = False