143 lines
4.8 KiB
Python
143 lines
4.8 KiB
Python
"""Concurrency / single-writer test for IntentService (REQ-007 NFR-2/NFR-3).
|
|
|
|
Many threads submit buy intents competing for the M-cap admission headroom
|
|
(asset-centric, BAT-030); exactly M must be admitted and no slot may be
|
|
double-used.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
|
|
from trex_core.adapters.persistence.in_memory_intent_store import InMemoryIntentStore
|
|
from trex_core.application.intents import BuyIntent, IntentService
|
|
from trex_core.domain.slot import SlotService, SlotState
|
|
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository
|
|
|
|
INST = "default"
|
|
|
|
|
|
def _wire(n_assets: int, max_active: int | None):
|
|
repo = InMemorySlotRepository()
|
|
svc = SlotService(repo, instance_key=INST)
|
|
intents = IntentService(
|
|
svc, repo, InMemoryIntentStore(),
|
|
resolve_symbol=lambda pid: f"SYM-{pid}",
|
|
instance_key=INST, max_active_slots=max_active,
|
|
)
|
|
repo.reconcile_universe(INST, {f"PF-{i}": "SYM" for i in range(n_assets)})
|
|
return repo, svc, intents
|
|
|
|
|
|
def test_concurrent_buys_admit_at_most_m():
|
|
repo, svc, intents = _wire(n_assets=20, max_active=5)
|
|
|
|
results: list[str] = []
|
|
results_lock = threading.Lock()
|
|
|
|
def worker(i: int) -> None:
|
|
d = intents.submit_buy(
|
|
BuyIntent(intent_id=f"buy-{i}", qty=1, portfolio_id=f"PF-{i}")
|
|
)
|
|
with results_lock:
|
|
results.append(d.status)
|
|
|
|
threads = [threading.Thread(target=worker, args=(i,)) for i in range(20)]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
|
|
admitted = [s for s in results if s == "admitted"]
|
|
pending = [s for s in repo.list_slots(INST) if s.status is SlotState.PENDING_BUY]
|
|
# Capacity admission and transition share the same instance advisory lock.
|
|
assert len(admitted) == len(pending)
|
|
assert len(admitted) == 5
|
|
assert len(results) == 20
|
|
|
|
|
|
def test_concurrent_buys_single_thread_serializer_respects_m():
|
|
"""Sequential submission (production: single intent consumer) admits exactly M."""
|
|
repo, svc, intents = _wire(n_assets=20, max_active=5)
|
|
results = [
|
|
intents.submit_buy(BuyIntent(intent_id=f"buy-{i}", portfolio_id=f"PF-{i}")).status
|
|
for i in range(20)
|
|
]
|
|
assert results.count("admitted") == 5
|
|
assert results.count("rejected") == 15
|
|
pending = [s for s in repo.list_slots(INST) if s.status is SlotState.PENDING_BUY]
|
|
assert len(pending) == 5
|
|
|
|
|
|
def test_duplicate_intent_id_admits_once_under_concurrency():
|
|
repo, svc, intents = _wire(n_assets=5, max_active=5)
|
|
|
|
statuses: list[str] = []
|
|
lock = threading.Lock()
|
|
|
|
def worker() -> None:
|
|
d = intents.submit_buy(BuyIntent(intent_id="same-id", portfolio_id="PF-1"))
|
|
with lock:
|
|
statuses.append(d.status)
|
|
|
|
threads = [threading.Thread(target=worker) for _ in range(10)]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
|
|
# same intent_id submitted 10x concurrently -> exactly ONE slot transitioned
|
|
# (the core idempotency guarantee). Racing duplicates observe the winner's
|
|
# decision, which may still be 'processing' before finalize; never 'rejected'.
|
|
pending = [s for s in repo.list_slots(INST) if s.status is SlotState.PENDING_BUY]
|
|
assert len(pending) == 1
|
|
assert all(s in ("admitted", "processing") for s in statuses)
|
|
|
|
|
|
def test_concurrent_cached_cash_reservations_are_atomic_with_transition():
|
|
repo = InMemorySlotRepository()
|
|
svc = SlotService(repo, instance_key=INST)
|
|
repo.reconcile_universe(INST, {"PF-0": "SYM", "PF-1": "SYM"})
|
|
|
|
def cash_guard(intent: BuyIntent):
|
|
reserved = sum(
|
|
float(slot.qty or 0) * float(slot.limit_price or 0)
|
|
for slot in repo.list_slots(INST, {"pending_buy"})
|
|
)
|
|
requested = float(intent.qty or 0) * float(intent.entry_price or 0)
|
|
return None if reserved + requested <= 100 else "insufficient_snapshot_cash"
|
|
|
|
intents = IntentService(
|
|
svc,
|
|
repo,
|
|
InMemoryIntentStore(),
|
|
resolve_symbol=lambda pid: f"SYM-{pid}",
|
|
instance_key=INST,
|
|
buy_guard_fn=cash_guard,
|
|
)
|
|
results = []
|
|
result_lock = threading.Lock()
|
|
|
|
def worker(index: int) -> None:
|
|
decision = intents.submit_buy(
|
|
BuyIntent(
|
|
intent_id=f"cash-{index}",
|
|
portfolio_id=f"PF-{index}",
|
|
qty=1,
|
|
entry_price=100,
|
|
)
|
|
)
|
|
with result_lock:
|
|
results.append(decision)
|
|
|
|
threads = [threading.Thread(target=worker, args=(index,)) for index in range(2)]
|
|
for thread in threads:
|
|
thread.start()
|
|
for thread in threads:
|
|
thread.join()
|
|
|
|
assert [decision.status for decision in results].count("admitted") == 1
|
|
assert [decision.reason for decision in results].count(
|
|
"insufficient_snapshot_cash"
|
|
) == 1
|
|
assert len(repo.list_slots(INST, {"pending_buy"})) == 1
|