claude-dev-env 2.4.0 → 2.7.0

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_baseline_import_isolation.py

@@ -0,0 +1,248 @@
+"""Behavioral tests for the baseline_import_isolation parts module.
+
+The import-root probe runs a real interpreter subprocess and the leak plugin is
+written, imported, and called the way pytest calls it, so each test measures the
+mechanism the live gate depends on rather than a stand-in for it.
+"""
+
+import importlib.util
+import json
+import os
+import sys
+import types
+from pathlib import Path
+
+import pytest
+from pr_loop_shared_constants.code_rules_gate_constants import (
+    BASELINE_LEAK_PLUGIN_MODULE_NAME,
+    BASELINE_LEAK_REPORT_ENV_VAR,
+    BASELINE_PRIMARY_ROOT_ENV_VAR,
+    PYTEST_PLUGINS_ENV_VAR,
+    PYTHONPATH_ENV_VAR,
+)
+
+from code_rules_gate_parts import baseline_import_isolation
+
+UNREACHABLE_PROBE_TIMEOUT_SECONDS = 0.001
+
+
+def baseline_environment_for(
+    tmp_path: Path,
+    staged_environment: dict[str, str],
+    all_import_roots: list[Path],
+) -> dict[str, str]:
+    """Build a baseline environment against a /repo and /baseline pair under *tmp_path*."""
+    return baseline_import_isolation.baseline_pytest_environment(
+        staged_environment,
+        tmp_path / "repo",
+        tmp_path / "baseline",
+        all_import_roots,
+        tmp_path / "plugin",
+        tmp_path / "report.json",
+    )
+
+
+def test_rebased_into_baseline_moves_a_repository_path_into_the_worktree(
+    tmp_path: Path,
+) -> None:
+    rebased_path = baseline_import_isolation.rebased_into_baseline(
+        tmp_path / "repo" / "packages", tmp_path / "repo", tmp_path / "baseline"
+    )
+
+    assert rebased_path == tmp_path / "baseline" / "packages"
+
+
+def test_rebased_into_baseline_leaves_a_path_outside_the_repository_unclaimed(
+    tmp_path: Path,
+) -> None:
+    rebased_path = baseline_import_isolation.rebased_into_baseline(
+        tmp_path / "elsewhere" / "library", tmp_path / "repo", tmp_path / "baseline"
+    )
+
+    assert rebased_path is None
+
+
+def test_baseline_pytest_environment_leads_with_the_rebased_import_roots(
+    tmp_path: Path,
+) -> None:
+    baseline_environment = baseline_environment_for(
+        tmp_path, {}, [tmp_path / "repo" / "source", tmp_path / "elsewhere"]
+    )
+
+    all_entries = baseline_environment[PYTHONPATH_ENV_VAR].split(os.pathsep)
+    assert all_entries[0] == str(tmp_path / "baseline" / "source")
+    assert str(tmp_path / "elsewhere") not in all_entries
+
+
+def test_baseline_pytest_environment_rebases_a_repository_pythonpath_entry(
+    tmp_path: Path,
+) -> None:
+    staged_environment = {PYTHONPATH_ENV_VAR: str(tmp_path / "repo" / "packages")}
+
+    baseline_environment = baseline_environment_for(tmp_path, staged_environment, [])
+
+    all_entries = baseline_environment[PYTHONPATH_ENV_VAR].split(os.pathsep)
+    assert str(tmp_path / "baseline" / "packages") in all_entries
+    assert str(tmp_path / "repo" / "packages") not in all_entries
+
+
+def test_baseline_pytest_environment_keeps_an_outside_pythonpath_entry(
+    tmp_path: Path,
+) -> None:
+    staged_environment = {PYTHONPATH_ENV_VAR: str(tmp_path / "vendor")}
+
+    baseline_environment = baseline_environment_for(tmp_path, staged_environment, [])
+
+    assert str(tmp_path / "vendor") in baseline_environment[PYTHONPATH_ENV_VAR].split(
+        os.pathsep
+    )
+
+
+def test_baseline_pytest_environment_adds_the_leak_plugin_to_an_existing_list(
+    tmp_path: Path,
+) -> None:
+    staged_environment = {PYTEST_PLUGINS_ENV_VAR: "project_plugin"}
+
+    baseline_environment = baseline_environment_for(tmp_path, staged_environment, [])
+
+    assert baseline_environment[PYTEST_PLUGINS_ENV_VAR] == (
+        f"{BASELINE_LEAK_PLUGIN_MODULE_NAME},project_plugin"
+    )
+
+
+def test_discover_import_roots_reports_a_pythonpath_directory(tmp_path: Path) -> None:
+    library_directory = tmp_path / "library"
+    library_directory.mkdir()
+    probe_environment = dict(os.environ)
+    probe_environment[PYTHONPATH_ENV_VAR] = str(library_directory)
+
+    all_import_roots = baseline_import_isolation.discover_import_roots(
+        sys.executable, probe_environment, tmp_path
+    )
+
+    assert library_directory.resolve() in all_import_roots
+
+
+def test_discover_import_roots_gives_up_on_a_probe_that_runs_out_of_time(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(
+        baseline_import_isolation,
+        "BASELINE_IMPORT_PROBE_TIMEOUT_SECONDS",
+        UNREACHABLE_PROBE_TIMEOUT_SECONDS,
+    )
+
+    all_import_roots = baseline_import_isolation.discover_import_roots(
+        sys.executable, dict(os.environ), tmp_path
+    )
+
+    assert all_import_roots == []
+    assert "import-root probe" in capsys.readouterr().err
+
+
+def test_discover_import_roots_gives_up_on_an_interpreter_that_cannot_start(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    all_import_roots = baseline_import_isolation.discover_import_roots(
+        str(tmp_path / "no_such_interpreter"), dict(os.environ), tmp_path
+    )
+
+    assert all_import_roots == []
+    assert "import-root probe" in capsys.readouterr().err
+
+
+def test_discover_import_roots_reports_an_editable_install_package_root(
+    tmp_path: Path,
+) -> None:
+    project_root = tmp_path / "project"
+    (project_root / "widget").mkdir(parents=True)
+    finder_directory = tmp_path / "finder"
+    finder_directory.mkdir()
+    (finder_directory / "sitecustomize.py").write_text(
+        "import sys\n"
+        f"MAPPING = {{'widget': r'{project_root / 'widget'}'}}\n\n\n"
+        "class EditableFinder:\n"
+        "    @classmethod\n"
+        "    def find_spec(cls, fullname, path=None, target=None):\n"
+        "        return None\n\n\n"
+        "sys.meta_path.append(EditableFinder)\n",
+        encoding="utf-8",
+    )
+    probe_environment = dict(os.environ)
+    probe_environment[PYTHONPATH_ENV_VAR] = str(finder_directory)
+
+    all_import_roots = baseline_import_isolation.discover_import_roots(
+        sys.executable, probe_environment, tmp_path
+    )
+
+    assert project_root.resolve() in all_import_roots
+
+
+def test_modules_imported_from_primary_tree_is_unknown_without_a_report(
+    tmp_path: Path,
+) -> None:
+    assert (
+        baseline_import_isolation.modules_imported_from_primary_tree(
+            tmp_path / "missing.json"
+        )
+        is None
+    )
+
+
+def test_modules_imported_from_primary_tree_reads_the_reported_paths(
+    tmp_path: Path,
+) -> None:
+    report_path = tmp_path / "report.json"
+    report_path.write_text(json.dumps([str(tmp_path / "repo" / "foo.py")]), encoding="utf-8")
+
+    assert baseline_import_isolation.modules_imported_from_primary_tree(report_path) == [
+        tmp_path / "repo" / "foo.py"
+    ]
+
+
+def load_installed_plugin(plugin_directory: Path) -> types.ModuleType:
+    """Import the plugin module ``install_leak_plugin`` wrote into *plugin_directory*."""
+    plugin_path = plugin_directory / f"{BASELINE_LEAK_PLUGIN_MODULE_NAME}.py"
+    module_specification = importlib.util.spec_from_file_location(
+        BASELINE_LEAK_PLUGIN_MODULE_NAME, plugin_path
+    )
+    assert module_specification is not None and module_specification.loader is not None
+    plugin_module = importlib.util.module_from_spec(module_specification)
+    module_specification.loader.exec_module(plugin_module)
+    return plugin_module
+
+
+def test_installed_plugin_reports_a_module_loaded_from_the_primary_tree(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    plugin_directory = tmp_path / "plugin"
+    baseline_import_isolation.install_leak_plugin(plugin_directory)
+    plugin_module = load_installed_plugin(plugin_directory)
+    primary_root = tmp_path / "repo"
+    leaked_module = types.ModuleType("leaked_widget")
+    leaked_module.__file__ = str(primary_root / "widget" / "__init__.py")
+    monkeypatch.setitem(sys.modules, "leaked_widget", leaked_module)
+    report_path = tmp_path / "report.json"
+    monkeypatch.setenv(BASELINE_PRIMARY_ROOT_ENV_VAR, str(primary_root))
+    monkeypatch.setenv(BASELINE_LEAK_REPORT_ENV_VAR, str(report_path))
+
+    plugin_module.pytest_sessionfinish(None, 0)
+
+    assert baseline_import_isolation.modules_imported_from_primary_tree(report_path) == [
+        primary_root / "widget" / "__init__.py"
+    ]
+
+
+def test_installed_plugin_reports_nothing_when_no_module_came_from_the_primary_tree(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    plugin_directory = tmp_path / "plugin"
+    baseline_import_isolation.install_leak_plugin(plugin_directory)
+    plugin_module = load_installed_plugin(plugin_directory)
+    report_path = tmp_path / "report.json"
+    monkeypatch.setenv(BASELINE_PRIMARY_ROOT_ENV_VAR, str(tmp_path / "repo"))
+    monkeypatch.setenv(BASELINE_LEAK_REPORT_ENV_VAR, str(report_path))
+
+    plugin_module.pytest_sessionfinish(None, 0)
+
+    assert baseline_import_isolation.modules_imported_from_primary_tree(report_path) == []

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_staged_test_regression.py

@@ -0,0 +1,309 @@
+"""Behavioral tests for the staged_test_regression parts module.
+
+Every test drives a real git repository and a real pytest subprocess — no
+mocked git state, no mocked pytest run — the same shape the live commit gate
+exercises.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from code_rules_gate_parts import baseline_import_isolation, staged_test_regression
+from code_rules_gate_parts.tests._repo_test_helpers import (
+    init_repository,
+    repository_root_without_pytest_config,
+    repository_with_root_pytest_config,
+    run_git,
+    write_and_stage,
+    write_commit_and_stage_change,
+)
+
+UNREACHABLE_PROBE_TIMEOUT_SECONDS = 0.001
+
+CONSUMER_TEST_TEXT = (
+    "import foo\n\n\ndef test_consumer_reads_head_value() -> None:\n"
+    "    assert foo.VALUE == 'clean', foo.__file__\n"
+)
+
+CONSUMER_TEST_TEXT_WITH_STAGED_EDIT = CONSUMER_TEST_TEXT + (
+    "\n\ndef test_consumer_extra() -> None:\n    assert True\n"
+)
+
+IMPORT_HOOK_SITECUSTOMIZE_TEMPLATE = (
+    "import sys\n"
+    "from importlib.machinery import PathFinder\n\n"
+    "PINNED_ROOT = r'{pinned_root}'\n\n\n"
+    "class PinnedFinder(PathFinder):\n"
+    "    @classmethod\n"
+    "    def find_spec(cls, fullname, path=None, target=None):\n"
+    "        if fullname.split('.')[0] != 'foo':\n"
+    "            return None\n"
+    "        return super().find_spec(fullname, [PINNED_ROOT], target)\n\n\n"
+    "sys.meta_path.insert(0, PinnedFinder)\n"
+)
+
+
+def stage_a_change_that_breaks_a_consumer(repository_root: Path) -> None:
+    """Commit a passing consumer of ``foo``, then stage a ``foo`` edit that breaks it.
+
+    The consumer imports ``foo`` by name, so which copy of ``foo`` the baseline
+    run loads decides whether the gate sees a regression at all.
+    """
+    write_and_stage(repository_root, "packages/foo/__init__.py", "VALUE = 'clean'\n")
+    write_and_stage(repository_root, "pkg_a/test_alpha.py", CONSUMER_TEST_TEXT)
+    run_git(repository_root, "commit", "--no-verify", "-m", "seed consumer")
+    write_and_stage(repository_root, "packages/foo/__init__.py", "VALUE = 'dirty'\n")
+    write_and_stage(
+        repository_root, "pkg_a/test_alpha.py", CONSUMER_TEST_TEXT_WITH_STAGED_EDIT
+    )
+
+
+def test_pythonpath_route_into_the_working_tree_does_not_hide_a_regression(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    stage_a_change_that_breaks_a_consumer(repository_root)
+    monkeypatch.setenv("PYTHONPATH", str(repository_root / "packages"))
+
+    assert staged_test_regression.run_staged_test_files(repository_root) != 0
+
+
+def test_a_probe_that_runs_out_of_time_still_reaches_a_gate_decision(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_commit_and_stage_change(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        (
+            "def test_already_fails() -> None:\n    assert False\n"
+            "def test_passes() -> None:\n    assert True\n"
+        ),
+        (
+            "def test_already_fails() -> None:\n    assert False\n"
+            "def test_passes() -> None:\n    assert 1 == 1\n"
+        ),
+    )
+    monkeypatch.setattr(
+        baseline_import_isolation,
+        "BASELINE_IMPORT_PROBE_TIMEOUT_SECONDS",
+        UNREACHABLE_PROBE_TIMEOUT_SECONDS,
+    )
+
+    exit_code = staged_test_regression.run_staged_test_files(repository_root)
+
+    assert exit_code == 0
+    assert "import-root probe" in capsys.readouterr().err
+
+
+def test_import_hook_route_into_the_working_tree_is_reported_and_blocks(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    stage_a_change_that_breaks_a_consumer(repository_root)
+    import_hook_directory = tmp_path / "import_hook"
+    import_hook_directory.mkdir()
+    (import_hook_directory / "sitecustomize.py").write_text(
+        IMPORT_HOOK_SITECUSTOMIZE_TEMPLATE.format(pinned_root=repository_root / "packages"),
+        encoding="utf-8",
+    )
+    monkeypatch.setenv("PYTHONPATH", str(import_hook_directory))
+
+    exit_code = staged_test_regression.run_staged_test_files(repository_root)
+
+    assert exit_code != 0
+    assert "imported 1 module(s) from your working tree" in capsys.readouterr().err
+
+
+def test_pre_existing_failure_does_not_block_an_unrelated_staged_change(
+    tmp_path: Path,
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_commit_and_stage_change(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        (
+            "def test_already_fails() -> None:\n    assert False\n"
+            "def test_passes() -> None:\n    assert True\n"
+        ),
+        (
+            "def test_already_fails() -> None:\n    assert False\n"
+            "def test_passes() -> None:\n    assert 1 == 1\n"
+        ),
+    )
+
+    assert staged_test_regression.run_staged_test_files(repository_root) == 0
+
+
+def test_staged_change_that_newly_breaks_a_passing_test_blocks(tmp_path: Path) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_commit_and_stage_change(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        "def test_alpha_passes() -> None:\n    assert True\n",
+        "def test_alpha_passes() -> None:\n    assert False\n",
+    )
+
+    assert staged_test_regression.run_staged_test_files(repository_root) != 0
+
+
+def test_brand_new_failing_test_with_no_baseline_blocks(tmp_path: Path) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_and_stage(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        "def test_alpha_fails() -> None:\n    assert False\n",
+    )
+
+    assert staged_test_regression.run_staged_test_files(repository_root) != 0
+
+
+def test_mixed_group_blocks_only_on_the_newly_broken_test(tmp_path: Path) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_commit_and_stage_change(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        (
+            "def test_already_red() -> None:\n    assert False\n"
+            "def test_stays_green() -> None:\n    assert True\n"
+        ),
+        (
+            "def test_already_red() -> None:\n    assert False\n"
+            "def test_stays_green() -> None:\n    assert False\n"
+        ),
+    )
+
+    assert staged_test_regression.run_staged_test_files(repository_root) != 0
+
+
+def test_regression_gate_leaves_the_staged_index_and_worktree_list_alone(
+    tmp_path: Path,
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_commit_and_stage_change(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        (
+            "def test_already_fails() -> None:\n    assert False\n"
+            "def test_passes() -> None:\n    assert True\n"
+        ),
+        (
+            "def test_already_fails() -> None:\n    assert False\n"
+            "def test_passes() -> None:\n    assert 1 == 1\n"
+        ),
+    )
+
+    staged_test_regression.run_staged_test_files(repository_root)
+
+    staged_content = run_git(
+        repository_root, "show", ":pkg_a/test_alpha.py"
+    ).stdout.decode("utf-8")
+    assert "assert 1 == 1" in staged_content
+    status = run_git(repository_root, "status", "--porcelain").stdout.decode("utf-8")
+    assert "M  pkg_a/test_alpha.py" in status
+    worktree_list = run_git(
+        repository_root, "worktree", "list", "--porcelain"
+    ).stdout.decode("utf-8")
+    assert worktree_list.count("worktree ") == 1
+    assert "code_rules_gate_baseline_" not in worktree_list
+
+
+def test_run_staged_test_files_returns_zero_when_nothing_staged(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    init_repository(repository_root)
+
+    assert staged_test_regression.run_staged_test_files(repository_root) == 0
+
+
+def test_run_staged_test_files_returns_zero_when_only_multiple_confests_staged(
+    tmp_path: Path,
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_and_stage(repository_root, "pkg_a/conftest.py", "import pytest\n")
+    write_and_stage(repository_root, "pkg_b/conftest.py", "import pytest\n")
+    write_and_stage(repository_root, "pkg_c/tests/conftest.py", "import pytest\n")
+
+    assert staged_test_regression.run_staged_test_files(repository_root) == 0
+
+
+def test_run_staged_test_files_passes_when_confests_stage_with_passing_test(
+    tmp_path: Path,
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_and_stage(repository_root, "pkg_a/conftest.py", "import pytest\n")
+    write_and_stage(repository_root, "pkg_b/conftest.py", "import pytest\n")
+    write_and_stage(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        "def test_alpha_passes() -> None:\n    assert True\n",
+    )
+
+    assert staged_test_regression.run_staged_test_files(repository_root) == 0
+
+
+def test_run_staged_test_files_fails_when_real_test_fails_alongside_confests(
+    tmp_path: Path,
+) -> None:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    write_and_stage(repository_root, "pkg_a/conftest.py", "import pytest\n")
+    write_and_stage(repository_root, "pkg_b/conftest.py", "import pytest\n")
+    write_and_stage(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        "def test_alpha_fails() -> None:\n    assert False\n",
+    )
+
+    assert staged_test_regression.run_staged_test_files(repository_root) != 0
+
+
+def test_no_head_baseline_blocks_on_any_staged_failure(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    run_git(repository_root, "init", "--initial-branch=main")
+    run_git(repository_root, "config", "user.email", "test@example.com")
+    run_git(repository_root, "config", "user.name", "Test")
+    run_git(repository_root, "config", "commit.gpgsign", "false")
+    write_and_stage(repository_root, "pytest.ini", "[pytest]\n")
+    write_and_stage(
+        repository_root,
+        "test_alpha.py",
+        "def test_alpha_fails() -> None:\n    assert False\n",
+    )
+
+    assert staged_test_regression.run_staged_test_files(repository_root) != 0
+
+
+def _stage_package_owning_a_bare_config(
+    repository_root: Path, package_name: str, marker_value: str
+) -> None:
+    """Stage a config-less top-level package whose tests import a bare ``config``.
+
+    Two such packages staged together reproduce the measured collision: one
+    pytest session binds ``config`` to whichever package imports first, so the
+    other package's test reads the wrong marker.
+    """
+    write_and_stage(
+        repository_root,
+        f"{package_name}/config/__init__.py",
+        f'PACKAGE_MARKER = "{marker_value}"\n',
+    )
+    write_and_stage(
+        repository_root,
+        f"{package_name}/test_{package_name}.py",
+        "from config import PACKAGE_MARKER\n\n\n"
+        f"def test_{package_name}_reads_its_own_config() -> None:\n"
+        f'    assert PACKAGE_MARKER == "{marker_value}"\n',
+    )
+
+
+def test_run_staged_test_files_passes_when_config_less_packages_share_a_module_name(
+    tmp_path: Path,
+) -> None:
+    repository_root = repository_root_without_pytest_config(tmp_path)
+    init_repository(repository_root)
+    _stage_package_owning_a_bare_config(repository_root, "alpha_package", "alpha")
+    _stage_package_owning_a_bare_config(repository_root, "beta_package", "beta")
+
+    assert staged_test_regression.run_staged_test_files(repository_root) == 0