proposa-ai/scripts/tests/test_step5_review.py

"""Step 5 新审核策略的快速回归测试（不调用真实 LLM）。"""

import unittest

from models import (
    BidOutline,
    Chapter,
    ChapterType,
    ReviewIssue,
    ScoringCriterion,
    TenderAnalysis,
)
from step5_reviewing.fixer import _Fixer
from step5_reviewing.policies import (
    dedupe_chapter_content,
    find_duplicate_info_issues,
    find_heading_score_issues,
    find_package_info_issues,
    find_rejection_filling_issues,
    find_sibling_numbering_issues,
    find_template_integrity_issues,
    remove_package_lines,
    renumber_sibling_children,
    strip_score_from_title,
)
from step5_reviewing.reviewer import _Reviewer


class FakeLlm:
    def __init__(self, response=None, error=None):
        self.response = response if response is not None else {}
        self.error = error
        self.calls = []

    def extract_json(self, **_kwargs):
        self.calls.append(_kwargs)
        if self.error:
            raise self.error
        return self.response


class HeadingFormatPolicyTests(unittest.TestCase):
    def test_scoring_heading_with_score_value_is_detected_and_cleaned(self):
        node = Chapter(
            id="4.1.1",
            title="（一）保洁作业流程（8分）",
            level=3,
            direct_scoring_bindings=["SC-1#1"],
        )
        outline = BidOutline(project_name="测试", chapters=[
            Chapter(id="4", title="基本服务方案", children=[node])
        ])

        issues = find_heading_score_issues(outline)

        self.assertEqual(len(issues), 1)
        self.assertEqual(issues[0].chapter_id, "4.1.1")
        self.assertEqual(strip_score_from_title(node.title), "（一）保洁作业流程")

    def test_duplicate_sibling_number_is_detected_and_renumbered(self):
        parent = Chapter(id="4", title="基本服务方案", level=1, children=[
            Chapter(id="4.1", title="一、保洁服务", level=2),
            Chapter(id="4.2", title="一、绿化服务", level=2),
            Chapter(id="4.3", title="二、秩序维护", level=2),
        ])
        outline = BidOutline(project_name="测试", chapters=[parent])

        issues = find_sibling_numbering_issues(outline)
        self.assertEqual(len(issues), 1)
        self.assertEqual(issues[0].chapter_id, "4")

        changed = renumber_sibling_children(parent)
        self.assertEqual(changed, 2)
        self.assertEqual(
            [child.title for child in parent.children],
            ["一、保洁服务", "二、绿化服务", "三、秩序维护"],
        )

    def test_renumbering_skips_child_level_gap(self):
        parent = Chapter(id="4", title="基本服务方案", level=1, children=[
            Chapter(id="4.1", title="一、保洁服务", level=2),
            Chapter(id="4.1.1", title="（一）保洁流程", level=3),
            Chapter(id="4.2", title="二、绿化服务", level=2),
        ])
        changed = renumber_sibling_children(parent)

        self.assertEqual(changed, 0)
        self.assertEqual(parent.children[0].title, "一、保洁服务")
        self.assertEqual(parent.children[2].title, "二、绿化服务")


class CleanupPolicyTests(unittest.TestCase):
    def test_package_lines_removed_when_project_has_no_packages(self):
        chapter = Chapter(
            id="2",
            title="投标报价",
            generated_content=(
                "报价说明\n包号：01\n服务内容：物业管理\n"
                "包件名称：无\n响应内容"
            ),
        )
        outline = BidOutline(project_name="测试", chapters=[chapter])

        issues = find_package_info_issues(outline, has_packages=False)
        self.assertEqual(len(issues), 1)
        self.assertEqual(issues[0].issue_type, "package_info")

        cleaned, removed = remove_package_lines(chapter.generated_content)
        self.assertEqual(removed, 2)
        self.assertNotIn("包号", cleaned)
        self.assertNotIn("包件", cleaned)
        self.assertIn("服务内容：物业管理", cleaned)

    def test_package_lines_kept_when_project_has_packages(self):
        chapter = Chapter(id="2", title="投标报价", generated_content="包号：01\n正文")
        outline = BidOutline(project_name="测试", chapters=[chapter])

        self.assertEqual(find_package_info_issues(outline, has_packages=True), [])

    def test_duplicate_body_lines_are_detected_and_deduplicated(self):
        duplicated = "结合本项目服务定位和采购需求制定针对性保障方案并落实各项管理措施。"
        chapter = Chapter(
            id="3",
            title="需求理解",
            generated_content=f"{duplicated}\n正文一\n{duplicated}",
        )
        outline = BidOutline(project_name="测试", chapters=[chapter])

        issues = find_duplicate_info_issues(outline)
        self.assertEqual(len(issues), 1)
        self.assertEqual(issues[0].issue_type, "duplicate_content")

        cleaned, removed = dedupe_chapter_content(chapter.generated_content)
        self.assertEqual(removed, 1)
        self.assertEqual(cleaned.count(duplicated), 1)

    def test_top_level_copied_supplement_block_is_not_flagged(self):
        child = Chapter(
            id="4.1",
            title="一、保洁作业流程",
            level=2,
            content_blocks=[{
                "order": 2,
                "block_type": "scoring_supplement",
                "target_heading_id": "4.1",
                "source_ids": ["SC-1#1"],
            }],
        )
        top = Chapter(
            id="4",
            title="基本服务方案",
            level=1,
            children=[child],
            content_blocks=[{
                "order": 2,
                "block_type": "scoring_supplement",
                "target_heading_id": "4.1",
                "source_ids": ["SC-1#1"],
            }],
        )
        outline = BidOutline(
            project_name="测试",
            chapters=[top],
            evaluation_index_entries=[{
                "entry_type": "scoring",
                "source_id": "SC-1#1",
                "criterion_id": "SC-1",
                "final_heading_id": "4.1",
            }],
        )

        self.assertEqual(find_template_integrity_issues(outline), [])


