def test_apply_order_filled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
filled = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("1"),
ExecutionId("E-1"),
PositionId("P-1"),
StrategyId.null(),
order.symbol,
order.side,
order.quantity,
order.quantity,
Quantity(),
Price("1.00001"),
AUDUSD_SIM.quote_currency,
AUDUSD_SIM.is_inverse,
Money(0, USD),
LiquiditySide.MAKER,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
order.apply(submitted)
order.apply(accepted)
order.apply(working)
# Act
order.apply(filled)
# Assert
self.assertEqual(OrderState.FILLED, order.state)
self.assertEqual(Quantity(100000), order.filled_qty)
self.assertEqual(Price("1.00000"), order.price)
self.assertEqual(Decimal("1.00001"), order.avg_price)
self.assertEqual(Decimal("0.00001"), order.slippage)
self.assertTrue(order.is_completed)
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_can_apply_order_modified_event_to_stop_order(self):
# Arrange
order = self.order_factory.stop(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"))
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
modified = OrderModified(
self.account_id,
order.cl_ord_id,
OrderId("1"),
Quantity(120000),
Price("1.00001"),
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH)
order.apply(submitted)
order.apply(accepted)
order.apply(working)
# Act
order.apply(modified)
# Assert
self.assertEqual(OrderState.WORKING, order.state())
self.assertEqual(OrderId("1"), order.id)
self.assertEqual(Quantity(120000), order.quantity)
self.assertEqual(Price("1.00001"), order.price)
self.assertTrue(order.is_working())
self.assertFalse(order.is_completed())
self.assertEqual(5, order.event_count())
def test_can_initialize_atomic_order_market_with_take_profit_and_label(
self):
# Arrange
# Act
atomic_order = self.order_factory.atomic_market(
AUDUSD_FXCM, OrderSide.BUY, Quantity(100000), Price(0.99990, 5),
Price(1.00010, 5), Label('U1'))
# Assert
self.assertEqual(AUDUSD_FXCM, atomic_order.stop_loss.symbol)
self.assertTrue(atomic_order.has_take_profit)
self.assertEqual(AUDUSD_FXCM, atomic_order.take_profit.symbol)
self.assertEqual(OrderId('O-19700101-000000-001-001-1'),
atomic_order.entry.id)
self.assertEqual(OrderId('O-19700101-000000-001-001-2'),
atomic_order.stop_loss.id)
self.assertEqual(OrderId('O-19700101-000000-001-001-3'),
atomic_order.take_profit.id)
self.assertEqual(OrderSide.SELL, atomic_order.stop_loss.side)
self.assertEqual(OrderSide.SELL, atomic_order.take_profit.side)
self.assertEqual(Quantity(100000), atomic_order.stop_loss.quantity)
self.assertEqual(Quantity(100000), atomic_order.take_profit.quantity)
self.assertEqual(Price(0.99990, 5), atomic_order.stop_loss.price)
self.assertEqual(Price(1.00010, 5), atomic_order.take_profit.price)
self.assertEqual(Label('U1_E'), atomic_order.entry.label)
self.assertEqual(Label('U1_SL'), atomic_order.stop_loss.label)
self.assertEqual(Label('U1_TP'), atomic_order.take_profit.label)
self.assertEqual(TimeInForce.GTC, atomic_order.stop_loss.time_in_force)
self.assertEqual(TimeInForce.GTC,
atomic_order.take_profit.time_in_force)
self.assertEqual(None, atomic_order.entry.expire_time)
self.assertEqual(None, atomic_order.stop_loss.expire_time)
self.assertEqual(None, atomic_order.take_profit.expire_time)
self.assertEqual(AtomicOrderId('AO-19700101-000000-001-001-1'),
atomic_order.id)
self.assertEqual(UNIX_EPOCH, atomic_order.timestamp)
def test_cancel_order_raises_not_implemented_error(self):
# Arrange
# Act
command = CancelOrder(
self.venue,
self.trader_id,
self.account_id,
ClientOrderId("O-123456789"),
OrderId("001"),
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Assert
self.assertRaises(NotImplementedError, self.client.cancel_order, command)
def test_priced_order_with_GTD_time_in_force_and_expire_time_none_raises_exception(
self):
# Arrange
# Act
self.assertRaises(ValueError,
Order,
OrderId('O-123456'),
AUDUSD_FXCM,
OrderSide.BUY,
OrderType.LIMIT,
Quantity(100000),
GUID(uuid.uuid4()),
UNIX_EPOCH,
price=Price(1.00000, 5),
time_in_force=TimeInForce.GTD,
expire_time=None)
def test_can_apply_order_partially_filled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"))
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
partially = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("1"),
ExecutionId("E-1"),
PositionId("P-1"),
StrategyId("S", "NULL"),
order.symbol,
order.side,
Quantity(50000),
Quantity(50000),
Price("0.999999"),
Money(0, USD),
LiquiditySide.MAKER,
USD,
USD,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH)
order.apply(submitted)
order.apply(accepted)
order.apply(working)
# Act
order.apply(partially)
# Assert
self.assertEqual(OrderState.PARTIALLY_FILLED, order.state())
self.assertEqual(Quantity(50000), order.filled_qty)
self.assertEqual(Price("1.00000"), order.price)
self.assertEqual(Price("0.999999"), order.avg_price)
self.assertEqual(Decimal("-0.000001"), order.slippage)
self.assertFalse(order.is_completed())
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_order_cancelled(self):
# Arrange
uuid = uuid4()
event = OrderCancelled(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
cancelled_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
self.assertEqual(f"OrderCancelled(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, event_id={uuid})", str(event))
self.assertEqual(f"OrderCancelled(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, event_id={uuid})", repr(event))
def test_serialize_and_deserialize_order_expired_events(self):
# Arrange
event = OrderExpired(
self.account_id,
ClientOrderId("O-123456"),
OrderId("1"),
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
def event_order_filled(
order,
instrument,
position_id=None,
strategy_id=None,
fill_price=None,
fill_qty=None,
liquidity_side=LiquiditySide.TAKER,
) -> OrderFilled:
if position_id is None:
position_id = PositionId(order.cl_ord_id.value.replace("P", "T"))
if strategy_id is None:
strategy_id = StrategyId.null()
if fill_price is None:
fill_price = Price("1.00000")
if fill_qty is None:
fill_qty = order.quantity
commission = instrument.calculate_commission(
quantity=order.quantity,
avg_price=fill_price,
liquidity_side=liquidity_side,
)
return OrderFilled(
account_id=TestStubs.account_id(),
cl_ord_id=order.cl_ord_id,
order_id=OrderId("1"),
execution_id=ExecutionId(order.cl_ord_id.value.replace("O", "E")),
position_id=position_id,
strategy_id=strategy_id,
symbol=order.symbol,
order_side=order.side,
fill_qty=fill_qty,
cum_qty=Quantity(order.filled_qty + fill_qty),
leaves_qty=Quantity(
max(0, order.quantity - order.filled_qty - fill_qty)),
fill_price=order.price if fill_price is None else fill_price,
currency=instrument.quote_currency,
is_inverse=instrument.is_inverse,
commission=commission,
liquidity_side=liquidity_side,
execution_time=UNIX_EPOCH,
event_id=uuid4(),
event_timestamp=UNIX_EPOCH,
)
def test_apply_order_partially_filled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
order.apply(TestStubs.event_order_submitted(order))
order.apply(TestStubs.event_order_accepted(order))
partially = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("1"),
ExecutionId("E-1"),
PositionId("P-1"),
StrategyId.null(),
order.instrument_id,
order.side,
Quantity(50000),
Quantity(50000),
Quantity(50000),
Price("0.999999"),
AUDUSD_SIM.quote_currency,
AUDUSD_SIM.is_inverse,
Money(0, USD),
LiquiditySide.MAKER,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
order.apply(partially)
# Assert
self.assertEqual(OrderState.PARTIALLY_FILLED, order.state)
self.assertEqual(Quantity(50000), order.filled_qty)
self.assertEqual(Price("1.00000"), order.price)
self.assertEqual(Decimal("0.999999"), order.avg_price)
self.assertEqual(Decimal("-0.000001"), order.slippage)
self.assertTrue(order.is_working)
self.assertFalse(order.is_completed)
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_cancel_stop_order_when_order_does_not_exist_generates_cancel_reject(self):
# Arrange
command = CancelOrder(
venue=SIM,
trader_id=self.trader_id,
account_id=self.account_id,
cl_ord_id=ClientOrderId("O-123456"),
order_id=OrderId("001"),
command_id=self.uuid_factory.generate(),
command_timestamp=UNIX_EPOCH,
)
# Act
self.exchange.handle_cancel_order(command)
# Assert
self.assertEqual(2, self.exec_engine.event_count)
def test_order_expired(self):
# Arrange
uuid = uuid4()
event = OrderExpired(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
expired_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
assert f"OrderExpired(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id=123456, event_id={uuid})" == str(
event)
assert f"OrderExpired(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id=123456, event_id={uuid})" == repr(
event)
def event_order_working(order, working_price=None) -> OrderWorking:
if working_price is None:
working_price = Price("1.00000")
return OrderWorking(
TestStubs.account_id(),
order.cl_ord_id,
OrderId("1"),
order.symbol,
order.side,
order.type,
order.quantity,
order.price if working_price is None else working_price,
order.time_in_force,
order.expire_time,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
def test_order_amended(self):
# Arrange
uuid = uuid4()
event = OrderAmended(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
quantity=Quantity(500000),
price=Price('1.95000'),
amended_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
self.assertEqual(f"OrderAmended(account_id=SIM-000, cl_order_id=O-2020872378423, "
f"order_id=123456, qty=500,000, price=1.95000, event_id={uuid})", str(event))
self.assertEqual(f"OrderAmended(account_id=SIM-000, cl_order_id=O-2020872378423, "
f"order_id=123456, qty=500,000, price=1.95000, event_id={uuid})", repr(event))
def test_serialize_and_deserialize_order_cancel_reject_events(self):
# Arrange
event = OrderCancelReject(
self.account_id,
ClientOrderId("O-123456"),
OrderId("1"),
UNIX_EPOCH,
"RESPONSE",
"ORDER_DOES_NOT_EXIST",
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
def test_serialize_and_deserialize_order_modified_events(self):
# Arrange
event = OrderModified(
self.account_id,
ClientOrderId("O-123456"),
OrderId("1"),
Quantity(100000),
Price("0.80010"),
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
def event_order_filled(
order,
position_id=None,
strategy_id=None,
fill_price=None,
filled_qty=None,
leaves_qty=None,
base_currency=USD,
quote_currency=JPY,
commission=0,
) -> OrderFilled:
if position_id is None:
position_id = PositionId(order.cl_ord_id.value.replace("P", "T"))
if strategy_id is None:
strategy_id = StrategyId("S", "NULL")
if fill_price is None:
fill_price = Price("1.00000")
if filled_qty is None:
filled_qty = order.quantity
if leaves_qty is None:
leaves_qty = Quantity()
return OrderFilled(
TestStubs.account_id(),
order.cl_ord_id,
OrderId("1"),
ExecutionId(order.cl_ord_id.value.replace("O", "E")),
position_id,
strategy_id,
order.symbol,
order.side,
filled_qty,
leaves_qty,
order.price if fill_price is None else fill_price,
Money(commission, base_currency),
LiquiditySide.TAKER,
base_currency, # Stub event
quote_currency, # Stub event
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
def test_order_accepted(self, order_id=None):
if order_id is None:
order_id = OrderId("123456")
# Arrange
uuid = uuid4()
event = OrderAccepted(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=order_id,
accepted_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
assert f"OrderAccepted(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id={123456}, event_id={uuid})", str(
event) # noqa
assert f"OrderAccepted(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id={123456}, event_id={uuid})", repr(
event) # noqa
def test_serialize_and_deserialize_cancel_order_commands(self):
# Arrange
command = CancelOrder(
self.venue,
self.trader_id,
self.account_id,
ClientOrderId("O-123456"),
OrderId("001"),
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(command, deserialized)
print(b64encode(serialized))
print(command)
def test_order_cancel_reject(self):
# Arrange
uuid = uuid4()
event = OrderCancelReject(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
rejected_time=UNIX_EPOCH,
response_to="O-2020872378423",
reason="ORDER_DOES_NOT_EXIST",
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
self.assertEqual(f"OrderCancelReject(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"response_to=O-2020872378423, reason='ORDER_DOES_NOT_EXIST', "
f"event_id={uuid})", str(event))
self.assertEqual(f"OrderCancelReject(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"response_to=O-2020872378423, reason='ORDER_DOES_NOT_EXIST', "
f"event_id={uuid})", repr(event))
def test_apply_order_working_event(self):
# Arrange
order = self.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
order.apply(TestStubs.event_order_submitted(order))
order.apply(TestStubs.event_order_accepted(order))
# Act
order.apply(TestStubs.event_order_working(order))
# Assert
# print(order)
self.assertEqual(OrderState.WORKING, order.state)
self.assertEqual(OrderId("1"), order.id)
self.assertFalse(order.is_completed)
self.assertTrue(order.is_working)
self.assertEqual(None, order.filled_timestamp)
def test_order_filled(self):
# Arrange
uuid = uuid4()
event = OrderFilled(
account_id=AccountId("SIM", "000"),
cl_ord_id=ClientOrderId("O-2020872378423"),
order_id=OrderId("123456"),
execution_id=ExecutionId("1"),
position_id=PositionId("2"),
strategy_id=StrategyId("SCALPER", "001"),
instrument_id=InstrumentId(Symbol("BTC/USDT"), Venue("BINANCE")),
order_side=OrderSide.BUY,
fill_qty=Quantity("0.561000"),
cum_qty=Quantity("0.561000"),
leaves_qty=Quantity(0),
fill_price=Price("15600.12445"),
currency=USDT,
is_inverse=False,
commission=Money("12.20000000", USDT),
liquidity_side=LiquiditySide.MAKER,
execution_time=UNIX_EPOCH,
event_id=uuid,
event_timestamp=UNIX_EPOCH,
)
# Act
assert (
f"OrderFilled(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, position_id=2, strategy_id=SCALPER-001, "
f"instrument_id=BTC/USDT.BINANCE, side=BUY-MAKER, fill_qty=0.561000, "
f"fill_price=15600.12445 USDT, cum_qty=0.561000, leaves_qty=0, "
f"commission=12.20000000 USDT, event_id={uuid})" == str(event))
assert (
f"OrderFilled(account_id=SIM-000, cl_ord_id=O-2020872378423, "
f"order_id=123456, position_id=2, strategy_id=SCALPER-001, "
f"instrument_id=BTC/USDT.BINANCE, side=BUY-MAKER, fill_qty=0.561000, "
f"fill_price=15600.12445 USDT, cum_qty=0.561000, leaves_qty=0, "
f"commission=12.20000000 USDT, event_id={uuid})" == repr(event))
def test_serialize_and_deserialize_order_working_events(self):
# Arrange
event = OrderWorking(
self.account_id,
ClientOrderId("O-123456"),
OrderId("B-123456"),
AUDUSD_SIM.symbol,
OrderSide.SELL,
OrderType.STOP_MARKET,
Quantity(100000),
Price("1.50000"),
TimeInForce.DAY,
None,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(event)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(deserialized, event)
def test_order_exists_when_no_order_returns_false(self):
# Arrange
# Act
# Assert
self.assertFalse(self.database.order_exists(OrderId('O-123456')))
def test_position_indexed_for_order_when_no_indexing_returns_false(self):
# Arrange
# Act
# Assert
self.assertFalse(
self.database.position_indexed_for_order(OrderId('O-123456')))
def test_position_filled_with_buy_order_then_sell_order_returns_expected_attributes(self):
# Arrange
order = self.order_factory.market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(150000),
)
fill1 = TestStubs.event_order_filled(
order,
instrument=AUDUSD_SIM,
position_id=PositionId("P-123456"),
strategy_id=StrategyId("S", "001"),
fill_price=Price("1.00001"),
)
position = Position(fill1)
fill2 = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("2"),
ExecutionId("E2"),
PositionId("T123456"),
StrategyId("S", "001"),
order.symbol,
OrderSide.SELL,
order.quantity,
order.quantity,
Quantity(),
Price("1.00011"),
AUDUSD_SIM.quote_currency,
AUDUSD_SIM.is_inverse,
Money(0, USD),
LiquiditySide.TAKER,
UNIX_EPOCH + timedelta(minutes=1),
uuid4(),
UNIX_EPOCH,
)
last = Price("1.00050")
# Act
position.apply(fill2)
# Assert
self.assertEqual(Quantity(), position.quantity)
self.assertEqual(PositionSide.FLAT, position.side)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertEqual(timedelta(minutes=1), position.open_duration)
self.assertEqual(Decimal("1.00001"), position.avg_open)
self.assertEqual(2, position.event_count)
self.assertEqual(datetime(1970, 1, 1, 0, 1, tzinfo=pytz.utc), position.closed_time)
self.assertEqual(Decimal("1.00011"), position.avg_close)
self.assertFalse(position.is_long)
self.assertFalse(position.is_short)
self.assertFalse(position.is_open)
self.assertTrue(position.is_closed)
self.assertEqual(Decimal("0.00010"), position.realized_points)
self.assertEqual(Decimal('0.00009999900000999990000099999000'), position.realized_return)
self.assertEqual(Money(12.00, USD), position.realized_pnl)
self.assertEqual(Money(0, USD), position.unrealized_pnl(last))
self.assertEqual(Money(12.00, USD), position.total_pnl(last))
self.assertEqual([Money(3.00, USD)], position.commissions())
self.assertEqual(Money(3.00, USD), position.commission)
self.assertEqual("Position(id=P-123456, FLAT AUD/USD.SIM)", repr(position))
def test_cld_ord_id_when_not_implemented_raises_exception(self):
self.assertRaises(NotImplementedError, self.facade.cl_ord_id,
OrderId("1"))
def test_position_filled_with_buy_order_then_sell_order_returns_expected_attributes(self):
# Arrange
order = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
fill1 = TestStubs.event_order_filled(
order,
position_id=PositionId("P-123456"),
strategy_id=StrategyId("S", "001"),
fill_price=Price("1.00001"),
)
position = Position(fill1)
fill2 = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("2"),
ExecutionId("E2"),
PositionId("T123456"),
StrategyId("S", "001"),
order.symbol,
OrderSide.SELL,
order.quantity,
Quantity(),
Price("1.00001"),
Money(0, USD),
LiquiditySide.TAKER,
AUD,
USD,
UNIX_EPOCH + timedelta(minutes=1),
uuid4(),
UNIX_EPOCH,
)
last = QuoteTick(
AUDUSD_FXCM,
Price("1.00050"),
Price("1.00048"),
Quantity(1),
Quantity(1),
UNIX_EPOCH,
)
# Act
position.apply(fill2)
# Assert
self.assertEqual(Quantity(), position.quantity)
self.assertEqual(PositionSide.FLAT, position.side)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertEqual(timedelta(minutes=1), position.open_duration)
self.assertEqual(1.00001, position.avg_open_price)
self.assertEqual(2, position.event_count())
self.assertEqual(datetime(1970, 1, 1, 0, 1, tzinfo=pytz.utc), position.closed_time)
self.assertEqual(1.00001, position.avg_close_price)
self.assertFalse(position.is_long())
self.assertFalse(position.is_short())
self.assertTrue(position.is_closed())
self.assertEqual(0.0, position.realized_points)
self.assertEqual(0.0, position.realized_return)
self.assertEqual(Money(0, USD), position.realized_pnl)
self.assertEqual(Money(0, USD), position.unrealized_pnl(last))
self.assertEqual(Money(0, USD), position.total_pnl(last))
def test_position_for_order_when_not_found_returns_none(self):
# Arrange
# Act
# Assert
self.assertIsNone(
self.database.get_position_for_order(OrderId('O-123456')))
def position_which_is_closed(position_id, close_price=None) -> Position:
if close_price is None:
close_price = Price("1.0001")
order_factory = OrderFactory(
strategy_id=StrategyId("S", "001"),
id_tag_trader=IdTag("001"),
id_tag_strategy=IdTag("001"),
)
order = order_factory.market(
TestStubs.symbol_audusd_fxcm(),
OrderSide.SELL,
Quantity(100000),
)
filled1 = OrderFilled(
TestStubs.account_id(),
order.cl_ord_id,
OrderId("1"),
ExecutionId(order.cl_ord_id.value.replace('O', 'E')),
position_id,
StrategyId("S", "1"),
order.symbol,
order.side,
order.quantity,
Quantity(),
close_price,
Money(0, USD),
LiquiditySide.TAKER,
USD, # Stub event
USD, # Stub event
UNIX_EPOCH + timedelta(minutes=5),
uuid4(),
UNIX_EPOCH + timedelta(minutes=5),
)
filled2 = OrderFilled(
TestStubs.account_id(),
order.cl_ord_id,
OrderId("2"),
ExecutionId(order.cl_ord_id.value.replace('O', 'E')),
position_id,
StrategyId("S", "1"),
order.symbol,
OrderSide.BUY,
order.quantity,
Quantity(),
close_price,
Money(0, USD),
LiquiditySide.TAKER,
USD, # Stub event
USD, # Stub event
UNIX_EPOCH + timedelta(minutes=5),
uuid4(),
UNIX_EPOCH + timedelta(minutes=5),
)
position = Position(filled1)
position.apply(filled2)
return position
