trex-core/tests/runtime/test_cutover_rehearsal.py

"""Cutover rehearsal tests (dcy-020 / REQ-064, BAT-030 M4).

PostgreSQL-gated (TREX_POSTGRESQL_TEST_DSN) — the rehearsal the design
requires before the operator runs the live cutover: full rebuild, broker
holding carry-over, in-flight abort, unmapped abort/skip, dry-run rollback.
"""
from __future__ import annotations

import pytest

from trex_core.adapters.persistence.postgresql import PostgreSQLSlotRepository
from trex_core.domain.slot import SlotService, SlotState
from trex_core.runtime.cutover import CutoverAbort, run_cutover

INST = "default"
UNIVERSE = [("pf-a", "005930"), ("pf-b", "000660"), ("pf-c", "035720")]


def _legacy_rows(dsn):
    """Seed pre-cutover state: an old pool-ish slot + a holding slot."""
    repo = PostgreSQLSlotRepository(dsn)
    svc = SlotService(repo, instance_key=INST)
    repo.reconcile_universe(INST, {"pf-old", "pf-b"})
    held = repo.find_slot_by_portfolio(INST, "pf-b")
    svc.transit_slot(held.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
                     reason="r", actor="t", symbol="000660", qty=7.0)
    svc.transit_slot(held.slot_id, SlotState.PENDING_BUY, SlotState.HOLDING,
                     reason="r", actor="t", avg_price=100.0)
    return repo, svc


def test_full_rebuild_with_broker_carry_over(pg_clean):
    repo, _ = _legacy_rows(pg_clean)
    report = run_cutover(
        pg_clean, INST, UNIVERSE, [("000660", 12)],  # broker ground truth qty=12
    )
    assert report.deleted == 2          # pf-old + pf-b wiped
    assert report.created == 3          # one slot per universe asset
    assert report.holdings == 1
    slots = {s.portfolio_id: s for s in repo.list_slots(INST)}
    assert set(slots) == {"pf-a", "pf-b", "pf-c"}
    assert slots["pf-a"].status is SlotState.INACTIVE
    held = slots["pf-b"]
    assert held.status is SlotState.HOLDING
    assert held.qty == 12.0             # broker qty, NOT the old mirror (7)
    assert held.avg_price is None       # balance API has no cost basis (WARN)
    assert held.symbol == "000660"
    # old pf-old row is gone
    assert repo.find_slot_by_portfolio(INST, "pf-old") is None


def test_aborts_on_in_flight_pending(pg_clean):
    repo = PostgreSQLSlotRepository(pg_clean)
    svc = SlotService(repo, instance_key=INST)
    repo.reconcile_universe(INST, {"pf-a"})
    s = repo.find_slot_by_portfolio(INST, "pf-a")
    svc.transit_slot(s.slot_id, SlotState.INACTIVE, SlotState.PENDING_BUY,
                     reason="r", actor="t", symbol="005930")
    with pytest.raises(CutoverAbort, match="in-flight"):
        run_cutover(pg_clean, INST, UNIVERSE, [])
    # nothing was changed
    assert repo.fetch_slot(s.slot_id).status is SlotState.PENDING_BUY


def test_aborts_on_unmapped_broker_holding(pg_clean):
    with pytest.raises(CutoverAbort, match="outside the universe"):
        run_cutover(pg_clean, INST, UNIVERSE, [("999999", 3)])
    # DB untouched (abort happened before any write)
    repo = PostgreSQLSlotRepository(pg_clean)
    assert repo.list_slots(INST) == []


def test_allow_unmapped_skips_with_warning(pg_clean):
    report = run_cutover(
        pg_clean, INST, UNIVERSE, [("999999", 3), ("005930", 5)],
        allow_unmapped=True,
    )
    assert report.unmapped == ["999999"]
    assert report.holdings == 1  # only the mapped one carried over
    repo = PostgreSQLSlotRepository(pg_clean)
    held = repo.find_slot_by_portfolio(INST, "pf-a")
    assert held.status is SlotState.HOLDING and held.qty == 5.0


def test_dry_run_rolls_back(pg_clean):
    repo, _ = _legacy_rows(pg_clean)
    before = {s.slot_id for s in repo.list_slots(INST)}
    report = run_cutover(pg_clean, INST, UNIVERSE, [("000660", 12)], dry_run=True)
    assert report.dry_run and report.created == 3
    after = {s.slot_id for s in repo.list_slots(INST)}
    assert after == before  # rolled back — nothing changed


def test_instance_isolation_other_instance_untouched(pg_clean):
    other = PostgreSQLSlotRepository(pg_clean)
    other.reconcile_universe("inst-other", {"pf-z"})
    run_cutover(pg_clean, INST, UNIVERSE, [])
    assert other.find_slot_by_portfolio("inst-other", "pf-z") is not None


def test_promote_unique_sets_not_null(pg_clean):
    import psycopg
    run_cutover(pg_clean, INST, UNIVERSE, [], promote_unique=True)
    with psycopg.connect(pg_clean) as conn:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT is_nullable FROM information_schema.columns "
                "WHERE table_name='daily_slot' AND column_name='portfolio_id'"
            )
            assert cur.fetchone()[0] == "NO"
            # restore for other tests (pg_clean truncates but keeps schema)
            cur.execute("ALTER TABLE daily_slot ALTER COLUMN portfolio_id DROP NOT NULL")
            conn.commit()


def test_audit_rows_written(pg_clean):
    import psycopg
    run_cutover(pg_clean, INST, UNIVERSE, [("005930", 5)])
    with psycopg.connect(pg_clean) as conn:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT count(*) FROM slot_transition_log WHERE reason='cutover_rebuild'"
            )
            assert int(cur.fetchone()[0]) == 3