muse-agent-example/tests/skills/write-next-chapter/test_candidate_cas.py

#!/usr/bin/env python3
"""PostgresCasStateStore 的离线测试。

用按条件 WHERE 语义模拟 example_candidate_cas 行为的假连接，验证：
- CAS 竞争（旧 token / 重复建链）失败关闭；
- transition/start_next 的守卫与 token 递增；
- 该存储可直接替换 InMemoryCasStateStore 驱动 run_writer_pipeline 全链。

跑法（仓库根目录）：.venv/bin/python tests/skills/write-next-chapter/test_candidate_cas.py
"""

from __future__ import annotations

import copy
import pathlib
import sys
import unittest

PROJECT_ROOT = pathlib.Path(__file__).resolve().parents[3]
SKILLS_DIR = PROJECT_ROOT / ".claude" / "skills"
TEST_DIR = PROJECT_ROOT / "tests" / "skills" / "write-next-chapter"
CHECK_TEST_DIR = PROJECT_ROOT / "tests" / "skills" / "check-content-consistency"
SCRIPT_DIR = SKILLS_DIR / "write-next-chapter" / "scripts"
DETECT_DIR = SKILLS_DIR / "check-content-consistency" / "scripts"
READ_CONTEXT_DIR = SKILLS_DIR / "assemble-context" / "scripts"
for path in (READ_CONTEXT_DIR, DETECT_DIR, SCRIPT_DIR, TEST_DIR, CHECK_TEST_DIR):
    if str(path) not in sys.path:
        sys.path.insert(0, str(path))

from candidate_cas import PostgresCasStateStore  # noqa: E402
from run_writer_pipeline import CasToken, PipelineError, run_writer_pipeline  # noqa: E402
from run_writer_semantic_detector import canonical_sha256  # noqa: E402
from test_check_writer_candidate import _candidate_body, _requirements, _valid_pair  # noqa: E402
from test_run_writer_pipeline import _semantic_pass, _writer_output  # noqa: E402
from writer_contract import build_candidate_envelope, retrieval_identity  # noqa: E402


class FakeCursor:
    """携带 rowcount 的最小游标。"""

    def __init__(self, rowcount: int = 0, row: tuple | None = None) -> None:
        self.rowcount = rowcount
        self._row = row

    def fetchone(self):
        return self._row


class FakeCasConnection:
    """按条件 WHERE 语义模拟 example_candidate_cas 的短事务连接。

    只模拟条件匹配的「行计数」事实（匹配则更新并计数 1，不匹配计数 0），
    不重复实现 DB 触发器的迁移方向约束——那是 DB 集成测试的职责。
    """

    def __init__(self, rows: dict) -> None:
        self._rows = rows
        self._snapshot = copy.deepcopy(rows)

    def __enter__(self):
        return self

    def __exit__(self, *_):
        return False

    def commit(self) -> None:
        self._snapshot = copy.deepcopy(self._rows)

    def rollback(self) -> None:
        self._rows = copy.deepcopy(self._snapshot)

    def execute(self, sql: str, params=()):
        text = " ".join(sql.split())
        if text.startswith("INSERT INTO example_candidate_cas"):
            run_id, work_id, chapter, attempt, version, creator, updater = params
            if run_id in self._rows:
                return FakeCursor(rowcount=0)
            self._rows[run_id] = {
                "work_id": work_id, "target_chapter": chapter, "attempt": attempt,
                "candidate_version": version, "state": "DRAFT", "revision": 1,
                "deleted": False,
            }
            return FakeCursor(rowcount=1)
        if text.startswith("UPDATE example_candidate_cas SET state=%s"):
            state, updater, run_id, revision, old_state, attempt, version = params
            row = self._rows.get(run_id)
            if not self._match(row, run_id, revision, old_state, attempt, version):
                return FakeCursor(rowcount=0)
            row["state"] = state
            row["revision"] += 1
            return FakeCursor(rowcount=1)
        if text.startswith("UPDATE example_candidate_cas SET state='DRAFT'"):
            attempt, version, updater, run_id, revision, old_attempt, old_version = params
            row = self._rows.get(run_id)
            if not self._match(row, run_id, revision, "REJECTED", old_attempt, old_version):
                return FakeCursor(rowcount=0)
            row["state"] = "DRAFT"
            row["attempt"] = attempt
            row["candidate_version"] = version
            row["revision"] += 1
            return FakeCursor(rowcount=1)
        if text.startswith("SELECT run_id, attempt, candidate_version, state, revision"):
            (run_id,) = params
            row = self._rows.get(run_id)
            if row is None or row["deleted"]:
                return FakeCursor(row=None)
            return FakeCursor(row=(run_id, row["attempt"], row["candidate_version"],
                                   row["state"], row["revision"]))
        raise AssertionError(f"未预期的 SQL: {text}")

    @staticmethod
    def _match(row, run_id, revision, state, attempt, version) -> bool:
        return (
            row is not None
            and not row["deleted"]
            and row["revision"] == revision
            and row["state"] == state
            and row["attempt"] == attempt
            and row["candidate_version"] == version
        )


def _store(rows: dict, **kwargs) -> PostgresCasStateStore:
    """注入共享行表与假连接的被测存储。"""

    return PostgresCasStateStore(connect=lambda **_kw: FakeCasConnection(rows), **kwargs)


