claude-dev-env 2.16.0 → 2.18.0

package/_shared/pr-loop/scripts/test_check_convergence_contract.py

@@ -0,0 +1,400 @@
+"""Contract-pin and flag tests for check_convergence.
+
+::
+
+    check_all(all gates passing,
+        is_bugteam_post_blocked=False,
+    )       -> exit 0, "All pre-conditions met ..."
+    check_all(one gate failing,
+        is_bugteam_post_blocked=False,
+    )        -> exit 1, "One or more ... do not mark ready."
+    _get_pr_head_sha raises SystemExit -> exit 2 propagates
+    parse_arguments([... --bugteam-post-blocked]) -> bugteam_post_blocked True
+
+The pin tests fix the stdout consumers parse (converge.mjs, autoconverge,
+archived bugteam) byte-for-byte, plus the exit codes and CLI surface. The flag tests
+drive the ``--bugteam-post-blocked`` bypass.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+import _pr_converge_path_setup  # noqa: F401
+import check_convergence_availability
+from pr_converge_skill_constants.constants import EXIT_CODE_GH_ERROR
+
+_SCRIPTS_DIRECTORY = Path(__file__).absolute().parent
+_PR_CONVERGE_DIRECTORY = _SCRIPTS_DIRECTORY.parent
+
+CURRENT_HEAD_SHA = "abcdef1234567890abcdef1234567890abcdef12"
+
+_ALL_LEAF_GATE_NAMES = [
+    "_check_bugbot",
+    "_check_bugbot_not_dirty",
+    "_check_bugteam_clean",
+    "_check_bot_review",
+    "_count_unresolved_bot_threads",
+    "_get_mergeable",
+    "_check_no_pending_reviews",
+]
+
+EXPECTED_ALL_PASS_STDOUT = (
+    "HEAD: abcdef1\n\n"
+    "1. bugbot_clean_at == current_head: PASS — clean\n"
+    "2. bugbot review body clean: PASS — clean\n"
+    "3. bugteam_clean_at == current_head: PASS — clean\n"
+    "4. copilot_clean_at == current_head: PASS — clean\n"
+    "5. codex_clean_at == current_head: PASS — skipped (codex review not required)\n"
+    "6. zero unresolved bot threads: PASS — clean\n"
+    "7. PR is mergeable: PASS — clean\n"
+    "8. no pending requested reviews: PASS — clean\n\n"
+    "All pre-conditions met — PR is ready to mark ready.\n"
+)
+
+EXPECTED_BUGBOT_DOWN_STDOUT = (
+    "HEAD: abcdef1\n\n"
+    "1. bugbot_clean_at == current_head: PASS — bypassed (bugbot_down)\n"
+    "2. bugteam_clean_at == current_head: PASS — clean\n"
+    "3. copilot_clean_at == current_head: PASS — clean\n"
+    "4. codex_clean_at == current_head: PASS — skipped (codex review not required)\n"
+    "5. zero unresolved bot threads: PASS — clean\n"
+    "6. PR is mergeable: PASS — clean\n"
+    "7. no pending requested reviews: PASS — clean\n\n"
+    "All pre-conditions met — PR is ready to mark ready.\n"
+)
+
+EXPECTED_COPILOT_DOWN_STDOUT = (
+    "HEAD: abcdef1\n\n"
+    "1. bugbot_clean_at == current_head: PASS — clean\n"
+    "2. bugbot review body clean: PASS — clean\n"
+    "3. bugteam_clean_at == current_head: PASS — clean\n"
+    "4. copilot_clean_at == current_head: PASS — bypassed (copilot_down)\n"
+    "5. codex_clean_at == current_head: PASS — skipped (codex review not required)\n"
+    "6. zero unresolved bot threads: PASS — clean\n"
+    "7. PR is mergeable: PASS — clean\n"
+    "8. no pending requested reviews: PASS — bypassed (copilot_down)\n\n"
+    "All pre-conditions met — PR is ready to mark ready.\n"
+)
+
+EXPECTED_FAIL_SUMMARY = "One or more pre-conditions not met — do not mark ready.\n"
+
+
+def _load_check_convergence() -> ModuleType:
+    if str(_PR_CONVERGE_DIRECTORY) not in sys.path:
+        sys.path.insert(0, str(_PR_CONVERGE_DIRECTORY))
+    if str(_SCRIPTS_DIRECTORY) not in sys.path:
+        sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+    module_path = _SCRIPTS_DIRECTORY / "check_convergence.py"
+    spec = importlib.util.spec_from_file_location(
+        "check_convergence_contract_under_test", module_path
+    )
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+check_convergence = _load_check_convergence()
+
+
+def _clean_head(**_call_keywords: object) -> str:
+    return CURRENT_HEAD_SHA
+
+
+def _clean_gate(**_call_keywords: object) -> tuple[bool, str]:
+    return True, "clean"
+
+
+def _refuse_bugteam_clean(**_call_keywords: object) -> tuple[bool, str]:
+    raise AssertionError(
+        "_check_bugteam_clean must not run when is_bugteam_post_blocked=True"
+    )
+
+
+def _null_codex_percent_left() -> float | None:
+    return None
+
+
+def _patch_gates_clean(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(check_convergence, "_get_pr_head_sha", _clean_head)
+    monkeypatch.setattr(
+        check_convergence, "_probe_codex_percent_left", _null_codex_percent_left
+    )
+    for each_gate_name in _ALL_LEAF_GATE_NAMES:
+        monkeypatch.setattr(check_convergence, each_gate_name, _clean_gate)
+
+
+def test_all_pass_stdout_and_exit_code_match_the_pinned_contract(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=False
+    , is_bugteam_post_blocked=False, is_codex_down=False, live_codex_clean_at=None)
+    assert capsys.readouterr().out == EXPECTED_ALL_PASS_STDOUT
+    assert exit_code == 0
+
+
+def test_bugbot_down_bypass_line_matches_the_pinned_contract(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=True, is_copilot_down=False
+    , is_bugteam_post_blocked=False, is_codex_down=False, live_codex_clean_at=None)
+    assert capsys.readouterr().out == EXPECTED_BUGBOT_DOWN_STDOUT
+    assert exit_code == 0
+
+
+def test_copilot_down_bypass_lines_match_the_pinned_contract(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=True
+    , is_bugteam_post_blocked=False, is_codex_down=False, live_codex_clean_at=None)
+    assert capsys.readouterr().out == EXPECTED_COPILOT_DOWN_STDOUT
+    assert exit_code == 0
+
+
+def test_a_failing_gate_yields_exit_one_and_the_fail_summary(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+
+    def _blocked_mergeable(**_call_keywords: object) -> tuple[bool, str]:
+        return False, "blocked"
+
+    monkeypatch.setattr(check_convergence, "_get_mergeable", _blocked_mergeable)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=False
+    , is_bugteam_post_blocked=False, is_codex_down=False, live_codex_clean_at=None)
+    captured_stdout = capsys.readouterr().out
+    assert "7. PR is mergeable: FAIL — blocked\n" in captured_stdout
+    assert captured_stdout.endswith(EXPECTED_FAIL_SUMMARY)
+    assert exit_code == 1
+
+
+def test_gh_error_exit_code_is_two_and_propagates_from_head_fetch(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def _raise_gh_error(**_call_keywords: object) -> str:
+        raise SystemExit(EXIT_CODE_GH_ERROR)
+
+    monkeypatch.setattr(check_convergence, "_get_pr_head_sha", _raise_gh_error)
+    with pytest.raises(SystemExit) as raised:
+        check_convergence.check_all(
+            owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=False
+        , is_bugteam_post_blocked=False, is_codex_down=False, live_codex_clean_at=None)
+    assert EXIT_CODE_GH_ERROR == 2
+    assert raised.value.code == 2
+
+
+def test_existing_cli_flags_stay_on_the_argument_surface() -> None:
+    arguments = check_convergence.parse_arguments(
+        [
+            "--owner",
+            "o",
+            "--repo",
+            "r",
+            "--pr-number",
+            "1",
+            "--bugbot-down",
+            "--copilot-down",
+        ]
+    )
+    assert arguments.owner == "o"
+    assert arguments.repo == "r"
+    assert getattr(arguments, "pr_number") == 1
+    assert arguments.bugbot_down is True
+    assert arguments.copilot_down is True
+
+
+def test_skip_bugteam_gate_when_bugteam_post_blocked_is_true(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    monkeypatch.setattr(
+        check_convergence, "_check_bugteam_clean", _refuse_bugteam_clean
+    )
+    exit_code = check_convergence.check_all(
+        owner="o",
+        repo="r",
+        number=1,
+        is_bugbot_down=False,
+        is_copilot_down=False,
+        is_bugteam_post_blocked=True,
+        is_codex_down=False,
+        live_codex_clean_at=None,
+    )
+    assert "bypassed (bugteam_post_blocked)" in capsys.readouterr().out
+    assert exit_code == 0
+
+
+def test_run_bugteam_gate_when_bugteam_post_blocked_is_false(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    invoked_gate_names: list[str] = []
+
+    def _recording_bugteam_clean(**_call_keywords: object) -> tuple[bool, str]:
+        invoked_gate_names.append("_check_bugteam_clean")
+        return True, "clean"
+
+    _patch_gates_clean(monkeypatch)
+    monkeypatch.setattr(
+        check_convergence, "_check_bugteam_clean", _recording_bugteam_clean
+    )
+    exit_code = check_convergence.check_all(
+        owner="o",
+        repo="r",
+        number=1,
+        is_bugbot_down=False,
+        is_copilot_down=False,
+        is_bugteam_post_blocked=False,
+        is_codex_down=False,
+        live_codex_clean_at=None,
+    )
+    assert "_check_bugteam_clean" in invoked_gate_names
+    assert "bypassed (bugteam_post_blocked)" not in capsys.readouterr().out
+    assert exit_code == 0
+
+
+def test_bugteam_post_blocked_flag_round_trips_through_parse_arguments() -> None:
+    arguments = check_convergence.parse_arguments(
+        ["--owner", "o", "--repo", "r", "--pr-number", "1", "--bugteam-post-blocked"]
+    )
+    assert arguments.bugteam_post_blocked is True
+
+
+def test_bugteam_post_blocked_defaults_to_false_when_flag_absent() -> None:
+    arguments = check_convergence.parse_arguments(
+        ["--owner", "o", "--repo", "r", "--pr-number", "1"]
+    )
+    assert arguments.bugteam_post_blocked is False
+
+
+def test_resolve_bugteam_post_blocked_true_when_flag_set(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    assert check_convergence._resolve_bugteam_post_blocked(True) is True
+
+
+def test_resolve_bugteam_post_blocked_true_when_env_disables_bugteam(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugteam")
+    assert check_convergence._resolve_bugteam_post_blocked(False) is True
+
+
+def test_resolve_bugteam_post_blocked_false_when_flag_unset_and_bugteam_opted_in(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    assert check_convergence._resolve_bugteam_post_blocked(False) is False
+
+
+def test_resolve_bugteam_post_blocked_true_when_neither_list_names_bugteam(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_ENABLED", raising=False)
+    assert check_convergence._resolve_bugteam_post_blocked(False) is True
+
+
+def test_resolve_bugteam_post_blocked_false_when_opted_in_and_env_disables_copilot(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "copilot")
+    assert check_convergence._resolve_bugteam_post_blocked(False) is False
+
+
+def test_env_bugteam_token_does_not_disable_copilot_or_bugbot_opt_out(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugteam")
+    assert check_convergence._resolve_copilot_down(False) is False
+    assert check_convergence._resolve_bugteam_post_blocked(False) is True
+
+
+def test_main_derives_bugteam_post_blocked_from_env_when_flag_omitted(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugteam")
+    captured_bugteam_post_blocked: list[bool] = []
+
+    def stub_check_all(
+        *,
+        owner: str,
+        repo: str,
+        number: int,
+        is_bugbot_down: bool,
+        is_copilot_down: bool,
+        is_bugteam_post_blocked: bool = False,
+        is_codex_down: bool = False,
+        live_codex_clean_at: str | None = None,
+        **_bypass_note_kwargs: str,
+    ) -> int:
+        captured_bugteam_post_blocked.append(is_bugteam_post_blocked)
+        return 0
+
+    monkeypatch.setattr(check_convergence, "check_all", stub_check_all)
+    exit_code = check_convergence.main(["--owner", "o", "--repo", "r", "--pr-number", "1"])
+    assert exit_code == 0
+    assert captured_bugteam_post_blocked == [True]
+
+
+def test_copilot_probe_error_still_runs_live_gates(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A probe error must not hard-fail; live GitHub gates decide pass/fail."""
+    _patch_gates_clean(monkeypatch)
+    live_copilot_calls: list[str] = []
+    live_pending_calls: list[str] = []
+
+    def _recording_bot_review(**_keywords: object) -> tuple[bool, str]:
+        live_copilot_calls.append("copilot")
+        return True, "clean"
+
+    def _recording_pending(**_keywords: object) -> tuple[bool, str]:
+        live_pending_calls.append("pending")
+        return True, "clean"
+
+    monkeypatch.setattr(check_convergence, "_check_bot_review", _recording_bot_review)
+    monkeypatch.setattr(
+        check_convergence, "_check_no_pending_reviews", _recording_pending
+    )
+    monkeypatch.setattr(
+        check_convergence,
+        "_resolve_copilot_waiver",
+        lambda _flag: check_convergence_availability.ReviewerWaiver(
+            False, "", "quota API down"
+        ),
+    )
+    monkeypatch.setattr(
+        check_convergence,
+        "_resolve_bugbot_waiver",
+        lambda _flag: check_convergence_availability.ReviewerWaiver(True, "bugbot_down", ""),
+    )
+    exit_code = check_convergence.main(
+        [
+            "--owner",
+            "o",
+            "--repo",
+            "r",
+            "--pr-number",
+            "1",
+            "--bugbot-down",
+        ]
+    )
+    captured = capsys.readouterr().out
+    assert live_copilot_calls == ["copilot"]
+    assert live_pending_calls == ["pending"]
+    assert "enforced (probe error" not in captured
+    assert exit_code == 0

