300 lines
11 KiB
Python
300 lines
11 KiB
Python
"""REQ-116 AC-1~8: strategy 필드 노출 + strategy 필터 테스트 (BAT-055).
|
|
|
|
AC coverage:
|
|
AC-1: strategy fields present and correct when hub provides them
|
|
AC-2: safe defaults when hub does not provide strategy fields
|
|
AC-3: strategy filter — matching
|
|
AC-4: strategy filter — absent (identical to pre-REQ-116 behaviour)
|
|
AC-5: strategy + status AND combination
|
|
AC-6: available_slots invariant (not affected by strategy filter)
|
|
AC-7: orb/tsl regression — no-strategy request returns unchanged key set + values
|
|
AC-8: contract test — strategy fields present in slot row (EXPECTED row keys)
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from trex_core.application.messaging import RpcRequest
|
|
from trex_core.application.messaging_handlers import make_slots_rpc_handler
|
|
from trex_core.application.portfolio import (
|
|
InMemoryPauseStore,
|
|
PortfolioItem,
|
|
SnapshotStore,
|
|
)
|
|
from trex_core.application.watchdog import WatchdogStore
|
|
from trex_core.domain.slot import SlotService, SlotState
|
|
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository
|
|
|
|
|
|
# --------------------------------------------------------------------------- helpers
|
|
|
|
def _make_item(portfolio_id, symbol="005930", **kwargs) -> PortfolioItem:
|
|
defaults = dict(
|
|
cash_balance=1_000_000,
|
|
asset_quantity=0,
|
|
strategy_name=None,
|
|
markets=[],
|
|
strategy_params={},
|
|
)
|
|
defaults.update(kwargs)
|
|
return PortfolioItem(portfolio_id=portfolio_id, symbol=symbol, **defaults)
|
|
|
|
|
|
def _wire_strategy(items=None, *, universe=None, max_active_slots=None):
|
|
"""Build a handler with an optional universe + snapshot."""
|
|
repo = InMemorySlotRepository()
|
|
svc = SlotService(repo)
|
|
uni = universe or {"pf-A": "SYM", "pf-B": "SYM"}
|
|
repo.reconcile_universe("default", uni)
|
|
store = SnapshotStore()
|
|
store.swap(items or [
|
|
_make_item("pf-A"),
|
|
_make_item("pf-B"),
|
|
])
|
|
pause = InMemoryPauseStore()
|
|
watchdog = WatchdogStore()
|
|
handler = make_slots_rpc_handler(
|
|
repo,
|
|
snapshot_store=store,
|
|
pause_store=pause,
|
|
watchdog_store=watchdog,
|
|
max_active_slots=max_active_slots,
|
|
)
|
|
return repo, svc, store, pause, watchdog, handler
|
|
|
|
|
|
def _req(filter=None, spy=False, strategy=None):
|
|
payload: dict = {}
|
|
if filter is not None:
|
|
payload["filter"] = filter
|
|
if spy:
|
|
payload["spy"] = True
|
|
else:
|
|
payload["strategy_instance_id"] = "test-instance"
|
|
if strategy is not None:
|
|
payload["strategy"] = strategy
|
|
return RpcRequest(payload=payload, correlation_id="test-corr")
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-1
|
|
|
|
def test_ac1_strategy_fields_present_when_hub_provides_them():
|
|
"""AC-1: hub returns strategy_name/strategy_params/markets → slot row contains them."""
|
|
items = [
|
|
_make_item("pf-A",
|
|
strategy_name="tvr_v1",
|
|
strategy_params={"target_weight": 0.05},
|
|
markets=["KRX"]),
|
|
_make_item("pf-B"),
|
|
]
|
|
_, _, _, _, _, handler = _wire_strategy(items)
|
|
resp = handler(_req())
|
|
rows = {r["portfolio_id"]: r for r in resp.payload["slots"]}
|
|
|
|
row_a = rows["pf-A"]
|
|
assert row_a["strategy_name"] == "tvr_v1"
|
|
assert row_a["strategy_params"] == {"target_weight": 0.05}
|
|
assert row_a["markets"] == ["KRX"]
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-2
|
|
|
|
def test_ac2_safe_defaults_when_hub_does_not_provide_strategy_fields():
|
|
"""AC-2: hub returns no strategy fields → strategy_name=null, strategy_params={}, markets=[]."""
|
|
items = [_make_item("pf-A")] # no strategy_name / markets / strategy_params
|
|
_, _, _, _, _, handler = _wire_strategy(items)
|
|
resp = handler(_req())
|
|
row = resp.payload["slots"][0]
|
|
assert row["strategy_name"] is None
|
|
assert row["strategy_params"] == {}
|
|
assert row["markets"] == []
|
|
|
|
|
|
def test_ac2_no_snapshot_store_uses_safe_defaults():
|
|
"""AC-2 variant: snapshot_store=None → safe defaults, daemon does not crash."""
|
|
repo = InMemorySlotRepository()
|
|
repo.reconcile_universe("default", {"pf-A": "SYM"})
|
|
handler = make_slots_rpc_handler(repo) # no snapshot_store
|
|
resp = handler(_req())
|
|
row = resp.payload["slots"][0]
|
|
assert row["strategy_name"] is None
|
|
assert row["strategy_params"] == {}
|
|
assert row["markets"] == []
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-3
|
|
|
|
def test_ac3_strategy_filter_matching():
|
|
"""AC-3: strategy="tvr_v1" → only tvr_v1 slots returned."""
|
|
items = [
|
|
_make_item("pf-A", strategy_name="tvr_v1"),
|
|
_make_item("pf-B", strategy_name="orb_v1"),
|
|
]
|
|
_, _, _, _, _, handler = _wire_strategy(items)
|
|
resp = handler(_req(strategy="tvr_v1"))
|
|
rows = resp.payload["slots"]
|
|
assert len(rows) == 1
|
|
assert rows[0]["portfolio_id"] == "pf-A"
|
|
assert rows[0]["strategy_name"] == "tvr_v1"
|
|
|
|
|
|
def test_ac3_strategy_filter_no_match_returns_empty():
|
|
"""AC-3 edge: strategy value matches nothing → slots=[]."""
|
|
items = [_make_item("pf-A", strategy_name="orb_v1")]
|
|
_, _, _, _, _, handler = _wire_strategy(items)
|
|
resp = handler(_req(strategy="nonexistent"))
|
|
assert resp.payload["slots"] == []
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-4
|
|
|
|
def test_ac4_no_strategy_param_returns_all_slots():
|
|
"""AC-4: strategy absent → all slots returned, no filter applied."""
|
|
items = [
|
|
_make_item("pf-A", strategy_name="tvr_v1"),
|
|
_make_item("pf-B", strategy_name="orb_v1"),
|
|
]
|
|
_, _, _, _, _, handler = _wire_strategy(items)
|
|
resp = handler(_req()) # no strategy param
|
|
assert len(resp.payload["slots"]) == 2
|
|
|
|
|
|
def test_ac4_response_keys_unchanged_without_strategy_param():
|
|
"""AC-4: response key set unchanged when strategy not provided (additive only)."""
|
|
_, _, _, _, _, handler = _wire_strategy()
|
|
resp = handler(_req())
|
|
assert set(resp.payload.keys()) == {"slots", "available_slots", "degraded", "reason", "message"}
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-5
|
|
|
|
def test_ac5_strategy_and_status_filter_and_combination():
|
|
"""AC-5: {filter:"holding", strategy:"tvr_v1"} → only tvr_v1 + holding slots."""
|
|
items = [
|
|
_make_item("pf-A", strategy_name="tvr_v1"),
|
|
_make_item("pf-B", strategy_name="tvr_v1"),
|
|
_make_item("pf-C", strategy_name="orb_v1"),
|
|
]
|
|
repo, svc, _, _, _, handler = _wire_strategy(
|
|
items,
|
|
universe={"pf-A": "SYM", "pf-B": "SYM", "pf-C": "SYM"},
|
|
)
|
|
# Put pf-A into holding
|
|
slot_a = repo.find_slot_by_portfolio("default", "pf-A")
|
|
pending = svc.transit_slot(slot_a.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
|
reason="buy", actor="test", symbol="005930")
|
|
svc.transit_slot(pending.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING,
|
|
reason="filled", actor="test", avg_price=100.0, qty=5.0)
|
|
# pf-B stays inactive; pf-C stays inactive
|
|
|
|
resp = handler(_req(filter="holding", strategy="tvr_v1"))
|
|
rows = resp.payload["slots"]
|
|
assert len(rows) == 1
|
|
assert rows[0]["portfolio_id"] == "pf-A"
|
|
assert rows[0]["status"] == "holding"
|
|
assert rows[0]["strategy_name"] == "tvr_v1"
|
|
|
|
|
|
def test_ac5_strategy_and_status_no_match_returns_empty():
|
|
"""AC-5: AND combination yields empty when no slot satisfies both conditions."""
|
|
items = [
|
|
_make_item("pf-A", strategy_name="tvr_v1"),
|
|
]
|
|
_, _, _, _, _, handler = _wire_strategy(items)
|
|
# tvr_v1 exists but filter=holding: no holding slots
|
|
resp = handler(_req(filter="holding", strategy="tvr_v1"))
|
|
assert resp.payload["slots"] == []
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-6
|
|
|
|
def test_ac6_available_slots_invariant_with_strategy_filter():
|
|
"""AC-6: available_slots = instance-wide (M - active), not affected by strategy filter."""
|
|
items = [
|
|
_make_item("pf-A", strategy_name="tvr_v1"),
|
|
_make_item("pf-B", strategy_name="orb_v1"),
|
|
]
|
|
repo, svc, _, _, _, handler = _wire_strategy(items, max_active_slots=10)
|
|
# Put pf-A into holding (1 active overall)
|
|
slot_a = repo.find_slot_by_portfolio("default", "pf-A")
|
|
pending = svc.transit_slot(slot_a.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
|
reason="buy", actor="test", symbol="005930")
|
|
svc.transit_slot(pending.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING,
|
|
reason="filled", actor="test", avg_price=100.0, qty=5.0)
|
|
|
|
# strategy="tvr_v1" matches 1 slot (pf-A holding), but available_slots = 10-1 = 9
|
|
resp_filtered = handler(_req(strategy="tvr_v1"))
|
|
resp_all = handler(_req())
|
|
|
|
assert resp_filtered.payload["available_slots"] == 9
|
|
assert resp_all.payload["available_slots"] == 9
|
|
# Filtered slots differ but available_slots is the same
|
|
assert len(resp_filtered.payload["slots"]) == 1
|
|
assert len(resp_all.payload["slots"]) == 2
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-7
|
|
|
|
def test_ac7_orb_tsl_regression_no_strategy_param():
|
|
"""AC-7: existing orb/tsl-style request (no strategy param) unchanged behaviour.
|
|
|
|
Verifies that existing mandatory fields are present and that strategy_name /
|
|
strategy_params / markets are additive (unknown fields, safe to ignore).
|
|
"""
|
|
items = [
|
|
_make_item("pf-A", strategy_name="orb_v1",
|
|
strategy_params={"risk": 0.01}, markets=["KRX"]),
|
|
]
|
|
# universe matches items (single slot pf-A only)
|
|
_, _, _, _, _, handler = _wire_strategy(
|
|
items, universe={"pf-A": "SYM"},
|
|
)
|
|
# Legacy request: no strategy param
|
|
resp = handler(_req(filter="all", spy=True))
|
|
rows = resp.payload["slots"]
|
|
assert len(rows) == 1
|
|
row = rows[0]
|
|
|
|
# Existing fields must still be present with correct types
|
|
mandatory = {
|
|
"slot_id", "status", "symbol", "qty", "avg_price", "entry_price",
|
|
"portfolio_id", "forced_close_at", "universe_detached", "occupancy_seq",
|
|
"asset_quantity", "cash_balance", "cash_estimated", "warned",
|
|
"watchdog", "paused", "reconcile_warned",
|
|
}
|
|
for key in mandatory:
|
|
assert key in row, f"mandatory field {key!r} missing from slot row"
|
|
|
|
# Slot-origin strategy fields must NOT be present
|
|
assert "strategy_id" not in row
|
|
assert "sell_strategy_id" not in row
|
|
assert "active_strategy_id" not in row
|
|
|
|
# REQ-116 additive fields ARE present (unknown to old consumers, safe to ignore)
|
|
assert "strategy_name" in row
|
|
assert "strategy_params" in row
|
|
assert "markets" in row
|
|
|
|
|
|
# --------------------------------------------------------------------------- AC-8
|
|
|
|
def test_ac8_contract_test_strategy_fields_in_slot_row():
|
|
"""AC-8: slot row schema includes strategy_name, strategy_params, markets."""
|
|
items = [
|
|
_make_item("pf-A",
|
|
strategy_name="tvr_v1",
|
|
strategy_params={"target_weight": 0.05},
|
|
markets=["KRX", "NASDAQ"]),
|
|
]
|
|
_, _, _, _, _, handler = _wire_strategy(items)
|
|
resp = handler(_req())
|
|
row = resp.payload["slots"][0]
|
|
|
|
# AC-8: new fields present in row schema
|
|
assert "strategy_name" in row
|
|
assert "strategy_params" in row
|
|
assert "markets" in row
|
|
|
|
# Values correct
|
|
assert row["strategy_name"] == "tvr_v1"
|
|
assert row["strategy_params"] == {"target_weight": 0.05}
|
|
assert row["markets"] == ["KRX", "NASDAQ"]
|