feat(strategy-state): persist instance-scoped slot maps
This commit is contained in:
Hermes Agent
@@ -155,8 +155,10 @@ def test_cancel_attempt_reservation_is_compare_and_set(pg_clean):
|
||||
assert repo.fetch_slot(decision.slot_id).cancel_state == "requested"
|
||||
|
||||
|
||||
# dcy-028 / REQ-079·081 (BAT-042): strategy-state store + occupancy_seq column
|
||||
# REQ-0009: slot-scoped strategy-instance state map.
|
||||
def test_strategy_state_store_pg(pg_clean):
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from trex_core.adapters.persistence.postgresql import PgStrategyStateStore
|
||||
from trex_core.application import strategy_state as ss
|
||||
|
||||
@@ -169,31 +171,30 @@ def test_strategy_state_store_pg(pg_clean):
|
||||
reason="buy", actor="t")
|
||||
svc.transit_slot(slot.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING,
|
||||
reason="filled", actor="t", qty=10, avg_price=100)
|
||||
# occupancy_seq persisted
|
||||
held = repo.fetch_slot(slot.slot_id)
|
||||
assert held.occupancy_seq == 1
|
||||
|
||||
# first-create
|
||||
r1 = store.set(slot.slot_id, "tsl_v1", expected_version=0,
|
||||
expected_occupancy_seq=1, data="peak", current_occupancy_seq=1,
|
||||
slot_active=True)
|
||||
r1 = store.set(slot.slot_id, "instance-a", expected_version=0, data="peak", slot_active=True)
|
||||
assert r1.ok and r1.version == 1
|
||||
# version conflict
|
||||
r2 = store.set(slot.slot_id, "tsl_v1", expected_version=0,
|
||||
expected_occupancy_seq=1, data="stale", current_occupancy_seq=1,
|
||||
slot_active=True)
|
||||
r2 = store.set(slot.slot_id, "instance-a", expected_version=0, data="stale", slot_active=True)
|
||||
assert not r2.ok and r2.reason == ss.REASON_VERSION_CONFLICT
|
||||
# batched read
|
||||
got = store.get_for_slots([slot.slot_id], {slot.slot_id: 1})
|
||||
assert got[slot.slot_id]["tsl_v1"].data == "peak"
|
||||
missing = store.set(slot.slot_id, "instance-missing", expected_version=1, data="stale", slot_active=True)
|
||||
assert not missing.ok and missing.reason == ss.REASON_VERSION_CONFLICT and missing.version == 0
|
||||
store.set(slot.slot_id, "instance-b", expected_version=0, data="other", slot_active=True)
|
||||
got = store.get_for_slots([slot.slot_id])
|
||||
assert got[slot.slot_id]["instance-a"].data == "peak"
|
||||
assert got[slot.slot_id]["instance-b"].data == "other"
|
||||
|
||||
with ThreadPoolExecutor(max_workers=2) as executor:
|
||||
writes = list(executor.map(
|
||||
lambda item: store.set(slot.slot_id, item, expected_version=0, data=item, slot_active=True),
|
||||
("instance-c", "instance-d"),
|
||||
))
|
||||
assert all(write.ok for write in writes)
|
||||
assert {"instance-c", "instance-d"} <= set(store.get_for_slots([slot.slot_id])[slot.slot_id])
|
||||
|
||||
# close deletes state (C-3)
|
||||
svc.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL,
|
||||
reason="sell", actor="t")
|
||||
svc.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE,
|
||||
reason="sold", actor="t")
|
||||
assert store.get_for_slots([slot.slot_id], {slot.slot_id: 1}) == {}
|
||||
# reuse bumps occupancy_seq
|
||||
assert store.get_for_slots([slot.slot_id])[slot.slot_id]["instance-a"].version == 1
|
||||
reused = svc.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
||||
reason="buy", actor="t")
|
||||
assert reused.occupancy_seq == 2
|
||||
|
||||
@@ -107,7 +107,7 @@ def test_apply_cash_estimate_overlays_pending_delta():
|
||||
repo = InMemorySlotRepository()
|
||||
repo.reconcile_universe("default", {"PF-1": "SYM"})
|
||||
handler = make_slots_rpc_handler(repo, snapshot_store=store, ledger_outbox=outbox)
|
||||
resp = handler(RpcRequest(payload={"filter": "all"}, correlation_id="test"))
|
||||
resp = handler(RpcRequest(payload={"filter": "all", "strategy_instance_id": "test-instance"}, correlation_id="test"))
|
||||
slots = resp.payload["slots"]
|
||||
pf1 = next(s for s in slots if s["portfolio_id"] == "PF-1")
|
||||
assert pf1["cash_estimated"] is True
|
||||
|
||||
@@ -693,7 +693,7 @@ def _wire_with_warn(warned_slot_ids=None):
|
||||
|
||||
|
||||
def _req(filter=None):
|
||||
return RpcRequest(payload={"filter": filter or "all"}, correlation_id="t")
|
||||
return RpcRequest(payload={"filter": filter or "all", "spy": True}, correlation_id="t")
|
||||
|
||||
|
||||
# REQ-104 AC-5: reconcile_warned=True for warned slot
|
||||
@@ -756,7 +756,7 @@ def test_slots_rpc_existing_warned_field_unchanged():
|
||||
reason="filled", actor="test", avg_price=100.0, qty=10.0)
|
||||
warn_store = InMemoryReconcileWarningStore()
|
||||
handler = make_slots_rpc_handler(repo, snapshot_store=store, warn_store=warn_store)
|
||||
resp = handler(RpcRequest(payload={"filter": "holding"}, correlation_id="t"))
|
||||
resp = handler(RpcRequest(payload={"filter": "holding", "spy": True}, correlation_id="t"))
|
||||
row = resp.payload["slots"][0]
|
||||
# slot.qty=10 != hub asset_quantity=5 => warned=True (existing field)
|
||||
assert row["warned"] is True
|
||||
|
||||
@@ -43,6 +43,8 @@ def _req(filter=None, spy=False):
|
||||
payload["filter"] = filter
|
||||
if spy:
|
||||
payload["spy"] = True
|
||||
else:
|
||||
payload["strategy_instance_id"] = "test-instance"
|
||||
return RpcRequest(payload=payload, correlation_id="test-corr")
|
||||
|
||||
|
||||
|
||||
@@ -74,6 +74,7 @@ def _make_handler(repo, warn_store, snapshot_items=None):
|
||||
|
||||
def _req(filter=None):
|
||||
payload = {}
|
||||
payload["spy"] = True
|
||||
if filter:
|
||||
payload["filter"] = filter
|
||||
return RpcRequest(payload=payload, correlation_id="test")
|
||||
|
||||
@@ -67,6 +67,8 @@ def _req(filter=None, spy=False, strategy=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")
|
||||
|
||||
@@ -1,93 +1,60 @@
|
||||
"""slots.req read piggyback of strategy_state + occupancy_seq (dcy-028 C-1).
|
||||
|
||||
REQ-073 AC-7 / REQ-074 AC-6 / S-1: each slot row carries occupancy_seq and,
|
||||
when present, a strategy_state map assembled from the store in one batched read.
|
||||
strategy_* reasoning fields remain absent.
|
||||
"""
|
||||
"""Strategy and operator strategy-state visibility contracts for slots.req."""
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
from trex_core.application.messaging import RpcRequest
|
||||
from trex_core.application.messaging_handlers import make_slots_rpc_handler
|
||||
from trex_core.application.strategy_state import InMemoryStrategyStateStore
|
||||
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
|
||||
|
||||
INST = "default"
|
||||
|
||||
|
||||
def _wire():
|
||||
repo = InMemorySlotRepository()
|
||||
store = InMemoryStrategyStateStore()
|
||||
service = SlotService(repo, instance_key=INST, strategy_state_store=store)
|
||||
repo.reconcile_universe(INST, {"pf-0": "SYM"})
|
||||
slot = repo.list_slots(INST)[0]
|
||||
service.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
||||
reason="buy", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING,
|
||||
reason="filled", actor="t", qty=10, avg_price=100)
|
||||
handler = make_slots_rpc_handler(repo, instance_key=INST,
|
||||
strategy_state_store=store)
|
||||
return repo, store, service, slot, handler
|
||||
repo, store, watchdog = InMemorySlotRepository(), InMemoryStrategyStateStore(), WatchdogStore()
|
||||
service = SlotService(repo)
|
||||
repo.reconcile_universe("default", {"pf": "SYM"})
|
||||
slot = repo.list_slots("default")[0]
|
||||
service.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY, reason="buy", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING, reason="fill", actor="t", qty=1, avg_price=1)
|
||||
store.set(slot.slot_id, "instance-a", expected_version=0, data="a", slot_active=True)
|
||||
store.set(slot.slot_id, "instance-b", expected_version=0, data="b", slot_active=True)
|
||||
return slot, store, watchdog, make_slots_rpc_handler(repo, strategy_state_store=store, watchdog_store=watchdog)
|
||||
|
||||
|
||||
def _rows(handler):
|
||||
return handler(RpcRequest(payload={}, correlation_id="c")).payload["slots"]
|
||||
def _call(handler, payload):
|
||||
return handler(RpcRequest(payload=payload, correlation_id="c")).payload
|
||||
|
||||
|
||||
def test_row_carries_occupancy_seq():
|
||||
_, _, _, slot, handler = _wire()
|
||||
row = _rows(handler)[0]
|
||||
assert row["occupancy_seq"] == 1
|
||||
def test_strategy_receives_only_exact_requested_entry():
|
||||
_, _, _, handler = _wire()
|
||||
payload = _call(handler, {"strategy_instance_id": "instance-a"})
|
||||
state = payload["slots"][0]["strategy_state"]
|
||||
assert state["data"] == "a" and set(state) == {"version", "data", "updated_at"}
|
||||
assert "instance-b" not in repr(payload)
|
||||
|
||||
|
||||
def test_row_carries_strategy_state_when_present():
|
||||
_, store, _, slot, handler = _wire()
|
||||
store.set(slot.slot_id, "tsl_v1", expected_version=0, expected_occupancy_seq=1,
|
||||
data='{"peak":100}', current_occupancy_seq=1, slot_active=True)
|
||||
row = _rows(handler)[0]
|
||||
assert "strategy_state" in row
|
||||
assert row["strategy_state"]["tsl_v1"]["version"] == 1
|
||||
assert row["strategy_state"]["tsl_v1"]["data"] == '{"peak":100}'
|
||||
assert "updated_at" in row["strategy_state"]["tsl_v1"]
|
||||
|
||||
|
||||
def test_row_omits_strategy_state_when_absent():
|
||||
_, _, _, _, handler = _wire()
|
||||
row = _rows(handler)[0]
|
||||
def test_strategy_omits_absent_entry():
|
||||
_, _, _, handler = _wire()
|
||||
row = _call(handler, {"strategy_instance_id": "absent"})["slots"][0]
|
||||
assert "strategy_state" not in row
|
||||
|
||||
|
||||
def test_no_strategy_reasoning_fields():
|
||||
"""REQ-074 AC-5 (REQ-116 additive 재도입 후에도 유지): slot-origin strategy fields absent.
|
||||
|
||||
strategy_params / strategy_name / markets are now present (REQ-116 PortfolioItem-origin);
|
||||
slot-origin strategy_id / sell_strategy_id / active_strategy_id remain absent.
|
||||
"""
|
||||
_, store, _, slot, handler = _wire()
|
||||
store.set(slot.slot_id, "tsl_v1", expected_version=0, expected_occupancy_seq=1,
|
||||
data="x", current_occupancy_seq=1, slot_active=True)
|
||||
row = _rows(handler)[0]
|
||||
# slot-origin fields must be absent (REQ-074 AC-5 unchanged)
|
||||
for k in ("strategy_id", "sell_strategy_id", "active_strategy_id"):
|
||||
assert k not in row
|
||||
# PortfolioItem-origin fields now present (REQ-116 additive)
|
||||
assert "strategy_params" in row # {} (safe default, no snapshot_store)
|
||||
assert "strategy_name" in row # None
|
||||
assert "markets" in row # []
|
||||
@pytest.mark.parametrize("identity", [None, "", False, 1, []])
|
||||
def test_malformed_strategy_request_has_exact_safe_envelope(identity):
|
||||
_, _, watchdog, handler = _wire()
|
||||
assert _call(handler, {"strategy_instance_id": identity}) == {
|
||||
"slots": [], "available_slots": None, "degraded": False,
|
||||
"reason": "bad_request:strategy_instance_id",
|
||||
"message": "strategy_instance_id must be a non-empty string",
|
||||
}
|
||||
assert watchdog.last_seen("unused") is None
|
||||
|
||||
|
||||
def test_reused_slot_shows_no_state():
|
||||
"""After a full close + reuse cycle, no prior-occupancy state surfaces
|
||||
(close-delete + read-side occupancy filter). occupancy_seq advances to 2."""
|
||||
repo, store, service, slot, handler = _wire()
|
||||
store.set(slot.slot_id, "tsl_v1", expected_version=0, expected_occupancy_seq=1,
|
||||
data="old", current_occupancy_seq=1, slot_active=True)
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL,
|
||||
reason="sell", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE,
|
||||
reason="sold", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
||||
reason="buy", actor="t") # occupancy_seq -> 2
|
||||
row = _rows(handler)[0]
|
||||
assert row["occupancy_seq"] == 2
|
||||
assert "strategy_state" not in row
|
||||
def test_operator_without_or_with_id_receives_full_map_without_watchdog_update():
|
||||
slot, _, watchdog, handler = _wire()
|
||||
for payload in ({"spy": True}, {"spy": True, "strategy_instance_id": "instance-a"}):
|
||||
state = _call(handler, payload)["slots"][0]["strategy_state"]
|
||||
assert set(state) == {"instance-a", "instance-b"}
|
||||
assert watchdog.last_seen(str(slot.slot_id)) is None
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
"""strategy_state.set write RPC handler tests (dcy-028 / REQ-080, BAT-042).
|
||||
|
||||
Covers the full reject reason set + success + bad_request, with the handler
|
||||
supplying the slot's current occupancy_seq / active-ness to the store CAS.
|
||||
"""
|
||||
"""strategy_state.set strategy-instance wire contract tests."""
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
from trex_core.application import strategy_state as ss
|
||||
from trex_core.application.messaging import RpcRequest
|
||||
from trex_core.application.messaging_handlers import make_strategy_state_set_handler
|
||||
@@ -12,109 +10,41 @@ from trex_core.application.strategy_state import InMemoryStrategyStateStore
|
||||
from trex_core.domain.slot import SlotService, SlotState
|
||||
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository
|
||||
|
||||
INST = "default"
|
||||
|
||||
|
||||
def _wire():
|
||||
repo = InMemorySlotRepository()
|
||||
store = InMemoryStrategyStateStore()
|
||||
service = SlotService(repo, instance_key=INST, strategy_state_store=store)
|
||||
repo.reconcile_universe(INST, {"pf-0": "SYM"})
|
||||
slot = repo.list_slots(INST)[0]
|
||||
# activate to holding (occupancy_seq -> 1)
|
||||
service.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
||||
reason="buy", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING,
|
||||
reason="filled", actor="t", qty=10, avg_price=100)
|
||||
handler = make_strategy_state_set_handler(repo, store)
|
||||
return repo, store, service, slot, handler
|
||||
repo, store = InMemorySlotRepository(), InMemoryStrategyStateStore()
|
||||
service = SlotService(repo)
|
||||
repo.reconcile_universe("default", {"pf": "SYM"})
|
||||
slot = repo.list_slots("default")[0]
|
||||
service.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY, reason="buy", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING, reason="fill", actor="t", qty=1, avg_price=1)
|
||||
return repo, store, service, slot, make_strategy_state_set_handler(repo, store)
|
||||
|
||||
|
||||
def _req(slot_id, *, ev=0, eo=1, data="peak", strat="tsl_v1"):
|
||||
return RpcRequest(payload={
|
||||
"slot_id": str(slot_id), "strategy_id": strat,
|
||||
"expected_version": ev, "expected_occupancy_seq": eo, "data": data,
|
||||
}, correlation_id=f"{slot_id}:{strat}:{ev}")
|
||||
def _req(slot_id, instance="instance-a", version=0, data="state"):
|
||||
return RpcRequest(payload={"slot_id": str(slot_id), "strategy_instance_id": instance, "expected_version": version, "data": data}, correlation_id="same-correlation-id")
|
||||
|
||||
|
||||
def test_first_write_ok():
|
||||
def test_write_uses_instance_identity_and_entry_cas():
|
||||
_, _, _, slot, handler = _wire()
|
||||
resp = handler(_req(slot.slot_id, ev=0))
|
||||
assert resp.payload["ok"] is True and resp.payload["version"] == 1
|
||||
assert handler(_req(slot.slot_id)).payload == {"ok": True, "slot_id": str(slot.slot_id), "strategy_instance_id": "instance-a", "version": 1}
|
||||
conflict = handler(_req(slot.slot_id, version=0, data="stale")).payload
|
||||
assert conflict["reason"] == ss.REASON_VERSION_CONFLICT and conflict["version"] == 1
|
||||
|
||||
|
||||
def test_version_conflict():
|
||||
_, _, _, slot, handler = _wire()
|
||||
handler(_req(slot.slot_id, ev=0)) # version -> 1
|
||||
resp = handler(_req(slot.slot_id, ev=0, data="stale"))
|
||||
assert resp.payload["ok"] is False
|
||||
assert resp.payload["reason"] == ss.REASON_VERSION_CONFLICT
|
||||
assert resp.payload["version"] == 1
|
||||
@pytest.mark.parametrize("identity", [None, "", 1, True, []])
|
||||
def test_malformed_instance_id_is_rejected_without_write(identity):
|
||||
_, store, _, slot, handler = _wire()
|
||||
response = handler(_req(slot.slot_id, identity)).payload
|
||||
assert response["ok"] is False
|
||||
assert response["reason"].startswith("bad_request:")
|
||||
assert store.get_for_slots([slot.slot_id]) == {}
|
||||
|
||||
|
||||
def test_occupancy_changed():
|
||||
_, _, _, slot, handler = _wire()
|
||||
# daemon read occupancy 0 (before activation) but slot is occupancy 1 now
|
||||
resp = handler(_req(slot.slot_id, ev=0, eo=0))
|
||||
assert resp.payload["ok"] is False
|
||||
assert resp.payload["reason"] == ss.REASON_OCCUPANCY_CHANGED
|
||||
assert resp.payload["occupancy_seq"] == 1
|
||||
|
||||
|
||||
def test_slot_inactive():
|
||||
def test_inactive_and_oversize_writes_do_not_change_existing_entry():
|
||||
repo, store, service, slot, handler = _wire()
|
||||
# close the slot
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL,
|
||||
reason="sell", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE,
|
||||
reason="sold", actor="t")
|
||||
resp = handler(_req(slot.slot_id, ev=0, eo=1))
|
||||
assert resp.payload["ok"] is False
|
||||
assert resp.payload["reason"] == ss.REASON_SLOT_INACTIVE
|
||||
|
||||
|
||||
def test_unknown_slot_is_slot_inactive():
|
||||
from uuid import uuid4
|
||||
_, _, _, _, handler = _wire()
|
||||
resp = handler(_req(uuid4(), ev=0, eo=1))
|
||||
assert resp.payload["ok"] is False
|
||||
assert resp.payload["reason"] == ss.REASON_SLOT_INACTIVE
|
||||
|
||||
|
||||
def test_state_too_large():
|
||||
_, _, _, slot, handler = _wire()
|
||||
big = "a" * (ss._STATE_CAP_BYTES + 1)
|
||||
resp = handler(_req(slot.slot_id, ev=0, data=big))
|
||||
assert resp.payload["ok"] is False
|
||||
assert resp.payload["reason"] == ss.REASON_STATE_TOO_LARGE
|
||||
|
||||
|
||||
def test_bad_request_missing_field():
|
||||
_, _, _, slot, handler = _wire()
|
||||
resp = handler(RpcRequest(payload={"slot_id": str(slot.slot_id)},
|
||||
correlation_id="c"))
|
||||
assert resp.payload["ok"] is False
|
||||
assert resp.payload["reason"].startswith("bad_request:")
|
||||
|
||||
|
||||
def test_bad_request_non_string_data():
|
||||
_, _, _, slot, handler = _wire()
|
||||
resp = handler(RpcRequest(payload={
|
||||
"slot_id": str(slot.slot_id), "strategy_id": "tsl_v1",
|
||||
"expected_version": 0, "expected_occupancy_seq": 1, "data": 123,
|
||||
}, correlation_id="c"))
|
||||
assert resp.payload["ok"] is False
|
||||
assert resp.payload["reason"].startswith("bad_request:")
|
||||
|
||||
|
||||
def test_reason_set_is_enumerated():
|
||||
"""All non-ok reasons must be within the documented set (REQ-080 AC-6)."""
|
||||
allowed_prefixes = {
|
||||
ss.REASON_OCCUPANCY_CHANGED, ss.REASON_VERSION_CONFLICT,
|
||||
ss.REASON_SLOT_INACTIVE, ss.REASON_STATE_TOO_LARGE, "bad_request",
|
||||
}
|
||||
_, _, _, slot, handler = _wire()
|
||||
handler(_req(slot.slot_id, ev=0))
|
||||
bad = handler(_req(slot.slot_id, ev=0, data="x")) # version_conflict
|
||||
reason = bad.payload["reason"].split(":")[0]
|
||||
assert reason in allowed_prefixes
|
||||
handler(_req(slot.slot_id))
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL, reason="sell", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE, reason="sold", actor="t")
|
||||
assert handler(_req(slot.slot_id, version=1)).payload["reason"] == ss.REASON_SLOT_INACTIVE
|
||||
assert store.get_for_slots([slot.slot_id])[slot.slot_id]["instance-a"].version == 1
|
||||
|
||||
@@ -1,118 +1,53 @@
|
||||
"""InMemoryStrategyStateStore CAS tests (dcy-028 / REQ-079, BAT-042).
|
||||
|
||||
Covers the 6 CAS outcomes (occupancy+version commit / version_conflict /
|
||||
occupancy_changed / slot_inactive / state_too_large / first-create), idempotent
|
||||
re-send, batched read with stale-occupancy filtering, and delete-on-close.
|
||||
"""
|
||||
"""Slot-scoped strategy-instance state store contract tests."""
|
||||
from __future__ import annotations
|
||||
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
|
||||
from trex_core.application import strategy_state as ss
|
||||
from trex_core.application.strategy_state import InMemoryStrategyStateStore
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def store():
|
||||
return InMemoryStrategyStateStore()
|
||||
|
||||
|
||||
def _set(store, slot_id, *, ev=0, eo=1, data="x", cur_occ=1, active=True, strat="tsl_v1"):
|
||||
def _set(store, slot_id, instance="instance-a", *, version=0, data="x", active=True):
|
||||
return store.set(
|
||||
slot_id, strat,
|
||||
expected_version=ev, expected_occupancy_seq=eo, data=data,
|
||||
current_occupancy_seq=cur_occ, slot_active=active,
|
||||
slot_id, instance, expected_version=version, data=data, slot_active=active
|
||||
)
|
||||
|
||||
|
||||
class TestCas:
|
||||
def test_first_create(self, store):
|
||||
sid = uuid4()
|
||||
r = _set(store, sid, ev=0, eo=1, cur_occ=1, data='{"peak":100}')
|
||||
assert r.ok and r.version == 1
|
||||
|
||||
def test_commit_increments_version(self, store):
|
||||
sid = uuid4()
|
||||
_set(store, sid, ev=0)
|
||||
r = _set(store, sid, ev=1, data="next")
|
||||
assert r.ok and r.version == 2
|
||||
|
||||
def test_version_conflict_does_not_store(self, store):
|
||||
sid = uuid4()
|
||||
_set(store, sid, ev=0, data="first") # version=1
|
||||
r = _set(store, sid, ev=0, data="stale") # expects 0, stored 1
|
||||
assert not r.ok and r.reason == ss.REASON_VERSION_CONFLICT and r.version == 1
|
||||
# original preserved
|
||||
got = store.get_for_slots([sid], {sid: 1})[sid]["tsl_v1"]
|
||||
assert got.data == "first" and got.version == 1
|
||||
|
||||
def test_occupancy_changed_does_not_store(self, store):
|
||||
sid = uuid4()
|
||||
# daemon read occupancy_seq=1 but slot is now occupancy 2
|
||||
r = _set(store, sid, ev=0, eo=1, cur_occ=2)
|
||||
assert not r.ok and r.reason == ss.REASON_OCCUPANCY_CHANGED and r.occupancy_seq == 2
|
||||
assert store.get_for_slots([sid], {sid: 2}) == {}
|
||||
|
||||
def test_slot_inactive_does_not_store(self, store):
|
||||
sid = uuid4()
|
||||
r = _set(store, sid, ev=0, active=False)
|
||||
assert not r.ok and r.reason == ss.REASON_SLOT_INACTIVE
|
||||
assert store.get_for_slots([sid], {sid: 1}) == {}
|
||||
|
||||
def test_state_too_large(self, store, monkeypatch):
|
||||
sid = uuid4()
|
||||
big = "a" * (ss._STATE_CAP_BYTES + 1)
|
||||
r = _set(store, sid, ev=0, data=big)
|
||||
assert not r.ok and r.reason == ss.REASON_STATE_TOO_LARGE
|
||||
|
||||
def test_idempotent_resend_is_conflict_not_double_apply(self, store):
|
||||
sid = uuid4()
|
||||
r1 = _set(store, sid, ev=0, data="v1") # -> version 1
|
||||
assert r1.ok and r1.version == 1
|
||||
# re-send identical expected_version=0 -> rejected (already advanced)
|
||||
r2 = _set(store, sid, ev=0, data="v1")
|
||||
assert not r2.ok and r2.reason == ss.REASON_VERSION_CONFLICT
|
||||
def test_entry_versions_are_isolated():
|
||||
store, slot_id = InMemoryStrategyStateStore(), uuid4()
|
||||
assert _set(store, slot_id, "a", data="a1").version == 1
|
||||
assert _set(store, slot_id, "b", data="b1").version == 1
|
||||
assert _set(store, slot_id, "a", version=1, data="a2").version == 2
|
||||
entries = store.get_for_slots([slot_id])[slot_id]
|
||||
assert entries["a"].version == 2 and entries["a"].data == "a2"
|
||||
assert entries["b"].version == 1 and entries["b"].data == "b1"
|
||||
assert not hasattr(entries["a"], "strategy_id")
|
||||
assert not hasattr(entries["a"], "occupancy_seq")
|
||||
|
||||
|
||||
class TestAbaGuard:
|
||||
def test_turnover_first_write_rejected(self, store):
|
||||
"""dcy-028 R-1 / S-4: read v0 of occupancy 1, slot reused as occupancy 2,
|
||||
stale write against occupancy 1 must not bind to occupancy 2."""
|
||||
sid = uuid4()
|
||||
# occupancy 2 is current; daemon computed against occupancy 1 (eo=1)
|
||||
r = _set(store, sid, ev=0, eo=1, cur_occ=2, data="stale-peak")
|
||||
assert not r.ok and r.reason == ss.REASON_OCCUPANCY_CHANGED
|
||||
# new occupancy starts clean
|
||||
assert store.get_for_slots([sid], {sid: 2}) == {}
|
||||
def test_conflict_inactive_and_size_limit_preserve_entries(monkeypatch):
|
||||
store, slot_id = InMemoryStrategyStateStore(), uuid4()
|
||||
_set(store, slot_id, "a", data="saved")
|
||||
assert _set(store, slot_id, "a", data="stale").reason == ss.REASON_VERSION_CONFLICT
|
||||
assert _set(store, slot_id, "b", active=False).reason == ss.REASON_SLOT_INACTIVE
|
||||
assert _set(store, slot_id, "b", data="x" * (ss._STATE_CAP_BYTES + 1)).reason == ss.REASON_STATE_TOO_LARGE
|
||||
entries = store.get_for_slots([slot_id])[slot_id]
|
||||
assert set(entries) == {"a"} and entries["a"].data == "saved"
|
||||
|
||||
|
||||
class TestBatchedRead:
|
||||
def test_get_for_slots_groups_by_slot_and_strategy(self, store):
|
||||
a, b = uuid4(), uuid4()
|
||||
_set(store, a, ev=0, cur_occ=1, strat="tsl_v1", data="A")
|
||||
_set(store, a, ev=0, cur_occ=1, strat="buy_v1", data="A2")
|
||||
_set(store, b, ev=0, cur_occ=1, strat="tsl_v1", data="B")
|
||||
out = store.get_for_slots([a, b], {a: 1, b: 1})
|
||||
assert set(out[a]) == {"tsl_v1", "buy_v1"}
|
||||
assert out[a]["tsl_v1"].data == "A"
|
||||
assert out[b]["tsl_v1"].data == "B"
|
||||
|
||||
def test_stale_occupancy_entries_invisible(self, store):
|
||||
sid = uuid4()
|
||||
_set(store, sid, ev=0, cur_occ=1, data="old") # stored at occupancy 1
|
||||
# slot is now occupancy 2 -> the occupancy-1 entry must not surface
|
||||
assert store.get_for_slots([sid], {sid: 2}) == {}
|
||||
|
||||
def test_empty_slot_ids(self, store):
|
||||
assert store.get_for_slots([], {}) == {}
|
||||
def test_concurrent_different_entries_both_survive():
|
||||
store, slot_id = InMemoryStrategyStateStore(), uuid4()
|
||||
with ThreadPoolExecutor(max_workers=2) as executor:
|
||||
results = list(executor.map(lambda key: _set(store, slot_id, key, data=key), ("a", "b")))
|
||||
assert all(result.ok for result in results)
|
||||
assert set(store.get_for_slots([slot_id])[slot_id]) == {"a", "b"}
|
||||
|
||||
|
||||
class TestDelete:
|
||||
def test_delete_all_removes_every_strategy(self, store):
|
||||
sid = uuid4()
|
||||
_set(store, sid, ev=0, strat="tsl_v1")
|
||||
_set(store, sid, ev=0, strat="buy_v1")
|
||||
store.delete_all(sid)
|
||||
assert store.get_for_slots([sid], {sid: 1}) == {}
|
||||
def test_same_entry_competing_cas_has_one_winner():
|
||||
store, slot_id = InMemoryStrategyStateStore(), uuid4()
|
||||
_set(store, slot_id, "a", data="first")
|
||||
with ThreadPoolExecutor(max_workers=2) as executor:
|
||||
results = list(executor.map(lambda data: _set(store, slot_id, "a", version=1, data=data), ("x", "y")))
|
||||
assert sum(result.ok for result in results) == 1
|
||||
assert store.get_for_slots([slot_id])[slot_id]["a"].version == 2
|
||||
|
||||
@@ -1,120 +1,23 @@
|
||||
"""Slot occupancy_seq bump + close-delete hook (dcy-028 / REQ-081, BAT-042).
|
||||
|
||||
S-3: every close path (→INACTIVE) deletes the slot's strategy_state and a reused
|
||||
slot starts with a new occupancy_seq + empty state. occupancy_seq is stable
|
||||
across one holding episode and bumps on inactive→pending_buy.
|
||||
"""
|
||||
"""Slot occupancy remains intact while strategy state survives close/reopen."""
|
||||
from __future__ import annotations
|
||||
|
||||
from trex_core.application.strategy_state import InMemoryStrategyStateStore
|
||||
from trex_core.domain.slot import SlotService, SlotState
|
||||
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository
|
||||
|
||||
INST = "default"
|
||||
|
||||
|
||||
def _seed(repo):
|
||||
repo.reconcile_universe(INST, {"pf-0": "SYM"})
|
||||
return repo.list_slots(INST)[0]
|
||||
|
||||
|
||||
def _service(repo, store=None):
|
||||
return SlotService(repo, instance_key=INST, strategy_state_store=store)
|
||||
|
||||
|
||||
def _activate_to_holding(service, slot_id):
|
||||
service.transit_slot(slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
||||
reason="buy", actor="t")
|
||||
return service.transit_slot(slot_id, SlotState.PENDING_BUY, SlotState.HOLDING,
|
||||
reason="filled", actor="t", qty=10, avg_price=100)
|
||||
|
||||
|
||||
class TestOccupancySeq:
|
||||
def test_bumps_on_inactive_to_pending_buy(self):
|
||||
repo = InMemorySlotRepository()
|
||||
service = _service(repo)
|
||||
slot = _seed(repo)
|
||||
assert slot.occupancy_seq == 0
|
||||
updated = service.transit_slot(
|
||||
slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
|
||||
reason="buy", actor="t")
|
||||
assert updated.occupancy_seq == 1
|
||||
|
||||
def test_stable_across_holding_episode(self):
|
||||
repo = InMemorySlotRepository()
|
||||
service = _service(repo)
|
||||
slot = _seed(repo)
|
||||
held = _activate_to_holding(service, slot.slot_id)
|
||||
assert held.occupancy_seq == 1
|
||||
sold = service.transit_slot(slot.slot_id, SlotState.HOLDING,
|
||||
SlotState.PENDING_SELL, reason="sell", actor="t")
|
||||
assert sold.occupancy_seq == 1 # unchanged within the episode
|
||||
|
||||
def test_increments_on_reuse(self):
|
||||
repo = InMemorySlotRepository()
|
||||
service = _service(repo)
|
||||
slot = _seed(repo)
|
||||
_activate_to_holding(service, slot.slot_id)
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL,
|
||||
reason="sell", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE,
|
||||
reason="sold", actor="t")
|
||||
# reuse: occupancy_seq bumps from 1 to 2
|
||||
reused = service.transit_slot(slot.slot_id, SlotState.INACTIVE,
|
||||
SlotState.PENDING_BUY, reason="buy", actor="t")
|
||||
assert reused.occupancy_seq == 2
|
||||
|
||||
|
||||
class TestCloseDelete:
|
||||
def _setup(self):
|
||||
repo = InMemorySlotRepository()
|
||||
store = InMemoryStrategyStateStore()
|
||||
service = _service(repo, store)
|
||||
slot = _seed(repo)
|
||||
_activate_to_holding(service, slot.slot_id)
|
||||
# daemon writes state during holding (occupancy_seq=1)
|
||||
store.set(slot.slot_id, "tsl_v1", expected_version=0,
|
||||
expected_occupancy_seq=1, data="peak", current_occupancy_seq=1,
|
||||
slot_active=True)
|
||||
assert store.get_for_slots([slot.slot_id], {slot.slot_id: 1})
|
||||
return repo, store, service, slot
|
||||
|
||||
def test_sell_fill_close_deletes_state(self):
|
||||
repo, store, service, slot = self._setup()
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL,
|
||||
reason="sell", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE,
|
||||
reason="sold", actor="t")
|
||||
assert store.get_for_slots([slot.slot_id], {slot.slot_id: 1}) == {}
|
||||
|
||||
def test_reused_slot_starts_empty_with_new_occupancy(self):
|
||||
repo, store, service, slot = self._setup()
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL,
|
||||
reason="sell", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE,
|
||||
reason="sold", actor="t")
|
||||
reused = service.transit_slot(slot.slot_id, SlotState.INACTIVE,
|
||||
SlotState.PENDING_BUY, reason="buy", actor="t")
|
||||
assert reused.occupancy_seq == 2
|
||||
assert store.get_for_slots([slot.slot_id], {slot.slot_id: 2}) == {}
|
||||
|
||||
def test_error_close_path_also_deletes(self):
|
||||
repo, store, service, slot = self._setup()
|
||||
# holding → error → inactive (operator resolve) also clears state
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.ERROR,
|
||||
reason="err", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.ERROR, SlotState.INACTIVE,
|
||||
reason="resolve", actor="t")
|
||||
assert store.get_for_slots([slot.slot_id], {slot.slot_id: 1}) == {}
|
||||
|
||||
def test_no_store_injected_is_noop(self):
|
||||
# backward-compat: service without store does not raise on close
|
||||
repo = InMemorySlotRepository()
|
||||
service = _service(repo, store=None)
|
||||
slot = _seed(repo)
|
||||
_activate_to_holding(service, slot.slot_id)
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL,
|
||||
reason="sell", actor="t")
|
||||
out = service.transit_slot(slot.slot_id, SlotState.PENDING_SELL,
|
||||
SlotState.INACTIVE, reason="sold", actor="t")
|
||||
assert out.status is SlotState.INACTIVE
|
||||
def test_close_preserves_state_and_reopen_continues_version():
|
||||
repo, store = InMemorySlotRepository(), InMemoryStrategyStateStore()
|
||||
service = SlotService(repo, strategy_state_store=store)
|
||||
repo.reconcile_universe("default", {"pf": "SYM"})
|
||||
slot = repo.list_slots("default")[0]
|
||||
service.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY, reason="buy", actor="t")
|
||||
service.transit_slot(slot.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING, reason="fill", actor="t", qty=1, avg_price=1)
|
||||
assert store.set(slot.slot_id, "instance", expected_version=0, data="old", slot_active=True).version == 1
|
||||
service.transit_slot(slot.slot_id, SlotState.HOLDING, SlotState.PENDING_SELL, reason="sell", actor="t")
|
||||
inactive = service.transit_slot(slot.slot_id, SlotState.PENDING_SELL, SlotState.INACTIVE, reason="sold", actor="t")
|
||||
assert inactive.occupancy_seq == 1
|
||||
assert store.get_for_slots([slot.slot_id])[slot.slot_id]["instance"].data == "old"
|
||||
reopened = service.transit_slot(slot.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY, reason="buy", actor="t")
|
||||
assert reopened.occupancy_seq == 2
|
||||
assert store.set(slot.slot_id, "instance", expected_version=1, data="new", slot_active=True).version == 2
|
||||
|
||||
Reference in New Issue
Block a user