fix: resolve conflicts for issue 330 (master refresh)

2026-07-07 05:21:43 -04:00
parent 94b022b24d 897d256f98
commit e9fdb356dd
7 changed files with 905 additions and 4 deletions
@@ -121,4 +121,10 @@ def test_start_issue_template_references_work_issue_workflow():
 def test_create_issue_final_report_verifier_exported():
    from review_proofs import assess_create_issue_final_report

-    assert callable(assess_create_issue_final_report)
+    assert callable(assess_create_issue_final_report)
+
+
+def test_non_mergeable_skip_verifier_exported():
+    from review_proofs import assess_non_mergeable_skip_proof
+
+    assert callable(assess_non_mergeable_skip_proof)
@@ -0,0 +1,91 @@
+"""Doc-contract checks for queue-status report verifier (#339)."""
+import unittest
+
+from review_proofs import assess_queue_status_report, build_final_report
+
+BAD_QUEUE_STATUS_REPORT = """
+## PR Queue Status
+
+Loaded workflows/review-merge-pr.md. Inventory complete because gitea_list_prs
+returned 6 open PRs, fewer than the default Gitea page size.
+
+PR #286 skipped: prior diagnostic worktree simulation showed merge conflicts.
+Live blocker proof for all skipped PRs.
+
+All open PRs are conflicted or blocked. Blockers: none.
+
+## Controller Handoff
+
+- Task: review queue status
+- Repo: Scaled-Tech-Consulting/Gitea-Tools
+- Role: reviewer
+- Identity: reviewer1 / prgs-reviewer
+- Selected PR: none
+- Inventory pagination proof: assumed complete (6 < 50)
+- Already-landed gate: passed
+- Author-safety result: passed
+- Merge preflight: passed
+- Review worktree used: false
+- Review worktree dirty before validation: false
+- Blockers: none
+- Current status: queue inspected; no PR selected
+"""
+
+
+class TestQueueStatusReport(unittest.TestCase):
+    def test_bad_fixture_fails_closed(self):
+        result = assess_queue_status_report(BAD_QUEUE_STATUS_REPORT)
+        self.assertFalse(result["proven"])
+        self.assertTrue(result["block"])
+        self.assertTrue(result["queue_status_only"])
+        joined = " ".join(result["violations"]).lower()
+        self.assertIn("already-landed gate", joined)
+        self.assertIn("author-safety", joined)
+        self.assertIn("merge preflight", joined)
+        self.assertIn("prior diagnostic", joined)
+        self.assertIn("blockers", joined)
+
+    def test_passes_with_not_applicable_gates(self):
+        report = """
+## Controller Handoff
+- Selected PR: none
+- Inventory pagination proof: is_final_page: true, has_more: false
+- Already-landed gate: not applicable
+- Author-safety result: not run
+- Merge preflight: not applicable
+- Review worktree used: false
+- Review worktree dirty before validation: not applicable
+- Blockers: all PRs skipped pending reviewer
+"""
+        result = assess_queue_status_report(report)
+        self.assertTrue(result["proven"])
+
+    def test_rejects_passed_gates_without_selected_pr(self):
+        report = """
+## Controller Handoff
+- Selected PR: none
+- Already-landed gate: passed
+- Blockers: PR #1 conflicted
+"""
+        result = assess_queue_status_report(report)
+        self.assertFalse(result["proven"])
+        self.assertIn("already-landed gate", " ".join(result["violations"]).lower())
+
+    def test_build_final_report_downgrades_bad_queue_status(self):
+        report = build_final_report(
+            {"proven": True},
+            {"complete": True},
+            {"claimable": True, "verdict": "strong"},
+            {"status": "clean"},
+            True,
+            False,
+            True,
+            report_text=BAD_QUEUE_STATUS_REPORT,
+        )
+        self.assertEqual(report["grade"], "downgraded")
+        self.assertFalse(report["queue_status_report_proven"])
+        self.assertTrue(report["queue_status_violations"])
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -24,6 +24,7 @@ from review_proofs import (  # noqa: E402
    ISSUE_SELECTION_CONTINUATION_EXPLICIT,
    ISSUE_SELECTION_REPRESENTED_BY_OPEN_PR,
    assess_author_pr_report,
+    assess_reviewer_baseline_validation_proof,
    assess_capability_evidence,
    assess_capability_proof,
    assess_contradictory_no_pr_claim,
@@ -2160,5 +2161,125 @@ class TestCreateIssueFinalReport(unittest.TestCase):
        self.assertTrue(result["downgraded"])


+class TestReviewerBaselineValidationProof(unittest.TestCase):
+    """Issue #325: baseline validation must use branches/ worktrees."""
+
+    ROOT = "/repo/Gitea-Tools"
+
+    def _good_baseline_proof(self, **overrides):
+        proof = {
+            "worktree_path": f"{self.ROOT}/branches/baseline-master-pr280",
+            "baseline_target_sha": PINNED,
+            "pr_head_sha": OTHER,
+            "baseline_failures": ["tests/test_foo.py::test_bar"],
+            "pr_failures": ["tests/test_foo.py::test_bar"],
+            "failure_signatures_match": True,
+            "clean_before": True,
+            "clean_after": True,
+        }
+        proof.update(overrides)
+        return proof
+
+    def test_main_checkout_test_run_blocks(self):
+        result = assess_reviewer_baseline_validation_proof(
+            validation_runs=[
+                {
+                    "command": "venv/bin/pytest tests/",
+                    "working_directory": self.ROOT,
+                    "project_root": self.ROOT,
+                }
+            ],
+            project_root=self.ROOT,
+        )
+        self.assertFalse(result["proven"])
+        self.assertTrue(result["block"])
+        self.assertTrue(result["violations"])
+
+    def test_branches_worktree_test_run_passes(self):
+        result = assess_reviewer_baseline_validation_proof(
+            validation_runs=[
+                {
+                    "command": "venv/bin/pytest tests/",
+                    "working_directory": f"{self.ROOT}/branches/review-pr-280",
+                    "project_root": self.ROOT,
+                }
+            ],
+            project_root=self.ROOT,
+        )
+        self.assertTrue(result["proven"])
+
+    def test_preexisting_claim_without_baseline_proof_fails(self):
+        result = assess_reviewer_baseline_validation_proof(
+            report_text=(
+                "Validation: full-suite failures are pre-existing on master."
+            ),
+            project_root=self.ROOT,
+        )
+        self.assertFalse(result["proven"])
+        self.assertTrue(result["claims_preexisting"])
+
+    def test_preexisting_claim_with_complete_baseline_proof_passes(self):
+        result = assess_reviewer_baseline_validation_proof(
+            report_text="Failures are pre-existing on master.",
+            baseline_proof=self._good_baseline_proof(),
+            project_root=self.ROOT,
+        )
+        self.assertTrue(result["proven"])
+
+    def test_mismatched_failures_block_preexisting_claim(self):
+        result = assess_reviewer_baseline_validation_proof(
+            report_text="Same as master.",
+            baseline_proof=self._good_baseline_proof(
+                failure_signatures_match=False,
+                pr_failures=["tests/test_other.py::test_other"],
+            ),
+            project_root=self.ROOT,
+        )
+        self.assertFalse(result["proven"])
+
+    def test_report_parsed_main_checkout_cwd_blocks(self):
+        result = assess_reviewer_baseline_validation_proof(
+            report_text=(
+                "- Validation command: venv/bin/pytest tests/\n"
+                f"- Working directory: {self.ROOT}\n"
+            ),
+            project_root=self.ROOT,
+        )
+        self.assertFalse(result["proven"])
+        self.assertTrue(result["block"])
+
+    def test_build_final_report_downgrades_main_checkout_validation(self):
+        report = build_final_report(
+            checkout_proof=_good_checkout(),
+            inventory=_good_inventory(),
+            validation=_good_validation(),
+            contamination=_good_contamination(),
+            identity_eligible=True,
+            merge_performed=False,
+            issue_status_verified=True,
+            capability_evidence=_good_capability_evidence(),
+            sweep=_good_sweep(),
+            live_state=_good_live_state(),
+            role_boundary=_good_role_boundary(),
+            review_mutation=_good_review_mutation(),
+            controller_handoff=_good_handoff(),
+            capability_proof=_good_capability_proof(),
+            sweep_proof=_good_secret_sweep(),
+            worktree_proof={
+                "worktree_path": "/repo/branches/review-feat-issue-224",
+                "porcelain_status": "",
+                "pr_scope_files": ["docs/wiki/Repositories.md"],
+                "scratch_used": True,
+            },
+            report_text=(
+                "- Validation command: venv/bin/pytest tests/\n"
+                f"- Working directory: {self.ROOT}\n"
+            ),
+            project_root=self.ROOT,
+        )
+        self.assertNotEqual(report["grade"], "A")
+        self.assertFalse(report["baseline_validation_proven"])
+
+
 if __name__ == "__main__":
    unittest.main()
@@ -0,0 +1,150 @@
+"""Tests for non-mergeable skip conflict-proof verifier (#322)."""
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from reviewer_mergeability_skip import assess_non_mergeable_skip_proof  # noqa: E402
+
+HEAD_A = "0fdc8f582026b72a229d59a172c0a63ac4aaeaf9"
+HEAD_B = "1111111111111111111111111111111111111111"
+
+
+def _good_skip_report(pr_number: int, head: str, files: str = "review_proofs.py") -> str:
+    return "\n".join([
+        f"Skipped PR #{pr_number} (non-mergeable).",
+        f"- PR number: #{pr_number}",
+        f"- Current head SHA: {head}",
+        "- Mergeability result: false",
+        "- Conflict proof command: git merge-tree $(git merge-base prgs/master prgs/feat) prgs/master prgs/feat",
+        f"- Conflicting files: {files}",
+        "- Head unchanged since prior blocker",
+        "- Blocking category: merge conflict",
+    ])
+
+
+class TestNonMergeableSkipProof(unittest.TestCase):
+    def test_no_skips_passes(self):
+        report = "Selected PR #203 for review. No earlier PRs skipped."
+        result = assess_non_mergeable_skip_proof(report, skipped_prs=[])
+        self.assertTrue(result["proven"])
+        self.assertFalse(result["block"])
+
+    def test_documented_non_mergeable_skip_passes(self):
+        report = _good_skip_report(282, HEAD_A)
+        result = assess_non_mergeable_skip_proof(
+            report,
+            skipped_prs=[{
+                "pr_number": 282,
+                "mergeable": False,
+                "head_sha": HEAD_A,
+                "mergeability_verified": True,
+                "conflicting_files": ["review_proofs.py"],
+                "head_changed_since_prior_blocker": False,
+            }],
+        )
+        self.assertTrue(result["proven"])
+
+    def test_skip_without_conflict_proof_blocks(self):
+        report = "\n".join([
+            "Skipped PR #284 because it was not mergeable.",
+            f"Head SHA: {HEAD_B}",
+        ])
+        result = assess_non_mergeable_skip_proof(
+            report,
+            skipped_prs=[{
+                "pr_number": 284,
+                "mergeable": False,
+                "head_sha": HEAD_B,
+                "mergeability_verified": True,
+            }],
+        )
+        self.assertFalse(result["proven"])
+        self.assertTrue(result["block"])
+        self.assertTrue(any("conflict proof" in r for r in result["reasons"]))
+
+    def test_missing_head_sha_blocks(self):
+        report = _good_skip_report(282, HEAD_A).replace(HEAD_A, "")
+        result = assess_non_mergeable_skip_proof(
+            report,
+            skipped_prs=[{
+                "pr_number": 282,
+                "mergeable": False,
+                "head_sha": HEAD_A,
+                "mergeability_verified": True,
+            }],
+        )
+        self.assertFalse(result["proven"])
+
+    def test_mergeability_unverified_classification_passes(self):
+        report = "\n".join([
+            "Skipped PR #282.",
+            "Classification: MERGEABILITY_UNVERIFIED",
+            "Conflict proof could not be retrieved in this session.",
+        ])
+        result = assess_non_mergeable_skip_proof(
+            report,
+            skipped_prs=[{
+                "pr_number": 282,
+                "mergeable": False,
+                "mergeability_verified": False,
+            }],
+        )
+        self.assertTrue(result["proven"])
+
+    def test_unverified_without_classification_blocks(self):
+        report = "Skipped PR #282 due to conflicts."
+        result = assess_non_mergeable_skip_proof(
+            report,
+            skipped_prs=[{
+                "pr_number": 282,
+                "mergeable": False,
+                "mergeability_verified": False,
+            }],
+        )
+        self.assertFalse(result["proven"])
+        self.assertTrue(any("MERGEABILITY_UNVERIFIED" in r for r in result["reasons"]))
+
+    def test_non_mergeable_without_file_details_still_passes_with_command(self):
+        report = _good_skip_report(284, HEAD_B, files="not available")
+        result = assess_non_mergeable_skip_proof(
+            report,
+            skipped_prs=[{
+                "pr_number": 284,
+                "mergeable": False,
+                "head_sha": HEAD_B,
+                "mergeability_verified": True,
+                "conflicting_files": [],
+            }],
+        )
+        self.assertTrue(result["proven"])
+
+    def test_stale_head_requires_head_change_field(self):
+        report = _good_skip_report(282, HEAD_A).replace(
+            "- Head unchanged since prior blocker",
+            "",
+        )
+        result = assess_non_mergeable_skip_proof(
+            report,
+            skipped_prs=[{
+                "pr_number": 282,
+                "mergeable": False,
+                "head_sha": HEAD_A,
+                "mergeability_verified": True,
+                "head_changed_since_prior_blocker": True,
+            }],
+        )
+        self.assertFalse(result["proven"])
+        self.assertTrue(any("head-changed" in r for r in result["reasons"]))
+
+
+class TestExport(unittest.TestCase):
+    def test_review_proofs_reexport(self):
+        from review_proofs import assess_non_mergeable_skip_proof as exported
+
+        self.assertTrue(callable(exported))
+
+
+if __name__ == "__main__":
+    unittest.main()