132 lines
4.8 KiB
Python
132 lines
4.8 KiB
Python
"""Slot transition event emission tests (REQ-021 + REQ-023 + REQ-018 hook)."""
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
import time
|
|
from datetime import date
|
|
|
|
from trex_core.adapters.broker.paper import PaperBroker
|
|
from trex_core.adapters.ledger.in_memory import InMemoryLedger
|
|
from trex_core.adapters.messaging import topology
|
|
from trex_core.adapters.messaging.in_memory import InMemoryTransport
|
|
from trex_core.adapters.persistence.in_memory_intent_store import InMemoryIntentStore
|
|
from trex_core.application.execution import ExecutionService
|
|
from trex_core.application.intents import BuyIntent, IntentService
|
|
from trex_core.application.ledger_outbox import InMemoryLedgerOutbox, LedgerWriter
|
|
from trex_core.application.messaging_handlers import slot_transition_event_payload
|
|
from trex_core.domain.slot import SlotService, SlotState
|
|
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository
|
|
|
|
DAY = date(2026, 6, 5)
|
|
|
|
|
|
def _wire(transport):
|
|
repo = InMemorySlotRepository()
|
|
svc = SlotService(repo)
|
|
intents = IntentService(svc, repo, InMemoryIntentStore())
|
|
outbox = InMemoryLedgerOutbox()
|
|
ledger = InMemoryLedger()
|
|
writer = LedgerWriter(outbox, ledger)
|
|
svc.preallocate_daily_slots(DAY, 3)
|
|
|
|
def emitter(event_type: str, slot) -> None:
|
|
rk = topology.event_routing_key(event_type, slot.strategy_id or "_", slot.symbol or "_")
|
|
payload = slot_transition_event_payload(slot, event_type=event_type)
|
|
try:
|
|
transport.publish_event(rk, payload)
|
|
except Exception: # noqa: BLE001
|
|
pass
|
|
|
|
execution = ExecutionService(svc, repo, PaperBroker(fill_after_polls=0),
|
|
ledger_outbox=outbox, event_emitter=emitter)
|
|
return repo, svc, intents, execution, writer
|
|
|
|
|
|
def test_fill_emits_slot_filled_event_with_routing_key_and_state():
|
|
transport = InMemoryTransport()
|
|
received: list[tuple[str, dict]] = []
|
|
stop = threading.Event()
|
|
th = threading.Thread(
|
|
target=transport.consume_events_forever,
|
|
args=("trex.events.strategy.A", topology.strategy_event_binding_pattern("A"),
|
|
lambda rk, p: received.append((rk, p)), stop),
|
|
daemon=True,
|
|
)
|
|
th.start()
|
|
time.sleep(0.05)
|
|
|
|
repo, _, intents, execution, _ = _wire(transport)
|
|
intents.submit_buy(BuyIntent(
|
|
intent_id="b1", trading_date=DAY, symbol="005930", qty=10,
|
|
strategy_id="A", portfolio_id="PF-1",
|
|
))
|
|
execution.run_once()
|
|
time.sleep(0.05)
|
|
stop.set()
|
|
th.join(timeout=1.0)
|
|
|
|
assert len(received) == 1
|
|
rk, payload = received[0]
|
|
assert rk == "slot_filled_buy.A.005930"
|
|
# payload carries current state + monotonic sequence (REQ-023 AC-5)
|
|
assert payload["event_type"] == "slot_filled_buy"
|
|
assert payload["status"] == SlotState.HOLDING.value
|
|
assert payload["strategy_id"] == "A"
|
|
assert payload["symbol"] == "005930"
|
|
assert "sequence_at" in payload # last-wins ordering token
|
|
|
|
|
|
def test_event_for_strategy_a_does_not_reach_strategy_b_queue():
|
|
"""REQ-021 AC-4: per-strategy routing key binding filters at the broker."""
|
|
transport = InMemoryTransport()
|
|
received_a: list[tuple[str, dict]] = []
|
|
received_b: list[tuple[str, dict]] = []
|
|
stop = threading.Event()
|
|
th_a = threading.Thread(
|
|
target=transport.consume_events_forever,
|
|
args=("q.A", topology.strategy_event_binding_pattern("A"),
|
|
lambda rk, p: received_a.append((rk, p)), stop),
|
|
daemon=True,
|
|
)
|
|
th_b = threading.Thread(
|
|
target=transport.consume_events_forever,
|
|
args=("q.B", topology.strategy_event_binding_pattern("B"),
|
|
lambda rk, p: received_b.append((rk, p)), stop),
|
|
daemon=True,
|
|
)
|
|
th_a.start()
|
|
th_b.start()
|
|
time.sleep(0.05)
|
|
|
|
_, _, intents, execution, _ = _wire(transport)
|
|
intents.submit_buy(BuyIntent(
|
|
intent_id="b1", trading_date=DAY, symbol="005930", qty=10,
|
|
strategy_id="A", portfolio_id="PF-1",
|
|
))
|
|
execution.run_once()
|
|
time.sleep(0.05)
|
|
stop.set()
|
|
th_a.join(timeout=1.0)
|
|
th_b.join(timeout=1.0)
|
|
|
|
assert any(rk == "slot_filled_buy.A.005930" for rk, _ in received_a)
|
|
assert received_b == []
|
|
|
|
|
|
def test_publish_failure_does_not_break_execution_loop():
|
|
"""Publish errors must NOT roll back slot transitions or ledger enqueue."""
|
|
transport = InMemoryTransport()
|
|
transport.set_available(False) # all publishes will raise TransportUnavailableError
|
|
|
|
repo, _, intents, execution, _ = _wire(transport)
|
|
intents.submit_buy(BuyIntent(
|
|
intent_id="b1", trading_date=DAY, symbol="005930", qty=10,
|
|
strategy_id="A", portfolio_id="PF-1",
|
|
))
|
|
r = execution.run_once()
|
|
# Slot still transitioned; ledger still enqueued.
|
|
assert r.filled == 1
|
|
assert r.ledger_enqueued == 1
|
|
pending = [s for s in repo.list_slots(DAY) if s.status is SlotState.HOLDING]
|
|
assert len(pending) == 1
|