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
def setUp(self):
# Fixture Setup
clock = TestClock()
logger = TestLogger(clock)
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER", "000"),
strategy_id=StrategyId("S", "001"),
clock=TestClock(),
)
state = AccountState(
account_id=AccountId("BINANCE", "1513111"),
balances=[Money("10.00000000", BTC)],
balances_free=[Money("0.00000000", BTC)],
balances_locked=[Money("0.00000000", BTC)],
info={},
event_id=uuid4(),
event_timestamp=UNIX_EPOCH,
)
self.data_cache = DataCache(logger)
self.account = Account(state)
self.portfolio = Portfolio(clock, logger)
self.portfolio.register_account(self.account)
self.portfolio.register_cache(self.data_cache)
self.data_cache.add_instrument(AUDUSD_SIM)
self.data_cache.add_instrument(GBPUSD_SIM)
self.data_cache.add_instrument(BTCUSDT_BINANCE)
self.data_cache.add_instrument(BTCUSD_BITMEX)
self.data_cache.add_instrument(ETHUSD_BITMEX)
def setUp(self):
# Fixture Setup
self.venue = Venue("SIM")
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.serializer = MsgPackCommandSerializer()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S", "001"),
clock=TestClock(),
)
self.order = self.order_factory.market(
AUDUSD,
OrderSide.BUY,
Quantity(100000),
)
self.command = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
StrategyId("SCALPER", "01"),
PositionId("P-123456"),
self.order,
uuid4(),
UNIX_EPOCH,
)
def setup(self):
# Fixture Setup
self.venue = Venue("SIM")
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
self.order = self.order_factory.market(
AUDUSD,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.command = SubmitOrder(
self.trader_id,
StrategyId("SCALPER-001"),
PositionId("P-123456"),
self.order,
UUID4(),
0,
)
self.serializer = MsgPackSerializer()
def setup(self):
# Fixture Setup
_reset()
self.catalog = DataCatalog(path="/root", fs_protocol="memory")
self.order_factory = OrderFactory(
trader_id=TraderId("T-001"),
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
self.order = self.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
self.order_submitted = copy.copy(self.order)
self.order_submitted.apply(TestStubs.event_order_submitted(self.order))
self.order_accepted = copy.copy(self.order_submitted)
self.order_accepted.apply(
TestStubs.event_order_accepted(self.order_submitted))
self.order_pending_cancel = copy.copy(self.order_accepted)
self.order_pending_cancel.apply(
TestStubs.event_order_pending_cancel(self.order_accepted))
self.order_cancelled = copy.copy(self.order_pending_cancel)
self.order_cancelled.apply(
TestStubs.event_order_canceled(self.order_pending_cancel))
def setUp(self):
# Fixture Setup
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(id_tag_trader=IdTag('001'),
id_tag_strategy=IdTag('001'),
clock=TestClock(),
guid_factory=TestGuidFactory())
def setUp(self):
# Fixture Setup
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER", "000"),
strategy_id=StrategyId("S", "001"),
clock=TestClock(),
)
def setup(self):
# Fixture Setup
self.analyzer = PerformanceAnalyzer()
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER-000"),
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
def setUp(self):
# Fixture Setup
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER-000"),
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
def setup(self):
# Fixture Setup
self.unpacker = OrderUnpacker()
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER-000"),
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
def setup(self):
# Fixture Setup
self.serializer = MsgPackOrderSerializer()
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER", "000"),
strategy_id=StrategyId("S", "001"),
clock=TestClock(),
)
def setUp(self):
# Fixture Setup
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
strategy_id=StrategyId("S", "001"),
id_tag_trader=IdTag("001"),
id_tag_strategy=IdTag("001"),
clock=TestClock())
def setup(self):
# Fixture Setup
self.trader_id = TestIdStubs.trader_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
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.trader_id = TestStubs.trader_id()
self.instrument = BetfairTestStubs.betting_instrument()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
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.uuid_factory = UUIDFactory()
self.logger = TestLogger(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,
generate_position_ids=True,
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(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 setup(self):
# Fixture Setup
self.venue = Venue("SIM")
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.serializer = MsgPackCommandSerializer()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
def setup(self):
# Fixture Setup
self.trader_id = TestStubs.trader_id()
self.strategy_id = TestStubs.strategy_id()
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=self.strategy_id,
clock=TestClock(),
)
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
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
def setup(self):
# Fixture Setup
self.trader_id = TestIdStubs.trader_id()
self.strategy_id = TestIdStubs.strategy_id()
self.account_id = TestIdStubs.account_id()
self.venue = Venue("SIM")
self.unpacker = OrderUnpacker()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=self.strategy_id,
clock=TestClock(),
)
self.serializer = MsgPackSerializer()
def setUp(self):
# Fixture Setup
self.clock = TestClock()
uuid_factor = TestUUIDFactory()
logger = TestLogger(self.clock)
self.order_factory = OrderFactory(
strategy_id=StrategyId("S", "001"),
id_tag_trader=IdTag("001"),
id_tag_strategy=IdTag("001"),
clock=TestClock(),
)
state = AccountState(
AccountId.from_string("BITMEX-1513111-SIMULATED"),
BTC,
Money(10., BTC),
Money(0., BTC),
Money(0., BTC),
uuid4(),
UNIX_EPOCH
)
self.account = Account(state)
self.portfolio = Portfolio(self.clock, uuid_factor, logger)
self.portfolio.register_account(self.account)
def setUp(self):
# Fixture Setup
self.clock = TestClock()
self.guid_factory = TestGuidFactory()
logger = TestLogger()
self.trader_id = TraderId('TESTER', '000')
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
id_tag_trader=self.trader_id.order_id_tag,
id_tag_strategy=IdTag('001'),
clock=self.clock)
self.portfolio = Portfolio(currency=Currency.USD,
clock=self.clock,
guid_factory=self.guid_factory,
logger=logger)
self.analyzer = PerformanceAnalyzer()
self.exec_db = InMemoryExecutionDatabase(trader_id=self.trader_id,
logger=logger)
self.exec_engine = ExecutionEngine(trader_id=self.trader_id,
account_id=self.account_id,
database=self.exec_db,
portfolio=self.portfolio,
clock=self.clock,
guid_factory=self.guid_factory,
logger=logger)
self.exec_engine.handle_event(TestStubs.account_event())
self.exec_client = MockExecutionClient(self.exec_engine, logger)
self.exec_engine.register_client(self.exec_client)
def setUp(self):
# Fixture Setup
clock = TestClock()
logger = Logger(clock)
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,
)
cache = Cache(
database=cache_db,
logger=logger,
)
self.portfolio = Portfolio(
cache=cache,
clock=clock,
logger=logger,
)
self.exec_engine = ExecutionEngine(
portfolio=self.portfolio,
cache=cache,
clock=clock,
logger=logger,
)
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.logger = Logger(self.clock)
self.trader_id = TestStubs.trader_id()
self.order_factory = OrderFactory(
trader_id=self.trader_id,
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
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,
)
# 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)
self.cache.add_instrument(BETTING_INSTRUMENT)
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.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.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,
engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
self.order_factory = OrderFactory(
trader_id=TraderId("TESTER-000"),
strategy_id=StrategyId("S-001"),
clock=TestClock(),
)
def test_order_serializer_methods_raise_not_implemented_error(self):
# Arrange
order_factory = OrderFactory(
trader_id=TraderId("TESTER", "000"),
strategy_id=StrategyId("S", "001"),
clock=TestClock(),
)
order = order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
serializer = OrderSerializer()
# Act
# Assert
self.assertRaises(NotImplementedError, serializer.serialize, order)
self.assertRaises(NotImplementedError, serializer.deserialize, bytes())
def setUp(self):
# Fixture Setup
self.clock = TestClock()
logger = TestLogger(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))
