genichinandClaude Opus 4.8
97d58318db
Implement REQ-011~015 (dcy-003): the order-execution layer on top of the BAT-002 slot-core daemon, connecting intents to real orders. - application: BrokerPort (submit/poll_fill/cancel) + ExecutionService (claim -> submit -> poll -> transition -> rollback -> reconcile) - adapters/broker: PaperBroker (deterministic async double) and KISBroker (KIS Open API: token, order-cash, inquire-daily-ccld, cancel; VTS sandbox tr_ids; live account gated behind allow_live) - persistence: option-A execution queue (find_pending_for_dispatch FOR UPDATE SKIP LOCKED, mark_dispatched idempotency guard, clear_dispatch) - runtime: background execution loop in the daemon lifespan + startup reconcile; config selects paper|kis Verification (real KIS VTS 모의투자 + PostgreSQL): 92 passed, ruff clean, domain import sweep shows zero broker/web/db deps, buy->holding / sell->closed / reject->idle, idempotent dispatch (exactly one order), reconcile after crash creates no duplicate order, KIS sandbox token+submit round-trip, and a daemon E2E through the background loop. Align the four baseline docs. BAT-004 -> release-candidate; REQ-011~015 -> Implemented. KIS live-account go-live, partial-fill accrual, option-B outbox, connection pooling, and the safety floor remain deferred to follow-up Discoveries. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
91 lines
3.8 KiB
Python
91 lines
3.8 KiB
Python
"""Order execution loop tests via paper broker (REQ-013, REQ-014).
|
|
|
|
In-memory adapters; deterministic paper double drives the full async path.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from datetime import date
|
|
|
|
from trex_core.adapters.broker.paper import PaperBroker
|
|
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, SellIntent
|
|
from trex_core.domain.slot import SlotService, SlotState
|
|
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository
|
|
|
|
DAY = date(2026, 6, 4)
|
|
|
|
|
|
def _wire(broker):
|
|
repo = InMemorySlotRepository()
|
|
svc = SlotService(repo)
|
|
intents = IntentService(svc, repo, InMemoryIntentStore())
|
|
execution = ExecutionService(svc, repo, broker)
|
|
svc.preallocate_daily_slots(DAY, 5)
|
|
return repo, svc, intents, execution
|
|
|
|
|
|
def _buy(intents, iid="b1", symbol="005930", qty=10):
|
|
return intents.submit_buy(BuyIntent(intent_id=iid, trading_date=DAY, symbol=symbol, qty=qty, entry_price=1000))
|
|
|
|
|
|
def test_buy_lifecycle_to_holding():
|
|
repo, svc, intents, execution = _wire(PaperBroker(fill_after_polls=0))
|
|
d = _buy(intents)
|
|
sid = d.slot_id
|
|
assert repo.fetch_slot(sid).status is SlotState.PENDING_BUY
|
|
execution.run_once() # dispatch + poll(fill immediately)
|
|
slot = repo.fetch_slot(sid)
|
|
assert slot.status is SlotState.HOLDING and slot.qty == 10 and slot.avg_price == 1000.0
|
|
|
|
|
|
def test_buy_dispatch_is_idempotent_no_double_order():
|
|
broker = PaperBroker(fill_after_polls=5) # stays accepted (not filled) across ticks
|
|
repo, svc, intents, execution = _wire(broker)
|
|
sid = _buy(intents).slot_id
|
|
execution.run_once() # dispatch (1 order) + poll(accepted)
|
|
bid1 = repo.fetch_slot(sid).broker_order_id
|
|
execution.run_once() # must NOT re-dispatch
|
|
bid2 = repo.fetch_slot(sid).broker_order_id
|
|
assert bid1 == bid2 and len(broker._orders) == 1 # exactly one broker order
|
|
|
|
|
|
def test_buy_reject_rolls_back_to_idle():
|
|
repo, svc, intents, execution = _wire(PaperBroker(reject_symbols={"005930"}))
|
|
sid = _buy(intents).slot_id
|
|
execution.run_once() # dispatch + poll(reject)
|
|
slot = repo.fetch_slot(sid)
|
|
assert slot.status is SlotState.IDLE and slot.symbol is None and slot.broker_order_id is None
|
|
|
|
|
|
def test_sell_lifecycle_to_closed_bumps_entry_count():
|
|
repo, svc, intents, execution = _wire(PaperBroker(fill_after_polls=0))
|
|
sid = _buy(intents).slot_id
|
|
execution.run_once() # -> holding
|
|
assert repo.fetch_slot(sid).status is SlotState.HOLDING
|
|
intents.submit_sell(SellIntent(intent_id="s1", slot_id=sid))
|
|
assert repo.fetch_slot(sid).status is SlotState.PENDING_SELL
|
|
execution.run_once() # dispatch sell + fill -> closed
|
|
assert repo.fetch_slot(sid).status is SlotState.CLOSED
|
|
assert svc.get_today_entry_count(DAY, "005930") == 0 # +1 happens on closed->idle recovery
|
|
|
|
|
|
def test_reconcile_after_crash_completes_fill_without_redispatch():
|
|
broker = PaperBroker(fill_after_polls=1)
|
|
repo, svc, intents, execution = _wire(broker)
|
|
sid = _buy(intents).slot_id
|
|
execution.run_once() # dispatch + poll1 (accepted, not filled) — simulates crash here
|
|
assert repo.fetch_slot(sid).status is SlotState.PENDING_BUY
|
|
orders_before = len(broker._orders)
|
|
execution.reconcile() # restart: re-poll -> fills, no new order
|
|
slot = repo.fetch_slot(sid)
|
|
assert slot.status is SlotState.HOLDING
|
|
assert len(broker._orders) == orders_before # reconcile did not submit a new order
|
|
|
|
|
|
def test_no_idle_slots_blocks_further_buys():
|
|
repo, svc, intents, execution = _wire(PaperBroker(fill_after_polls=0))
|
|
for i in range(5):
|
|
assert _buy(intents, iid=f"b{i}").status == "admitted"
|
|
assert _buy(intents, iid="overflow").status == "rejected"
|