def test_submit_bracket_order_raises_not_implemented_error(self):
entry_order = self.order_factory.stop_market(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("0.99995"),
)
# Act
bracket_order = self.order_factory.bracket(
entry_order,
Price("0.99990"),
Price("1.00010"),
)
command = SubmitBracketOrder(
self.venue,
self.trader_id,
self.account_id,
StrategyId("SCALPER", "001"),
bracket_order,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
self.assertRaises(NotImplementedError, self.client.submit_bracket_order, command)
def test_submit_bracket_order_when_not_connected_logs_and_does_not_send(
self):
# Arrange
strategy = TradingStrategy("000")
entry = self.order_factory.market(
ETHUSDT_BINANCE.symbol,
OrderSide.BUY,
Quantity(100),
)
bracket = self.order_factory.bracket(entry, Price("500.00000"))
command = SubmitBracketOrder(
BINANCE,
self.trader_id,
self.account_id,
strategy.id,
bracket,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
# Act
self.exec_client.submit_bracket_order(command)
# Assert
self.assertEqual(OrderState.INITIALIZED, entry.state)
def test_serialize_and_deserialize_submit_bracket_order_with_take_profit_commands(
self, ):
# Arrange
entry_order = self.order_factory.limit(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000, precision=0),
Price(1.00000, precision=5),
)
bracket_order = self.order_factory.bracket(
entry_order,
stop_loss=Price(0.99900, precision=5),
take_profit=Price(1.00010, precision=5),
)
command = SubmitBracketOrder(
self.trader_id,
StrategyId("SCALPER-001"),
bracket_order,
uuid4(),
0,
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == command
assert deserialized.bracket_order == bracket_order
print(b64encode(serialized))
print(command)
def test_serialize_and_deserialize_submit_bracket_order_with_take_profit_commands(
self):
# Arrange
entry_order = self.order_factory.limit(
AUDUSD_SIM.symbol,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"),
)
bracket_order = self.order_factory.bracket(
entry_order,
stop_loss=Price("0.99900"),
take_profit=Price("1.00010"),
)
command = SubmitBracketOrder(
self.venue,
self.trader_id,
self.account_id,
StrategyId("SCALPER", "01"),
bracket_order,
uuid4(),
UNIX_EPOCH,
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
self.assertEqual(command, deserialized)
self.assertEqual(bracket_order, deserialized.bracket_order)
print(b64encode(serialized))
print(command)
def test_submit_bracket_order_raises_not_implemented_error(self):
entry_order = self.order_factory.stop_market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity.from_int(100000),
Price.from_str("0.99995"),
)
# Act
bracket_order = self.order_factory.bracket(
entry_order,
Price.from_str("0.99990"),
Price.from_str("1.00010"),
)
command = SubmitBracketOrder(
self.trader_id,
entry_order.strategy_id,
bracket_order,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
self.assertRaises(NotImplementedError,
self.client.submit_bracket_order, command)
def test_submit_bracket_order_when_not_connected_logs_and_does_not_send(
self):
# Arrange
strategy = TradingStrategy("000")
entry = self.order_factory.market(
ETHUSDT_BINANCE.id,
OrderSide.BUY,
Quantity.from_int(100),
)
bracket = self.order_factory.bracket(
entry,
Price.from_str("500.00000"),
Price.from_str("600.00000"),
)
command = SubmitBracketOrder(
self.trader_id,
strategy.id,
bracket,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.exec_client.submit_bracket_order(command)
# Assert
assert entry.state == OrderState.INITIALIZED
def test_serialize_and_deserialize_submit_bracket_order_no_take_profit_commands(
self, ):
# Arrange
entry_order = self.order_factory.market(AUDUSD_SIM.id, OrderSide.BUY,
Quantity(100000))
bracket_order = self.order_factory.bracket(
entry_order,
stop_loss=Price("0.99900"),
take_profit=Price("1.00100"),
)
command = SubmitBracketOrder(
entry_order.instrument_id.venue.client_id,
self.trader_id,
self.account_id,
StrategyId("SCALPER", "01"),
bracket_order,
uuid4(),
0,
)
# Act
serialized = self.serializer.serialize(command)
deserialized = self.serializer.deserialize(serialized)
# Assert
assert deserialized == command
assert deserialized.bracket_order == bracket_order
print(b64encode(serialized))
print(command)
def test_submit_bracket_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)
entry = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
bracket = strategy.order_factory.bracket(
entry_order=entry,
stop_loss=Price("1.00000"),
take_profit=Price("1.00010"),
)
submit_bracket = SubmitBracketOrder(
self.venue,
self.trader_id,
self.account_id,
strategy.id,
bracket,
self.uuid_factory.generate(),
self.clock.utc_now(),
)
self.risk_engine.set_block_all_orders()
# Act
self.exec_engine.execute(submit_bracket)
# Assert
assert self.exec_client.calls == ['connect']
assert self.exec_engine.event_count == 3
def test_submit_bracket_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)
entry = strategy.order_factory.market(
AUDUSD_SIM.id,
OrderSide.BUY,
Quantity(100000),
)
bracket = strategy.order_factory.bracket(
entry_order=entry,
stop_loss=Price("1.00000"),
take_profit=Price("1.00010"),
)
submit_bracket = SubmitBracketOrder(
entry.instrument_id.venue.client_id,
self.trader_id,
self.account_id,
strategy.id,
bracket,
self.uuid_factory.generate(),
self.clock.timestamp_ns(),
)
# Act
self.risk_engine.execute(submit_bracket)
# Assert
assert self.exec_client.calls == ["connect", "submit_bracket_order"]