muse-agent-example/tests/skills/decide-candidate/test_fact_delta.py

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

模型只能提类型化增量，证据引文必须真实出现在候选正文中（不得编造证据）；
字段闭集、类型闭集、payload 合同、重复 ID 一律失败关闭。

跑法：.venv/bin/python tests/skills/decide-candidate/test_fact_delta.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"
SCRIPT_DIR = SKILLS_DIR / "decide-candidate" / "scripts"
for path in (SCRIPT_DIR, SKILLS_DIR / "assemble-context" / "scripts"):
    if str(path) not in sys.path:
        sys.path.insert(0, str(path))

from fact_delta import (  # noqa: E402
    DELTA_TYPES, FactDeltaError, validate_delta_batch, validate_delta_proposal,
)

BODY = "林深把黑纹缠上手臂，异种核心在胸腔里低鸣。何岚站在舱门口没有说话。"


def _proposal(delta_type="character_location_changed", *, delta_id="delta-1",
              payload=None, quote="异种核心在胸腔里低鸣"):
    if payload is None:
        payload = {"characterName": "林深", "toLocation": "舱室底层"}
    return {"deltaId": delta_id, "deltaType": delta_type,
            "payload": payload, "evidenceQuote": quote}


class ValidateDeltaProposalTest(unittest.TestCase):
    def test_each_delta_type_has_working_contract(self) -> None:
        cases = {
            "character_location_changed":
                ({"characterName": "林深", "toLocation": "舱室底层"}, "异种核心在胸腔里低鸣"),
            "character_knowledge_added":
                ({"characterName": "何岚", "knowledge": "林深体内有异种核心"}, "何岚站在舱门口没有说话"),
            "relationship_changed":
                ({"fromName": "林深", "toName": "何岚", "relation": "互相提防"}, "何岚站在舱门口没有说话"),
            "hook_advanced":
                ({"hookId": "hook-voice", "action": "advanced",
                  "dueWindow": {"fromChapter": 5, "toChapter": 8}}, "异种核心在胸腔里低鸣"),
            "timeline_event_added":
                ({"event": "隔离舱首次审讯结束"}, "何岚站在舱门口没有说话"),
            "setting_added":
                ({"factType": "污染规则", "text": "黑纹扩散不可逆"}, "林深把黑纹缠上手臂"),
        }
        self.assertEqual(set(cases), DELTA_TYPES)
        for delta_type, (payload, quote) in cases.items():
            with self.subTest(delta_type=delta_type):
                got = validate_delta_proposal(
                    _proposal(delta_type, payload=payload, quote=quote),
                    candidate_body=BODY, target_chapter=2)
                self.assertEqual(got["deltaType"], delta_type)
                self.assertTrue(got["subjectKey"])

    def test_subject_key_derivation(self) -> None:
        got = validate_delta_proposal(
            _proposal("relationship_changed",
                      payload={"fromName": "林深", "toName": "何岚", "relation": "同盟"},
                      quote="何岚站在舱门口没有说话"),
            candidate_body=BODY, target_chapter=2)
        self.assertEqual(got["subjectKey"], "林深→何岚")
        hook = validate_delta_proposal(
            _proposal("hook_advanced", payload={"hookId": "hook-voice", "action": "planted"},
                      quote="异种核心在胸腔里低鸣"),
            candidate_body=BODY, target_chapter=2)
        self.assertEqual(hook["subjectKey"], "hook-voice")

    def test_quote_not_found_fails_closed(self) -> None:
        with self.assertRaises(FactDeltaError) as caught:
            validate_delta_proposal(_proposal(quote="正文里不存在的句子"),
                                    candidate_body=BODY, target_chapter=2)
        self.assertEqual(caught.exception.code, "FACT_DELTA_QUOTE_NOT_FOUND")

    def test_closed_field_set_and_type_enum(self) -> None:
        extra = _proposal()
        extra["extraField"] = 1
        with self.assertRaises(FactDeltaError) as caught:
            validate_delta_proposal(extra, candidate_body=BODY, target_chapter=2)
        self.assertEqual(caught.exception.code, "FACT_DELTA_INVALID")
        bad_type = _proposal(delta_type="character_resurrected")
        with self.assertRaises(FactDeltaError) as caught:
            validate_delta_proposal(bad_type, candidate_body=BODY, target_chapter=2)
        self.assertEqual(caught.exception.code, "FACT_DELTA_TYPE_INVALID")

    def test_payload_contract_enforced_per_type(self) -> None:
        missing_field = _proposal(payload={"characterName": "林深"})  # 缺 toLocation
        with self.assertRaises(FactDeltaError):
            validate_delta_proposal(missing_field, candidate_body=BODY, target_chapter=2)
        bad_hook_action = _proposal(
            "hook_advanced", payload={"hookId": "h1", "action": "detonated"},
            quote="异种核心在胸腔里低鸣")
        with self.assertRaises(FactDeltaError):
            validate_delta_proposal(bad_hook_action, candidate_body=BODY, target_chapter=2)
        bad_due_window = _proposal(
            "hook_advanced",
            payload={"hookId": "h1", "action": "planted",
                     "dueWindow": {"fromChapter": 9, "toChapter": 3}},
            quote="异种核心在胸腔里低鸣")
        with self.assertRaises(FactDeltaError):
            validate_delta_proposal(bad_due_window, candidate_body=BODY, target_chapter=2)

    def test_batch_rejects_duplicate_ids(self) -> None:
        batch = [_proposal(delta_id="delta-1"),
                 _proposal(delta_id="delta-1", payload={"characterName": "何岚",
                                                        "toLocation": "指挥舱"})]
        with self.assertRaises(FactDeltaError) as caught:
            validate_delta_batch(batch, candidate_body=BODY, target_chapter=2)
        self.assertEqual(caught.exception.code, "FACT_DELTA_DUPLICATE_ID")
        ok = validate_delta_batch(
            [_proposal(delta_id="delta-1"),
             _proposal(delta_id="delta-2", payload={"characterName": "何岚",
                                                    "toLocation": "指挥舱"})],
            candidate_body=BODY, target_chapter=2)
        self.assertEqual([item["deltaId"] for item in ok], ["delta-1", "delta-2"])

    def test_quote_is_normalized_before_matching(self) -> None:
        # 正文里的字面转义换行（模型 JSON 双重转义）归一为真换行后再匹配，与正文合同一致
        escaped_body = BODY + "\\n舱灯闪了一下"
        got = validate_delta_proposal(
            _proposal(payload={"characterName": "林深", "toLocation": "舱室底层"},
                      quote="\n舱灯闪了一下"),
            candidate_body=escaped_body, target_chapter=2)
        self.assertEqual(got["deltaType"], "character_location_changed")
        self.assertIn("\n舱灯闪了一下", escaped_body.replace("\\n", "\n"))


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