def test_can_close_position_on_order_fill(self):
# Arrange
strategy = TradingStrategy(order_id_tag='001')
strategy.change_clock(self.clock)
self.exec_engine.register_strategy(strategy)
position_id = strategy.position_id_generator.generate()
order1 = strategy.order_factory.stop(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000),
Price(1.00000, 5))
order2 = strategy.order_factory.stop(AUDUSD_FXCM, OrderSide.SELL,
Quantity(100000),
Price(1.00000, 5))
submit_order1 = SubmitOrder(self.trader_id, self.account_id,
strategy.id, position_id, order1,
self.guid_factory.generate(),
self.clock.time_now())
submit_order2 = SubmitOrder(self.trader_id, self.account_id,
strategy.id, position_id, order2,
self.guid_factory.generate(),
self.clock.time_now())
self.exec_engine.execute_command(submit_order1)
self.exec_engine.execute_command(submit_order2)
order1_filled = TestStubs.event_order_filled(order1)
order2_filled = TestStubs.event_order_filled(order2)
# Act
self.exec_engine.handle_event(order1_filled)
self.exec_engine.handle_event(order2_filled)
# # Assert
self.assertTrue(self.exec_db.position_exists(position_id))
self.assertFalse(self.exec_db.is_position_open(position_id))
self.assertTrue(self.exec_db.is_position_closed(position_id))
self.assertTrue(self.exec_engine.is_strategy_flat(strategy.id))
self.assertTrue(self.exec_engine.is_flat())
self.assertEqual(position_id,
self.exec_db.get_position(position_id).id)
self.assertTrue(position_id in self.exec_db.get_positions(strategy.id))
self.assertTrue(position_id in self.exec_db.get_positions())
self.assertEqual(0, len(self.exec_db.get_positions_open(strategy.id)))
self.assertEqual(0, len(self.exec_db.get_positions_open()))
self.assertTrue(
position_id in self.exec_db.get_positions_closed(strategy.id))
self.assertTrue(position_id in self.exec_db.get_positions_closed())
self.assertTrue(
position_id not in self.exec_db.get_positions_open(strategy.id))
self.assertTrue(position_id not in self.exec_db.get_positions_open())
self.assertEqual(1, self.exec_db.count_positions_total())
self.assertEqual(0, self.exec_db.count_positions_open())
self.assertEqual(1, self.exec_db.count_positions_closed())
def test_submit_order_when_not_connected_logs_and_does_not_send(self):
# Arrange
strategy = TradingStrategy("000")
order = self.order_factory.market(
ETHUSDT_BINANCE.symbol,
OrderSide.BUY,
Quantity(100),
)
command = SubmitOrder(
BINANCE,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_client.submit_order(command)
# Assert
self.assertEqual(OrderState.INITIALIZED, order.state)
def test_submit_order_when_not_connected_logs_and_does_not_send(self):
# Arrange
strategy = TradingStrategy("000")
order = self.order_factory.market(
ETHUSDT_BINANCE.id,
OrderSide.BUY,
Quantity(100),
)
command = SubmitOrder(
order.instrument_id.venue.client_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.exec_client.submit_order(command)
# Assert
assert order.state == OrderState.INITIALIZED
def test_submit_order(self):
# Arrange
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
clock=self.clock,
uuid_factory=TestUUIDFactory(),
logger=self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
PositionId.py_null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_engine.execute(submit_order)
# Assert
self.assertIn(submit_order, self.exec_client.received_commands)
self.assertTrue(self.cache.order_exists(order.cl_ord_id))
def test_submit_order_with_default_settings_sends_to_client(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.risk_engine.execute(submit_order)
# Assert
assert self.exec_client.calls == ['connect', 'submit_order']
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 test_serialize_and_deserialize_submit_order_commands(self):
# Arrange
order = self.order_factory.market(AUDUSD_SIM.symbol, OrderSide.BUY,
Quantity(100000))
command = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
StrategyId("SCALPER", "01"),
PositionId("P-123456"),
order,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(command, deserialized)
self.assertEqual(order, deserialized.order)
print(command)
print(len(serialized))
print(serialized)
print(b64encode(serialized))
def test_serialize_and_deserialize_submit_order_commands(self):
# Arrange
order = self.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000, precision=0),
)
command = SubmitOrder(
self.trader_id,
StrategyId("SCALPER-001"),
PositionId("P-123456"),
order,
uuid4(),
0,
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == command
assert deserialized.order == order
print(command)
print(len(serialized))
print(serialized)
print(b64encode(serialized))
def test_handle_order_fill_event(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
self.exec_engine.execute(submit_order)
# Act
self.exec_engine.process(TestStubs.event_order_submitted(order))
self.exec_engine.process(TestStubs.event_order_accepted(order))
self.exec_engine.process(
TestStubs.event_order_filled(order, AUDUSD_SIM))
expected_position_id = PositionId(
"O-19700101-000000-000-001-1") # Stubbed from order id?
# Assert
self.assertTrue(self.cache.position_exists(expected_position_id))
self.assertTrue(self.cache.is_position_open(expected_position_id))
self.assertFalse(self.cache.is_position_closed(expected_position_id))
self.assertEqual(Position,
type(self.cache.position(expected_position_id)))
self.assertIn(expected_position_id, self.cache.position_ids())
self.assertNotIn(
expected_position_id,
self.cache.position_closed_ids(strategy_id=strategy.id))
self.assertNotIn(expected_position_id,
self.cache.position_closed_ids())
self.assertIn(expected_position_id,
self.cache.position_open_ids(strategy_id=strategy.id))
self.assertIn(expected_position_id, self.cache.position_open_ids())
self.assertEqual(1, self.cache.positions_total_count())
self.assertEqual(1, self.cache.positions_open_count())
self.assertEqual(0, self.cache.positions_closed_count())
def test_update_order_with_default_settings_sends_to_client(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER-000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("1.00010"),
)
submit = SubmitOrder(
self.trader_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
update = UpdateOrder(
self.trader_id,
strategy.id,
order.instrument_id,
order.client_order_id,
order.venue_order_id,
order.quantity,
Price.from_str("1.00010"),
None,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.risk_engine.execute(submit)
# Act
self.risk_engine.execute(update)
# Assert
assert self.exec_client.calls == [
"connect", "submit_order", "update_order"
]
assert self.risk_engine.command_count == 2
assert self.exec_engine.command_count == 2
async def run_test():
# Arrange
self.engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.engine.register_strategy(strategy)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submit_order = SubmitOrder(
AUDUSD_SIM.id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.engine.execute(submit_order)
self.engine.process(TestStubs.event_order_submitted(order))
self.engine.process(TestStubs.event_order_accepted(order))
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_state=OrderState.EXPIRED,
filled_qty=Quantity(0),
timestamp_ns=0,
)
self.client.add_order_status_report(report)
await asyncio.sleep(0.01)
# Act
result = await self.engine.reconcile_state()
self.engine.stop()
# Assert
assert result
def test_cancel_order_with_default_settings_sends_to_client(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit = SubmitOrder(
order.instrument_id.venue.client_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
cancel = CancelOrder(
order.instrument_id.venue.client_id,
self.trader_id,
self.account_id,
order.instrument_id,
order.client_order_id,
order.venue_order_id,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.risk_engine.execute(submit)
# Act
self.risk_engine.execute(cancel)
# Assert
assert self.exec_client.calls == [
"connect", "submit_order", "cancel_order"
]
def test_message_qsize_at_max_blocks_on_put_event(self):
# Arrange
self.risk_engine = LiveRiskEngine(
loop=self.loop,
exec_engine=self.exec_engine,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
config={"qsize": 1},
)
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
order.instrument_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
event = TestStubs.event_order_submitted(order)
# Act
self.risk_engine.execute(submit_order)
self.risk_engine.process(event) # Add over max size
# Assert
assert self.risk_engine.qsize() == 1
assert self.risk_engine.event_count == 0
def test_message_qsize_at_max_blocks_on_put_event(self):
# Arrange
self.exec_engine = LiveExecutionEngine(loop=self.loop,
database=self.database,
portfolio=self.portfolio,
clock=self.clock,
logger=self.logger,
config={"qsize": 1})
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
Venue("SIM"),
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
event = TestStubs.event_order_submitted(order)
# Act
self.exec_engine.execute(submit_order)
self.exec_engine.process(event) # Add over max size
# Assert
self.assertEqual(1, self.exec_engine.qsize())
self.assertEqual(0, self.exec_engine.command_count)
def test_can_handle_order_fill_event(self):
# Arrange
strategy = TradingStrategy(order_id_tag='001')
strategy.change_clock(self.clock)
self.exec_engine.register_strategy(strategy)
position_id = strategy.position_id_generator.generate()
order = strategy.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
submit_order = SubmitOrder(self.trader_id, self.account_id,
strategy.id, position_id, order,
self.guid_factory.generate(),
self.clock.time_now())
self.exec_engine.execute_command(submit_order)
order_filled = TestStubs.event_order_filled(order)
# Act
self.exec_engine.handle_event(order_filled)
# Assert
self.assertTrue(self.exec_db.position_exists(position_id))
self.assertTrue(self.exec_db.is_position_open(position_id))
self.assertFalse(self.exec_db.is_position_closed(position_id))
self.assertFalse(self.exec_engine.is_strategy_flat(strategy.id))
self.assertFalse(self.exec_engine.is_flat())
self.assertEqual(Position,
type(self.exec_db.get_position(position_id)))
self.assertTrue(position_id in self.exec_db.get_positions())
self.assertTrue(
position_id not in self.exec_db.get_positions_closed(strategy.id))
self.assertTrue(position_id not in self.exec_db.get_positions_closed())
self.assertTrue(
position_id in self.exec_db.get_positions_open(strategy.id))
self.assertTrue(position_id in self.exec_db.get_positions_open())
self.assertEqual(1, self.exec_db.count_positions_total())
self.assertEqual(1, self.exec_db.count_positions_open())
self.assertEqual(0, self.exec_db.count_positions_closed())
self.assertTrue(self.exec_db.position_exists_for_order(order.id))
self.assertEqual(Position,
type(self.exec_db.get_position_for_order(order.id)))
def test_message_qsize_at_max_blocks_on_put_command(self):
# Arrange
self.exec_engine = LiveExecutionEngine(
loop=self.loop,
portfolio=self.portfolio,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config={"qsize": 1},
)
self.exec_engine.register_risk_engine(self.risk_engine)
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER-000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
)
submit_order = SubmitOrder(
self.trader_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.exec_engine.execute(submit_order)
self.exec_engine.execute(submit_order)
# Assert
assert self.exec_engine.qsize() == 1
assert self.exec_engine.command_count == 0
def test_submit_order_raises_exception(self):
order = self.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.SELL,
Quantity.from_int(100000),
Price.from_str("1.00000"),
)
command = SubmitOrder(
self.trader_id,
order.strategy_id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.assertRaises(NotImplementedError, self.client.submit_order,
command)
def test_execute_command(self):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.id,
OrderSide.BUY,
Quantity.from_str("1.00000000"),
)
command = SubmitOrder(
self.trader_id,
self.strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
def execute_command():
self.exec_engine.execute(command)
self.benchmark.pedantic(execute_command, iterations=10_000, rounds=1)
def test_submit_order_raises_exception(self):
order = self.order_factory.limit(
AUDUSD_SIM.symbol,
OrderSide.SELL,
Quantity(100000),
Price("1.00000"),
)
command = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
StrategyId("SCALPER", "001"),
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
self.assertRaises(NotImplementedError, self.client.submit_order, command)
async def run_test():
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
Venue("SIM"),
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_engine.execute(submit_order)
await asyncio.sleep(0.1)
# Assert
self.assertEqual(0, self.exec_engine.qsize())
self.assertEqual(1, self.exec_engine.command_count)
# Tear Down
self.exec_engine.stop()
async def run_test():
# Arrange
self.risk_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
order.instrument_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_order)
await asyncio.sleep(0.1)
# Assert
assert self.risk_engine.qsize() == 0
assert self.risk_engine.command_count == 1
# Tear Down
self.risk_engine.stop()
def test_execute_command(self):
order = self.strategy.order_factory.market(
BTCUSDT_BINANCE.symbol,
OrderSide.BUY,
Quantity("1.00000000"),
)
command = SubmitOrder(
order.symbol.venue,
self.trader_id,
self.account_id,
self.strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
def execute_command():
self.exec_engine.execute(command)
PerformanceHarness.profile_function(execute_command, 10000, 1)
def submit_order_command():
return SubmitOrder(
trader_id=BetfairTestStubs.trader_id(),
strategy_id=BetfairTestStubs.strategy_id(),
position_id=BetfairTestStubs.position_id(),
order=LimitOrder(
client_order_id=ClientOrderId(
f"O-20210410-022422-001-001-{BetfairTestStubs.strategy_id().value}"
),
strategy_id=BetfairTestStubs.strategy_id(),
instrument_id=BetfairTestStubs.instrument_id(),
order_side=OrderSide.BUY,
quantity=Quantity.from_int(10),
price=Price(0.33, precision=5),
time_in_force=TimeInForce.GTC,
expire_time=None,
init_id=BetfairTestStubs.uuid(),
timestamp_ns=BetfairTestStubs.clock().timestamp_ns(),
),
command_id=BetfairTestStubs.uuid(),
timestamp_ns=BetfairTestStubs.clock().timestamp_ns(),
)
def submit_order_command():
return SubmitOrder(
instrument_id=BetfairTestStubs.instrument_id(),
trader_id=BetfairTestStubs.trader_id(),
account_id=BetfairTestStubs.account_id(),
strategy_id=BetfairTestStubs.strategy_id(),
position_id=BetfairTestStubs.position_id(),
order=LimitOrder(
client_order_id=ClientOrderId("1"),
strategy_id=BetfairTestStubs.strategy_id(),
instrument_id=BetfairTestStubs.instrument_id(),
order_side=OrderSide.BUY,
quantity=Quantity(10),
price=Price(0.33, 5),
time_in_force=TimeInForce.GTC,
expire_time=None,
init_id=BetfairTestStubs.uuid(),
timestamp_ns=BetfairTestStubs.clock().timestamp_ns(),
),
command_id=BetfairTestStubs.uuid(),
timestamp_ns=BetfairTestStubs.clock().timestamp_ns(),
)
def test_submit_order_when_block_all_orders_true_then_denies_order(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
submit_order = SubmitOrder(
order.instrument_id.venue.client_id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.risk_engine.set_block_all_orders()
# Act
self.exec_engine.execute(submit_order)
# Assert
assert self.exec_client.calls == ["connect"]
assert self.exec_engine.event_count == 1
def test_can_submit_order(self):
# Arrange
strategy = TradingStrategy(order_id_tag='001')
strategy.change_clock(self.clock)
self.exec_engine.register_strategy(strategy)
position_id = strategy.position_id_generator.generate()
order = strategy.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
submit_order = SubmitOrder(self.trader_id, self.account_id,
strategy.id, position_id, order,
self.guid_factory.generate(),
self.clock.time_now())
# Act
self.exec_engine.execute_command(submit_order)
# Assert
self.assertIn(submit_order, self.exec_client.received_commands)
self.assertTrue(self.exec_db.order_exists(order.id))
self.assertEqual(position_id, self.exec_db.get_position_id(order.id))
async def run_test():
# Arrange
self.engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.engine.register_strategy(strategy)
order = strategy.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submit_order = SubmitOrder(
AUDUSD_SIM.id,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.engine.execute(submit_order)
self.engine.process(TestStubs.event_order_submitted(order))
self.engine.process(TestStubs.event_order_accepted(order))
report = OrderStatusReport(
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"), # <-- from stub event
order_state=OrderState.FILLED,
filled_qty=Quantity(100000),
timestamp_ns=0,
)
trade1 = ExecutionReport(
execution_id=ExecutionId("1"),
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
last_qty=Decimal(50000),
last_px=Decimal("1.00000"),
commission_amount=Decimal("5.0"),
commission_currency="USD",
liquidity_side=LiquiditySide.MAKER,
execution_ns=0,
timestamp_ns=0,
)
trade2 = ExecutionReport(
execution_id=ExecutionId("2"),
client_order_id=order.client_order_id,
venue_order_id=VenueOrderId("1"),
last_qty=Decimal(50000),
last_px=Decimal("1.00000"),
commission_amount=Decimal("2.0"),
commission_currency="USD",
liquidity_side=LiquiditySide.MAKER,
execution_ns=0,
timestamp_ns=0,
)
self.client.add_order_status_report(report)
self.client.add_trades_list(VenueOrderId("1"), [trade1, trade2])
await asyncio.sleep(0.01)
# Act
result = await self.engine.reconcile_state()
self.engine.stop()
# Assert
assert result
def test_flip_position_on_opposite_filled_same_position_buy(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order1 = strategy.order_factory.market(
AUDUSD_SIM.symbol,
OrderSide.SELL,
Quantity(100000),
)
order2 = strategy.order_factory.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(150000),
)
submit_order1 = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order1,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
position_id = PositionId("P-000-AUD/USD.SIM-1")
self.exec_engine.execute(submit_order1)
self.exec_engine.process(TestStubs.event_order_submitted(order1))
self.exec_engine.process(TestStubs.event_order_accepted(order1))
self.exec_engine.process(
TestStubs.event_order_filled(order1, AUDUSD_SIM, position_id))
submit_order2 = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
position_id,
order2,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_engine.execute(submit_order2)
self.exec_engine.process(TestStubs.event_order_submitted(order2))
self.exec_engine.process(TestStubs.event_order_accepted(order2))
self.exec_engine.process(
TestStubs.event_order_filled(order2, AUDUSD_SIM, position_id))
position_id_flipped = PositionId("P-000-AUD/USD.SIM-1F")
# Assert
position_flipped = self.cache.position(position_id_flipped)
self.assertEqual(50000, position_flipped.relative_quantity)
self.assertTrue(self.cache.position_exists(position_id))
self.assertTrue(self.cache.position_exists(position_id_flipped))
self.assertTrue(self.cache.is_position_closed(position_id))
self.assertTrue(self.cache.is_position_open(position_id_flipped))
self.assertIn(position_id, self.cache.position_ids())
self.assertIn(position_id,
self.cache.position_ids(strategy_id=strategy.id))
self.assertIn(position_id_flipped, self.cache.position_ids())
self.assertIn(position_id_flipped,
self.cache.position_ids(strategy_id=strategy.id))
self.assertEqual(2, self.cache.positions_total_count())
self.assertEqual(1, self.cache.positions_open_count())
self.assertEqual(1, self.cache.positions_closed_count())
def test_multiple_strategy_positions_one_active_one_closed(self):
# Arrange
self.exec_engine.start()
strategy1 = TradingStrategy(order_id_tag="001")
strategy1.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
strategy2 = TradingStrategy(order_id_tag="002")
strategy2.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy1)
self.exec_engine.register_strategy(strategy2)
order1 = strategy1.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
order2 = strategy1.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.SELL,
Quantity(100000),
Price("1.00000"),
)
order3 = strategy2.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submit_order1 = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy1.id,
PositionId.null(),
order1,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
position_id1 = PositionId('P-1')
submit_order2 = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy1.id,
position_id1,
order2,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
submit_order3 = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy2.id,
PositionId.null(),
order3,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
position_id2 = PositionId('P-2')
# Act
self.exec_engine.execute(submit_order1)
self.exec_engine.process(TestStubs.event_order_submitted(order1))
self.exec_engine.process(TestStubs.event_order_accepted(order1))
self.exec_engine.process(
TestStubs.event_order_filled(order1, AUDUSD_SIM, position_id1))
self.exec_engine.execute(submit_order2)
self.exec_engine.process(TestStubs.event_order_submitted(order2))
self.exec_engine.process(TestStubs.event_order_accepted(order2))
self.exec_engine.process(
TestStubs.event_order_filled(order2, AUDUSD_SIM, position_id1))
self.exec_engine.execute(submit_order3)
self.exec_engine.process(TestStubs.event_order_submitted(order3))
self.exec_engine.process(TestStubs.event_order_accepted(order3))
self.exec_engine.process(
TestStubs.event_order_filled(order3, AUDUSD_SIM, position_id2))
# Assert
# Already tested .is_position_active and .is_position_closed above
self.assertTrue(self.cache.position_exists(position_id1))
self.assertTrue(self.cache.position_exists(position_id2))
self.assertIn(position_id1,
self.cache.position_ids(strategy_id=strategy1.id))
self.assertIn(position_id2,
self.cache.position_ids(strategy_id=strategy2.id))
self.assertIn(position_id1, self.cache.position_ids())
self.assertIn(position_id2, self.cache.position_ids())
self.assertEqual(
0, len(self.cache.positions_open(strategy_id=strategy1.id)))
self.assertEqual(
1, len(self.cache.positions_open(strategy_id=strategy2.id)))
self.assertEqual(1, len(self.cache.positions_open()))
self.assertEqual(1, len(self.cache.positions_closed()))
self.assertEqual(2, len(self.cache.positions()))
self.assertNotIn(
position_id1,
self.cache.position_open_ids(strategy_id=strategy1.id))
self.assertIn(position_id2,
self.cache.position_open_ids(strategy_id=strategy2.id))
self.assertNotIn(position_id1, self.cache.position_open_ids())
self.assertIn(position_id2, self.cache.position_open_ids())
self.assertIn(position_id1,
self.cache.position_closed_ids(strategy_id=strategy1.id))
self.assertNotIn(
position_id2,
self.cache.position_closed_ids(strategy_id=strategy2.id))
self.assertIn(position_id1, self.cache.position_closed_ids())
self.assertNotIn(position_id2, self.cache.position_closed_ids())
self.assertEqual(2, self.cache.positions_total_count())
self.assertEqual(1, self.cache.positions_open_count())
self.assertEqual(1, self.cache.positions_closed_count())
def test_close_position_on_order_fill(self):
# Arrange
self.exec_engine.start()
strategy = TradingStrategy(order_id_tag="001")
strategy.register_trader(
TraderId("TESTER", "000"),
self.clock,
self.logger,
)
self.exec_engine.register_strategy(strategy)
order1 = strategy.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
order2 = strategy.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.SELL,
Quantity(100000),
Price("1.00000"),
)
submit_order1 = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
PositionId.null(),
order1,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
position_id = PositionId("P-1")
self.exec_engine.execute(submit_order1)
self.exec_engine.process(TestStubs.event_order_submitted(order1))
self.exec_engine.process(TestStubs.event_order_accepted(order1))
self.exec_engine.process(
TestStubs.event_order_filled(order1, AUDUSD_SIM, position_id))
submit_order2 = SubmitOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
position_id,
order2,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_engine.execute(submit_order2)
self.exec_engine.process(TestStubs.event_order_submitted(order2))
self.exec_engine.process(TestStubs.event_order_accepted(order2))
self.exec_engine.process(
TestStubs.event_order_filled(order2, AUDUSD_SIM, position_id))
# # Assert
self.assertTrue(self.cache.position_exists(position_id))
self.assertFalse(self.cache.is_position_open(position_id))
self.assertTrue(self.cache.is_position_closed(position_id))
self.assertEqual(position_id, self.cache.position(position_id).id)
self.assertEqual(position_id,
self.cache.positions(strategy_id=strategy.id)[0].id)
self.assertEqual(position_id, self.cache.positions()[0].id)
self.assertEqual(
0, len(self.cache.positions_open(strategy_id=strategy.id)))
self.assertEqual(0, len(self.cache.positions_open()))
self.assertEqual(
position_id,
self.cache.positions_closed(strategy_id=strategy.id)[0].id)
self.assertEqual(position_id, self.cache.positions_closed()[0].id)
self.assertNotIn(position_id,
self.cache.position_open_ids(strategy_id=strategy.id))
self.assertNotIn(position_id, self.cache.position_open_ids())
self.assertEqual(1, self.cache.positions_total_count())
self.assertEqual(0, self.cache.positions_open_count())
self.assertEqual(1, self.cache.positions_closed_count())