package/_shared/pr-loop/scripts/test_check_convergence_fixture.py

@@ -0,0 +1,179 @@
+"""Fixture-mode tests for check_convergence --fixture replay."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+import _pr_converge_path_setup  # noqa: F401
+
+_SCRIPTS_DIRECTORY = Path(__file__).absolute().parent
+_PR_CONVERGE_DIRECTORY = _SCRIPTS_DIRECTORY.parent
+
+CLEAN_LABEL = "Clean \u2014 no findings"
+CLEAN_BODY = (
+    f"**Bugteam audit completed** \u2014 {CLEAN_LABEL}\n\n"
+    "No findings.\n"
+)
+HEAD_SHA = "ae8005aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+
+
+def _load_module() -> ModuleType:
+    for each_cached_name in [
+        each_key
+        for each_key in list(sys.modules)
+        if each_key == "config" or each_key.startswith("config.")
+    ]:
+        sys.modules.pop(each_cached_name, None)
+    if str(_PR_CONVERGE_DIRECTORY) in sys.path:
+        sys.path.remove(str(_PR_CONVERGE_DIRECTORY))
+    sys.path.insert(0, str(_PR_CONVERGE_DIRECTORY))
+    module_path = _SCRIPTS_DIRECTORY / "check_convergence.py"
+    spec = importlib.util.spec_from_file_location(
+        "check_convergence_fixture_under_test", module_path
+    )
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+check_convergence = _load_module()
+
+
+def _write_passing_fixture(tmp_path: Path) -> Path:
+    fixture_path = tmp_path / "pr-at-merge.json"
+    payload = {
+        "head_sha": HEAD_SHA,
+        "pr_object": {"mergeable": True, "mergeable_state": "clean"},
+        "reviews": [
+            {
+                "id": 1,
+                "body": CLEAN_BODY,
+                "commit_id": HEAD_SHA,
+            }
+        ],
+        "unresolved_bot_threads_passed": True,
+        "unresolved_bot_threads_detail": "0 unresolved",
+        "pending_reviews_passed": True,
+        "pending_reviews_detail": "none pending",
+    }
+    fixture_path.write_text(json.dumps(payload), encoding="utf-8")
+    return fixture_path
+
+
+def should_exit_zero_from_fixture_with_bugbot_and_copilot_down(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    fixture_path = _write_passing_fixture(tmp_path)
+    exit_code = check_convergence.main(
+        [
+            "--owner",
+            "jl-cmd",
+            "--repo",
+            "claude-dev-env",
+            "--pr-number",
+            "53",
+            "--fixture",
+            str(fixture_path),
+            "--bugbot-down",
+            "--copilot-down",
+        ]
+    )
+    captured = capsys.readouterr().out
+    assert exit_code == 0
+    assert "All pre-conditions met" in captured
+    assert "bypassed (bugbot_down)" in captured
+    assert "bypassed (copilot_down)" in captured
+    assert "clean bugteam audit" in captured
+    assert "PR is mergeable: PASS" in captured
+
+
+def should_exit_one_from_fixture_when_bugteam_clean_missing(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    fixture_path = tmp_path / "missing-bugteam.json"
+    payload = {
+        "head_sha": HEAD_SHA,
+        "pr_object": {"mergeable": True, "mergeable_state": "clean"},
+        "reviews": [],
+        "unresolved_bot_threads_passed": True,
+        "unresolved_bot_threads_detail": "0 unresolved",
+        "pending_reviews_passed": True,
+        "pending_reviews_detail": "none pending",
+    }
+    fixture_path.write_text(json.dumps(payload), encoding="utf-8")
+    exit_code = check_convergence.main(
+        [
+            "--owner",
+            "jl-cmd",
+            "--repo",
+            "claude-dev-env",
+            "--pr-number",
+            "80",
+            "--fixture",
+            str(fixture_path),
+            "--bugbot-down",
+            "--copilot-down",
+        ]
+    )
+    captured = capsys.readouterr().out
+    assert exit_code == 1
+    assert "no bugteam review found" in captured
+    assert "do not mark ready" in captured
+
+
+def should_parse_fixture_flag() -> None:
+    arguments = check_convergence.parse_arguments(
+        [
+            "--owner",
+            "o",
+            "--repo",
+            "r",
+            "--pr-number",
+            "1",
+            "--fixture",
+            "snap.json",
+            "--bugbot-down",
+            "--copilot-down",
+        ]
+    )
+    assert arguments.fixture == "snap.json"
+    assert arguments.bugbot_down is True
+    assert arguments.copilot_down is True
+
+
+def should_evaluate_bugteam_clean_from_reviews_on_clean_body() -> None:
+    head = HEAD_SHA
+    passed, detail = check_convergence._evaluate_bugteam_clean_from_reviews(
+        [{"id": 9, "body": CLEAN_BODY, "commit_id": head}],
+        head,
+    )
+    assert passed is True
+    assert "clean bugteam audit" in detail
+
+
+def should_load_convergence_fixture_from_disk(tmp_path: Path) -> None:
+    fixture_path = _write_passing_fixture(tmp_path)
+    fixture = check_convergence._load_convergence_fixture(fixture_path)
+    assert fixture.head_sha == HEAD_SHA
+    assert fixture.pr_object["mergeable"] is True
+    assert len(fixture.reviews) == 1
+
+
+def should_reject_fixture_missing_safety_gate_flags(tmp_path: Path) -> None:
+    fixture_path = tmp_path / "missing-safety-flags.json"
+    payload = {
+        "head_sha": HEAD_SHA,
+        "pr_object": {"mergeable": True, "mergeable_state": "clean"},
+        "reviews": [{"id": 1, "body": CLEAN_BODY, "commit_id": HEAD_SHA}],
+    }
+    fixture_path.write_text(json.dumps(payload), encoding="utf-8")
+    with pytest.raises(ValueError):
+        check_convergence._load_convergence_fixture(fixture_path)

package/_shared/pr-loop/scripts/test_check_convergence_gates.py

@@ -0,0 +1,84 @@
+"""Behavioral tests for the review and Bugbot convergence gate leaves.
+
+::
+
+    _flatten_paginated_reviews(two pages) -> newest-first flat list
+    _bugbot_run_conclusion_detail(success) -> (True, "check run ...")
+    _check_bugbot(named complete run) -> (True, "check run ...")
+
+Each test drives the real leaf, stubbing only the ``gh`` transport helpers.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+import check_convergence_gates as gates
+
+
+def test_flatten_paginated_reviews_flattens_and_sorts_newest_first() -> None:
+    pages = [
+        [{"id": 1, "submitted_at": "2026-01-01T00:00:00Z"}],
+        [{"id": 2, "submitted_at": "2026-03-01T00:00:00Z"}],
+    ]
+    flattened = gates._flatten_paginated_reviews(json.dumps(pages))
+    assert flattened is not None
+    assert [each_review["id"] for each_review in flattened] == [2, 1]
+
+
+def test_flatten_paginated_reviews_returns_none_for_non_list_payload() -> None:
+    assert (
+        gates._flatten_paginated_reviews(json.dumps({"message": "Not Found"})) is None
+    )
+
+
+def test_bugbot_run_conclusion_detail_passes_on_a_complete_conclusion() -> None:
+    complete_conclusion = gates.ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS[0]
+    passed, detail = gates._bugbot_run_conclusion_detail(
+        {"id": 55, "conclusion": complete_conclusion, "html_url": ""}
+    )
+    assert passed is True
+    assert "check run 55" in detail
+
+
+def test_check_bugbot_reports_success_when_the_named_run_is_complete(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    complete_conclusion = gates.ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS[0]
+    run_name = f"x {gates.BUGBOT_CHECK_RUN_NAME_SUBSTRING} y"
+    payload = {
+        "check_runs": [
+            {
+                "name": run_name,
+                "id": 9,
+                "conclusion": complete_conclusion,
+                "html_url": "",
+            }
+        ]
+    }
+
+    def _stub_gh_api(endpoint_path: str) -> tuple[int, str]:
+        return 0, json.dumps(payload)
+
+    monkeypatch.setattr(gates, "_gh_api", _stub_gh_api)
+    passed, detail = gates._check_bugbot(owner="o", repo="r", sha="abc")
+    assert passed is True
+    assert "check run 9" in detail
+
+
+def should_evaluate_mergeable_from_pr_object_clean() -> None:
+    passed, detail = gates._evaluate_mergeable_from_pr_object(
+        {"mergeable": True, "mergeable_state": "clean"}
+    )
+    assert passed is True
+    assert detail == "clean"
+
+
+def should_evaluate_mergeable_from_pr_object_unknown() -> None:
+    passed, detail = gates._evaluate_mergeable_from_pr_object(
+        {"mergeable": None, "mergeable_state": "unknown"}
+    )
+    assert passed is False
+    assert detail == "unknown"