class PostgresCasStateStoreTest(unittest.TestCase):
    def test_create_then_latest_returns_draft_token(self) -> None:
        rows: dict = {}
        store = _store(rows)
        token = store.create("run-1", attempt=1, candidate_version=1)
        self.assertEqual(token, CasToken("run-1", 1, 1, "DRAFT", 1))
        self.assertEqual(store.latest("run-1"), token)

    def test_create_twice_same_run_fails_closed(self) -> None:
        rows: dict = {}
        store = _store(rows)
        store.create("run-1", attempt=1, candidate_version=1)
        with self.assertRaises(PipelineError) as caught:
            store.create("run-1", attempt=1, candidate_version=1)
        self.assertEqual(caught.exception.code, "CAS_CONFLICT")

    def test_transition_requires_exact_expected_token(self) -> None:
        rows: dict = {}
        store = _store(rows)
        draft = store.create("run-1", attempt=1, candidate_version=1)
        checking = store.transition(draft, "CHECKING")
        self.assertEqual(checking, CasToken("run-1", 1, 1, "CHECKING", 2))
        # 旧 token 重放：revision 已前进，条件不命中，返回 None
        self.assertIsNone(store.transition(draft, "CHECKING"))
        # 非法方向同样不命中（fake 只模拟条件匹配）
        self.assertIsNone(store.transition(checking, "DRAFT"))

    def test_start_next_guards_monotonic_identity(self) -> None:
        rows: dict = {}
        store = _store(rows)
        draft = store.create("run-1", attempt=1, candidate_version=1)
        checking = store.transition(draft, "CHECKING")
        rejected = store.transition(checking, "REJECTED")
        # 非递增的 attempt / candidate_version 一律拒绝
        self.assertIsNone(store.start_next(rejected, attempt=1, candidate_version=2))
        self.assertIsNone(store.start_next(rejected, attempt=2, candidate_version=1))
        self.assertIsNone(store.start_next(checking, attempt=2, candidate_version=2))
        next_draft = store.start_next(rejected, attempt=2, candidate_version=2)
        self.assertEqual(next_draft, CasToken("run-1", 2, 2, "DRAFT", 4))
        # 旧 REJECTED token 重放失败
        self.assertIsNone(store.start_next(rejected, attempt=3, candidate_version=3))

    def test_latest_missing_run_returns_none(self) -> None:
        self.assertIsNone(_store({}).latest("no-such-run"))


def _advance_context(context: dict, attempt: int) -> dict:
    advanced = copy.deepcopy(context)
    advanced["attempt"] = attempt
    advanced["factEvidence"].append({
        "evidenceId": f"fact-gap-{attempt}",
        "fact": "补充证据",
        "sourceType": "canonical_state",
        "sourceRef": {"sourceId": "state:gap", "sourceVersion": "v1"},
        "contentSha256": "sha256:" + "4" * 64,
        "riskLevel": "low",
    })
    advanced["contextSnapshot"]["contextSha256"] = retrieval_identity(advanced)
    return advanced


class PipelineOnPostgresStoreTest(unittest.TestCase):
    """用持久存储驱动完整 pipeline，证明协议兼容与补证环行为不变。"""

    def test_full_pipeline_passes_with_postgres_store(self) -> None:
        context, _ = _valid_pair()
        rows: dict = {}
        result = run_writer_pipeline(
            context=context,
            requirements=_requirements(),
            writer=lambda current, version: _writer_output(current, version),
            evidence_provider=lambda *_args: self.fail("无 gap 不得补证"),
            semantic_detector=_semantic_pass,
            state_store=_store(rows),
        )
        self.assertEqual(result["status"], "PASSED")
        self.assertEqual(result["candidateArtifact"]["schemaVersion"], "candidate-envelope-v2")
        chain = rows[context["runId"]]
        self.assertEqual(chain["state"], "PASSED")
        self.assertEqual(chain["revision"], 3)  # create→CHECKING→PASSED

    def test_pipeline_evidence_loop_uses_start_next(self) -> None:
        context, _ = _valid_pair()
        rows: dict = {}

        def detector(current: dict, candidate: dict, _mechanical: dict) -> dict:
            if candidate["candidateVersion"] == 1:
                report = {
                    "schemaVersion": "semantic-detection-v3",
                    "runId": current["runId"], "sampleId": "cas-sample",
                    "opaqueArmId": "cas-candidate", "inputSha256": "sha256:" + "1" * 64,
                    "candidateVersion": candidate["candidateVersion"],
                    "candidateSha256": candidate["candidateSha256"],
                    "contextSnapshotSha256": current["contextSnapshot"]["contextSha256"],
                    "modelReceiptSha256": "sha256:" + "2" * 64, "status": "needs_evidence",
                    "claims": [], "findings": [], "assertionVerdicts": [],
                    "hardConstraintVerdicts": [], "newSettingCandidates": [],
                    "evidenceGaps": [{
                        "gapId": "gap-1", "query": "补证", "reason": "缺口", "priority": "high",
                        "candidateSha256": candidate["candidateSha256"],
                        "candidateQuote": "旧徽章", "startCodePoint": 11, "endCodePoint": 14,
                    }],
                }
                report["reportSha256"] = canonical_sha256(report)
                return report
            return _semantic_pass(current, candidate, _mechanical)

        result = run_writer_pipeline(
            context=context,
            requirements=_requirements(),
            writer=lambda current, version: _writer_output(current, version),
            evidence_provider=lambda current, _gaps, attempt: _advance_context(current, attempt),
            semantic_detector=detector,
            state_store=_store(rows),
        )
        self.assertEqual(result["status"], "PASSED")
        chain = rows[context["runId"]]
        # create→CHECKING→REJECTED→新DRAFT→CHECKING→PASSED
        self.assertEqual((chain["state"], chain["revision"], chain["attempt"],
                          chain["candidate_version"]), ("PASSED", 6, 2, 2))


if __name__ == "__main__":
    unittest.main()