test: ExecutionEngine + PortfolioOrchestrator tests, RiskMonitor integration

Adds 22 tests covering:
- Order FSM: valid/invalid transitions, terminal states, timestamps
- Fill matching: partial/full fills, multiple fills, avg price
- Position updates: buy adds, sell realizes PnL
- ExecutionEngine: full order lifecycle, portfolio snapshot
- PortfolioOrchestrator: signal→orders, rebalance, sell untargeted
- Cash tracking, portfolio summary

RiskMonitor integration: pre-trade checks before order submission.

1184 passed (all existing + 22 new)

Author: sijie-Z

strategy/portfolio_orchestrator.py

@@ -27,9 +27,11 @@
 from quant_platform.execution.engine import (
     ExecutionEngine,
     OrderSide,
+)
+from quant_platform.execution.models import (
+    OrderStatus,
     OrderType,
 )
-from quant_platform.execution.models import OrderStatus
 from quant_platform.strategy.multi_strategy import (
     MultiStrategyManager,
     StrategyConfig,
@@ -53,11 +55,13 @@ def __init__(
         exec_engine: ExecutionEngine | None = None,
         lot_size: int = 100,
         t_plus: int = 1,
+        risk_monitor=None,
     ):
         self.multi_strategy = multi_strategy
         self.exec_engine = exec_engine or ExecutionEngine()
         self.lot_size = lot_size
-        self.t_plus = t_plus  # A-share T+1 settlement
+        self.t_plus = t_plus
+        self.risk_monitor = risk_monitor  # A-share T+1 settlement
 
         # Track positions per strategy (strategy_id -> {ticker: target_qty})
         self._targets: dict[str, dict[str, int]] = {}
@@ -181,6 +185,19 @@ def rebalance(self) -> list[dict]:
                         quantity=self._round_lot(buy_qty),
                         strategy=strategy_id,
                     )
+                    # Pre-trade risk check
+                    if self.risk_monitor is not None:
+                        check = self.risk_monitor.check_pre_trade(
+                            ticker=ticker,
+                            quantity=order.quantity,
+                            price=price,
+                            side=OrderSide.BUY,
+                        )
+                        if not check.get('approved', True):
+                            logger.warning('Order blocked by risk: %s', check.get('reason', ''))
+                            order.notes = f'Risk blocked: {check.get("reason", "")}'
+                            self.exec_engine.reject_order(order)
+                            continue
                     self.exec_engine.submit_order(order)
                     self._cash_locked += order.quantity * price
 

tests/test_execution/test_engine.py

@@ -0,0 +1,138 @@
+"""Tests for ExecutionEngine and Order state machine."""
+
+import pytest
+from datetime import datetime
+
+from quant_platform.execution.engine import (
+    ExecutionEngine,
+    OrderSide,
+    OrderStatus,
+    validate_order_transition,
+    transition_order,
+    apply_fill,
+    update_position,
+)
+from quant_platform.execution.models import Fill, Order, Position
+
+
+class TestOrderFSM:
+    def test_valid_transition(self):
+        order = Order(status=OrderStatus.PENDING)
+        valid, reason = validate_order_transition(order, OrderStatus.SUBMITTED)
+        assert valid
+        assert reason == ""
+
+    def test_invalid_transition(self):
+        order = Order(status=OrderStatus.FILLED)
+        valid, reason = validate_order_transition(order, OrderStatus.SUBMITTED)
+        assert not valid
+        assert "Invalid transition" in reason
+
+    def test_transition_raises_on_invalid(self):
+        order = Order(status=OrderStatus.CANCELLED)
+        with pytest.raises(ValueError, match="Invalid transition"):
+            transition_order(order, OrderStatus.SUBMITTED)
+
+    def test_transition_sets_submitted_at(self):
+        order = Order(status=OrderStatus.PENDING)
+        transition_order(order, OrderStatus.SUBMITTED)
+        assert order.status == OrderStatus.SUBMITTED
+        assert order.submitted_at is not None
+
+    def test_terminal_states(self):
+        for terminal in [OrderStatus.FILLED, OrderStatus.CANCELLED, OrderStatus.REJECTED, OrderStatus.EXPIRED]:
+            order = Order(status=terminal)
+            valid, _ = validate_order_transition(order, OrderStatus.PENDING)
+            assert not valid
+
+    def test_partial_to_filled(self):
+        order = Order(status=OrderStatus.PARTIAL)
+        transition_order(order, OrderStatus.FILLED)
+        assert order.status == OrderStatus.FILLED
+        assert order.filled_at is not None
+
+
+class TestApplyFill:
+    def test_full_fill(self):
+        order = Order(quantity=100, status=OrderStatus.SUBMITTED)
+        fill = Fill(price=10.0, quantity=100)
+        apply_fill(order, fill)
+        assert order.status == OrderStatus.FILLED
+        assert len(order.fills) == 1
+        assert order.filled_quantity == 100
+
+    def test_partial_fill(self):
+        order = Order(quantity=100, status=OrderStatus.SUBMITTED)
+        fill = Fill(price=10.0, quantity=40)
+        apply_fill(order, fill)
+        assert order.status == OrderStatus.PARTIAL
+        assert order.filled_quantity == 40
+        assert order.remaining_quantity == 60
+
+    def test_multiple_fills(self):
+        order = Order(quantity=100, status=OrderStatus.SUBMITTED)
+        apply_fill(order, Fill(price=10.0, quantity=30))
+        apply_fill(order, Fill(price=11.0, quantity=70))
+        assert order.status == OrderStatus.FILLED
+        assert order.filled_quantity == 100
+        assert order.avg_fill_price == 10.7  # (30*10 + 70*11) / 100
+
+
+class TestUpdatePosition:
+    def test_buy_updates_position(self):
+        pos = Position(ticker="600519")
+        order = Order(ticker="600519", side=OrderSide.BUY, quantity=100)
+        fill = Fill(price=150.0, quantity=100)
+        update_position(pos, order, fill)
+        assert pos.quantity == 100
+        assert pos.avg_cost == 150.0
+
+    def test_sell_realizes_pnl(self):
+        pos = Position(ticker="600519", quantity=100, avg_cost=150.0)
+        order = Order(ticker="600519", side=OrderSide.SELL, quantity=50)
+        fill = Fill(price=170.0, quantity=50)
+        update_position(pos, order, fill)
+        assert pos.quantity == 50
+        assert pos.realized_pnl == 1000.0  # (170-150)*50
+
+
+class TestExecutionEngine:
+    def test_create_order(self):
+        engine = ExecutionEngine()
+        order = engine.create_order("600519", OrderSide.BUY, 100)
+        assert order.ticker == "600519"
+        assert order.quantity == 100
+        assert order.status == OrderStatus.PENDING
+
+    def test_submit_order(self):
+        engine = ExecutionEngine()
+        order = engine.create_order("600519", OrderSide.BUY, 100)
+        engine.submit_order(order)
+        assert order.status == OrderStatus.SUBMITTED
+
+    def test_process_fill_updates_position(self):
+        engine = ExecutionEngine()
+        order = engine.create_order("600519", OrderSide.BUY, 100)
+        engine.submit_order(order)
+        engine.process_fill(order, price=150.0, quantity=100)
+        assert order.status == OrderStatus.FILLED
+        pos = engine.get_position("600519")
+        assert pos is not None
+        assert pos.quantity == 100
+
+    def test_cancel_order(self):
+        engine = ExecutionEngine()
+        order = engine.create_order("600519", OrderSide.BUY, 100)
+        engine.submit_order(order)
+        engine.cancel_order(order)
+        assert order.status == OrderStatus.CANCELLED
+
+    def test_portfolio_snapshot(self):
+        engine = ExecutionEngine()
+        o1 = engine.create_order("600519", OrderSide.BUY, 100)
+        engine.submit_order(o1)
+        engine.process_fill(o1, price=150.0, quantity=100)
+
+        snapshot = engine.portfolio_snapshot({"600519": 155.0})
+        assert snapshot["n_positions"] == 1
+        assert snapshot["total_unrealized_pnl"] == 500.0  # (155-150)*100