class FillingPolicyTests(unittest.TestCase):
    def test_rejection_filling_detects_missing_commitment(self):
        commitment = Chapter(
            id="1.17",
            title="十七、要求承诺函",
            level=2,
            direct_rejection_bindings=["RI-01"],
        )
        outline = BidOutline(project_name="测试", chapters=[
            Chapter(id="1", title="资格证明", children=[commitment])
        ])
        entries = [{
            "entry_type": "rejection",
            "source_id": "RI-01",
            "requirement": "投标文件必须加盖公章。",
        }]

        issues = find_rejection_filling_issues(outline, entries)

        self.assertEqual(len(issues), 1)
        self.assertEqual(issues[0].issue_type, "rejection_filling")

    def test_rejection_filling_passes_when_commitment_filled(self):
        commitment = Chapter(
            id="1.17",
            title="十七、要求承诺函",
            level=2,
            direct_rejection_bindings=["RI-01"],
            supplement_content="投标文件必须加盖公章。",
        )
        outline = BidOutline(project_name="测试", chapters=[
            Chapter(id="1", title="资格证明", children=[commitment])
        ])
        entries = [{
            "entry_type": "rejection",
            "source_id": "RI-01",
            "requirement": "投标文件必须加盖公章。",
        }]

        self.assertEqual(find_rejection_filling_issues(outline, entries), [])

    def test_fixer_writes_missing_rejections_to_bound_node(self):
        commitment = Chapter(
            id="1.17",
            title="十七、要求承诺函",
            level=2,
            direct_rejection_bindings=["RI-01", "RI-02"],
        )
        outline = BidOutline(
            project_name="测试",
            chapters=[Chapter(id="1", title="资格证明", children=[commitment])],
            evaluation_index_entries=[
                {
                    "entry_type": "rejection",
                    "source_id": "RI-01",
                    "requirement": "投标文件必须加盖公章。",
                },
                {
                    "entry_type": "rejection",
                    "source_id": "RI-02",
                    "requirement": "不得改变投标文件实质性内容。",
                },
            ],
        )
        report = type(
            "Report", (), {"issues": [ReviewIssue(
                chapter_id="1.17",
                severity="error",
                issue_type="rejection_filling",
                description="要求承诺函未完整填充废标项",
            )]}
        )()
        fixer = object.__new__(_Fixer)

        fixer._fix_rejection_filling(outline, TenderAnalysis(project_name="测试"), report)

        self.assertIn("投标文件必须加盖公章", commitment.supplement_content)
        self.assertIn("不得改变投标文件实质性内容", commitment.supplement_content)


class CriteriaCoveragePolicyTests(unittest.TestCase):
    def _outline_with_bound_scoring(self, evidence):
        node = Chapter(
            id="4.1",
            title="一、保洁作业流程",
            level=2,
            supplement_content=evidence,
            direct_scoring_bindings=["SC-1#1"],
        )
        outline = BidOutline(
            project_name="测试",
            chapters=[Chapter(id="4", title="基本服务方案", children=[node])],
            evaluation_index_entries=[{
                "entry_type": "scoring",
                "source_id": "SC-1#1",
                "criterion_id": "SC-1",
                "display_name": "保洁作业流程",
                "requirement": "流程完整、可操作",
                "final_heading_id": "4.1",
            }],
        )
        return outline

    def test_llm_reports_uncovered_bound_criterion(self):
        outline = self._outline_with_bound_scoring("已有保洁流程响应")
        reviewer = _Reviewer.__new__(_Reviewer)
        reviewer.llm = FakeLlm({"uncovered": [{"criteria_id": "SC-1", "reason": "缺少"}], "summary": "x"})

        issues = reviewer._check_criteria_coverage(
            outline,
            [ScoringCriterion("SC-1", "基本服务", "保洁作业流程", "流程完整", 8)],
        )

        self.assertEqual(len(issues), 1)
        self.assertEqual(issues[0].issue_type, "missing_criterion")
        self.assertIn("SC-1", issues[0].description)
        self.assertIn("4.1", reviewer.llm.calls[0]["user_prompt"])

    def test_llm_failure_falls_back_to_empty_bound_node_detection(self):
        outline = self._outline_with_bound_scoring("")
        reviewer = _Reviewer.__new__(_Reviewer)
        reviewer.llm = FakeLlm(error=RuntimeError("offline"))

        issues = reviewer._check_criteria_coverage(
            outline,
            [ScoringCriterion("SC-1", "基本服务", "保洁作业流程", "流程完整", 8)],
        )

        self.assertEqual(len(issues), 1)
        self.assertEqual(issues[0].issue_type, "missing_criterion")
        self.assertIn("绑定节点内容为空", issues[0].description)


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