tests/test_strategy/test_orchestrator.py

@@ -0,0 +1,74 @@
+"""Tests for PortfolioOrchestrator."""
+
+import pandas as pd
+import pytest
+
+from quant_platform.execution.engine import ExecutionEngine, OrderSide
+from quant_platform.execution.models import OrderStatus
+from quant_platform.strategy.multi_strategy import MultiStrategyManager, StrategyConfig
+from quant_platform.strategy.portfolio_orchestrator import PortfolioOrchestrator
+
+
+@pytest.fixture
+def orch():
+    ms = MultiStrategyManager(total_capital=1_000_000)
+    sid = ms.add_strategy(StrategyConfig(
+        name="test", allocation_pct=1.0, is_active=True,
+    ))
+    engine = ExecutionEngine()
+    return PortfolioOrchestrator(ms, exec_engine=engine), sid
+
+
+class TestPortfolioOrchestrator:
+    def test_on_signal_creates_targets(self, orch):
+        o, sid = orch
+        signal = pd.Series({"A0001": 0.5, "A0002": 0.3, "A0003": 0.1})
+        o._last_prices = {"A0001": 100.0, "A0002": 50.0, "A0003": 20.0}
+        o.on_signal("2025-01-01", signal, strategy_id=sid)
+        assert len(o._targets[sid]) > 0
+
+    def test_rebalance_creates_orders(self, orch):
+        o, sid = orch
+        signal = pd.Series({"A0001": 0.5, "A0002": 0.3})
+        o._last_prices = {"A0001": 100.0, "A0002": 50.0}
+        o.on_signal("2025-01-01", signal, strategy_id=sid)
+        orders = o.rebalance()
+        assert len(orders) > 0
+        assert orders[0]["side"] == "buy"
+
+    def test_rebalance_sells_untargeted(self, orch):
+        o, sid = orch
+        # First establish a position
+        signal = pd.Series({"A0001": 0.5})
+        o._last_prices = {"A0001": 100.0}
+        o.on_signal("2025-01-01", signal, strategy_id=sid)
+        o.rebalance()
+        o.process_fills({"A0001": 100.0})
+
+        # Now signal changes — exit A0001
+        o._targets["test"] = {}
+        orders = o.rebalance()
+        sells = [o for o in orders if o["side"] == "sell"]
+        assert len(sells) > 0
+        assert sells[0]["ticker"] == "A0001"
+
+    def test_process_fills_updates_positions(self, orch):
+        o, sid = orch
+        signal = pd.Series({"A0001": 0.5})
+        o._last_prices = {"A0001": 100.0}
+        o.on_signal("2025-01-01", signal, strategy_id=sid)
+        o.rebalance()
+        o.process_fills({"A0001": 100.0})
+        pos = o.exec_engine.get_position("A0001")
+        assert pos is not None
+        assert pos.quantity > 0
+
+    def test_cash_available(self, orch):
+        o, _ = orch
+        assert o.cash_available == 1_000_000.0
+
+    def test_portfolio_summary(self, orch):
+        o, _ = orch
+        summary = o.portfolio_summary()
+        assert summary["n_positions"] == 0
+        assert "cash_available" in summary