claude-dev-env 2.4.0 → 2.7.0

package/_shared/pr-loop/scripts/code_rules_gate_parts/staged_test_running.py

@@ -1,13 +1,33 @@
-"""Run the staged Python test files, grouped by their owning pytest config.
+"""Run the staged Python test files, grouped by owning pytest config or top-level directory.
 
 The commit gate runs each staged test file so a broken test blocks the commit.
-Files are grouped by the nearest ancestor holding a pytest config, and each
-group runs in its own pytest session with the working directory at that root, so
-two packages exposing a same-named top-level package never shadow each other.
+Files are grouped by the nearest ancestor holding a pytest config, falling back
+to the file's own top-level directory under the repository root when no ancestor
+owns one. Each group runs in its own pytest session with the working directory
+at that root, so two packages exposing a same-named top-level package never
+shadow each other.
 
 ``conftest.py`` paths are never passed as pytest collection targets: pytest loads
 them automatically when nearby tests run, and collecting multiple bare confests
 in one session collides on the shared module basename.
+
+``staged_test_regression`` is the commit gate's entry point: it discovers the
+staged test files, groups them by owning pytest-config root, and calls back
+into this module's group-running primitives to run each group (optionally
+with a JUnit XML report per batch, for its staged-vs-baseline comparison).
+
+Boundaries of the top-level fallback, which fires only in a repository whose
+root holds no pytest config::
+
+    repository_root = /repo, holding no pytest config of its own
+    ok:   /repo/alpha/test_a.py, /repo/beta/test_b.py           -> two sessions
+    flag: /repo/pkgs/alpha/test_a.py, /repo/pkgs/beta/test_b.py -> one session
+
+Config-less packages nested under one shared top-level directory run in that
+directory's single session, so the split separates top-level neighbors alone.
+A repository-root ``conftest.py`` stays unloaded for those groups as well: the
+session works from the top-level directory, which leaves the root file outside
+the tree pytest treats as its root.
 """
 
 import os
@@ -24,12 +44,11 @@ from pr_loop_shared_constants.code_rules_gate_constants import (
     CODE_RULES_GATE_PYTHON_ENV_VAR,
     CODE_RULES_GATE_PYTHONPATH_ENV_VAR,
     COMMAND_LINE_ARGUMENT_SEPARATOR_LENGTH,
+    JUNIT_XML_FLAG_PREFIX,
     MAXIMUM_STAGED_PYTEST_COMMAND_LINE_CHARACTERS,
     PYTHON_FILE_EXTENSION,
     PYTHONPATH_ENV_VAR,
     STAGED_PYTEST_TIMEOUT_SECONDS,
-    STAGED_TEST_FAILURE_HEADER,
-    STAGED_TEST_GROUP_FAILURE_MESSAGE,
     TEST_CONFTEST_FILENAME,
 )
 from pr_loop_shared_constants.preflight_constants import (
@@ -102,6 +121,36 @@ def _directory_holds_pytest_config(directory: Path) -> bool:
     return False
 
 
+def _walk_to_owning_test_root(
+    resolved_test_file_path: Path, resolved_repository_root: Path
+) -> tuple[Path, bool]:
+    """Walk up once for the owning test root and whether that root holds a config.
+
+    ::
+
+        resolved_repository_root = /repo, holding no pytest config of its own
+        ok:   /repo/pkg/pytest.ini above /repo/pkg/suite/test_a.py -> (/repo/pkg, True)
+        ok:   /repo/tools/tests/test_b.py                          -> (/repo, False)
+
+    One walk answers both questions a caller has, so the repository root's
+    config is read once per staged file rather than once per question.
+
+    Args:
+        resolved_test_file_path: The already-resolved staged test file.
+        resolved_repository_root: The already-resolved repository root.
+
+    Returns:
+        The nearest config-owning ancestor paired with True, or the repository
+        root paired with False when no ancestor up to it owns a config.
+    """
+    for each_ancestor in resolved_test_file_path.parents:
+        if _directory_holds_pytest_config(each_ancestor):
+            return each_ancestor, True
+        if each_ancestor == resolved_repository_root:
+            return resolved_repository_root, False
+    return resolved_repository_root, False
+
+
 def _resolve_owning_test_root(test_file_path: Path, repository_root: Path) -> Path:
     """Return the nearest ancestor of *test_file_path* owning a pytest config.
 
@@ -112,31 +161,107 @@ def _resolve_owning_test_root(test_file_path: Path, repository_root: Path) -> Pa
     Returns:
         The resolved owning test root directory.
     """
+    owning_root, _has_owning_pytest_config = _walk_to_owning_test_root(
+        test_file_path.resolve(), repository_root.resolve()
+    )
+    return owning_root
+
+
+def _resolved_path_or_none(each_path: Path) -> Path | None:
+    """Return *each_path* resolved, or None when the filesystem refuses to resolve it."""
+    try:
+        return each_path.resolve()
+    except OSError:
+        return None
+
+
+def _top_level_group_root(
+    resolved_test_file_path: Path, resolved_repository_root: Path
+) -> Path:
+    """Return the repository top-level directory *resolved_test_file_path* sits under.
+
+    ::
+
+        resolved_repository_root = /repo
+        ok:   /repo/tools/tests/test_a.py -> /repo/tools
+        ok:   /repo/test_b.py             -> /repo
+        ok:   /elsewhere/test_c.py        -> /repo   (outside the repository)
+
+    Args:
+        resolved_test_file_path: The already-resolved staged test file to place
+            under a top-level directory.
+        resolved_repository_root: The already-resolved repository root.
+
+    Returns:
+        The repository root joined to the file's first repository-relative path
+        component; the repository root itself for a file sitting directly at it
+        or outside it.
+    """
+    try:
+        repository_relative_path = resolved_test_file_path.relative_to(resolved_repository_root)
+    except ValueError:
+        return resolved_repository_root
+    all_relative_parts = repository_relative_path.parts
+    if len(all_relative_parts) <= 1:
+        return resolved_repository_root
+    return resolved_repository_root / all_relative_parts[0]
+
+
+def _group_root_for_test_file(test_file_path: Path, repository_root: Path) -> Path:
+    """Return the pytest session root *test_file_path* runs under.
+
+    ::
+
+        repository_root = /repo, holding no pytest config of its own
+        ok:   /repo/pkg/pytest.ini next to /repo/pkg/suite/test_a.py -> /repo/pkg
+        ok:   /repo/tools/tests/test_b.py                            -> /repo/tools
+        ok:   /repo/test_c.py                                        -> /repo
+        flag: /repo/tools/... and /repo/pipeline/... in one /repo bucket
+
+    A config-owning ancestor always wins. A file no ancestor config owns falls
+    back to its top-level directory, so two config-less packages exposing a
+    same-named top-level module run in separate pytest processes rather than
+    shadowing each other in one. A staged path the filesystem refuses to
+    resolve joins the repository-root group instead of aborting the gate.
+
+    Args:
+        test_file_path: The staged test file to place in a group.
+        repository_root: The repository root that bounds the upward walk.
+
+    Returns:
+        The config-owning ancestor when one exists, the repository root when the
+        root owns the config or the path fails to resolve, else the file's
+        top-level directory.
+    """
     resolved_repository_root = repository_root.resolve()
-    for each_ancestor in test_file_path.resolve().parents:
-        if _directory_holds_pytest_config(each_ancestor):
-            return each_ancestor
-        if each_ancestor == resolved_repository_root:
-            return resolved_repository_root
-    return resolved_repository_root
+    resolved_test_file_path = _resolved_path_or_none(test_file_path)
+    if resolved_test_file_path is None:
+        return resolved_repository_root
+    owning_root, has_owning_pytest_config = _walk_to_owning_test_root(
+        resolved_test_file_path, resolved_repository_root
+    )
+    if has_owning_pytest_config:
+        return owning_root
+    return _top_level_group_root(resolved_test_file_path, resolved_repository_root)
 
 
 def _group_staged_tests_by_root(
     all_test_paths: list[Path], repository_root: Path
 ) -> dict[Path, list[Path]]:
-    """Group *all_test_paths* by their owning pytest-config root.
+    """Group *all_test_paths* by the pytest session root that runs them.
 
     Args:
         all_test_paths: The staged test files to partition.
         repository_root: The repository root that bounds each upward walk.
 
     Returns:
-        A mapping from owning test root to the staged test files under it.
+        A mapping from group root to the staged test files running under it.
+        Every input path lands in exactly one group.
     """
     all_tests_by_root: dict[Path, list[Path]] = {}
     for each_test_path in all_test_paths:
-        owning_root = _resolve_owning_test_root(each_test_path, repository_root)
-        all_tests_by_root.setdefault(owning_root, []).append(each_test_path)
+        group_root = _group_root_for_test_file(each_test_path, repository_root)
+        all_tests_by_root.setdefault(group_root, []).append(each_test_path)
     return all_tests_by_root
 
 
@@ -256,23 +381,36 @@ def _batched_pytest_arguments(
     return all_batches
 
 
-def _pytest_batch_exit_code(all_batch_command: list[str], group_root: Path) -> int:
+def _pytest_batch_exit_code(
+    all_batch_command: list[str],
+    group_root: Path,
+    environment: dict[str, str],
+    junit_xml_path: Path | None = None,
+) -> int:
     """Run one pytest invocation and normalize its exit code.
 
     Args:
         all_batch_command: The full argv for this pytest invocation.
         group_root: The owning test root used as the working directory.
+        environment: The environment the pytest subprocess runs under, which
+            decides where its imports resolve from.
+        junit_xml_path: When given, the batch also writes a JUnit XML report
+            here (via ``--junitxml``), for a caller that needs the per-test
+            pass/fail identities alongside the exit code.
 
     Returns:
         0 when the batch passes or collects no tests; pytest's exit code
         otherwise.
     """
+    full_command = list(all_batch_command)
+    if junit_xml_path is not None:
+        full_command.append(f"{JUNIT_XML_FLAG_PREFIX}{junit_xml_path}")
     pytest_process = subprocess.run(
-        all_batch_command,
+        full_command,
         cwd=str(group_root),
         timeout=STAGED_PYTEST_TIMEOUT_SECONDS,
         check=False,
-        env=_staged_pytest_environment(),
+        env=environment,
     )
     if pytest_process.returncode == PYTEST_NO_TESTS_COLLECTED_EXIT_CODE:
         return 0
@@ -288,19 +426,49 @@ def _pytest_fixed_command(repository_root: Path) -> list[str]:
 
 
 def _first_failing_batch_exit_code(
-    all_fixed_command: list[str], all_batches: list[list[str]], group_root: Path
+    all_fixed_command: list[str],
+    all_batches: list[list[str]],
+    group_root: Path,
+    environment: dict[str, str],
+    junit_xml_dir: Path | None = None,
 ) -> int:
-    """Run each batch and return the first non-zero pytest exit code, or zero."""
+    """Run each batch and return the first non-zero pytest exit code, or zero.
+
+    Args:
+        all_fixed_command: The interpreter-and-pytest prefix shared by every batch.
+        all_batches: The command-line-length-safe argument batches to run in order.
+        group_root: The owning test root used as the working directory.
+        environment: The environment every pytest subprocess runs under.
+        junit_xml_dir: When given, each batch also writes its own JUnit XML report
+            here (one file per batch index), for a caller that needs per-test
+            pass/fail identities alongside the exit code.
+
+    Returns:
+        0 when every batch passes or collects no tests; the first non-zero batch
+        exit code otherwise.
+    """
     first_failing_exit_code = 0
-    for each_batch in all_batches:
-        batch_exit_code = _pytest_batch_exit_code([*all_fixed_command, *each_batch], group_root)
+    for batch_index, each_batch in enumerate(all_batches):
+        junit_xml_path = (
+            junit_xml_dir / f"batch_{batch_index}.xml" if junit_xml_dir is not None else None
+        )
+        batch_exit_code = _pytest_batch_exit_code(
+            [*all_fixed_command, *each_batch],
+            group_root,
+            environment,
+            junit_xml_path=junit_xml_path,
+        )
         if batch_exit_code != 0 and first_failing_exit_code == 0:
             first_failing_exit_code = batch_exit_code
     return first_failing_exit_code
 
 
 def _run_pytest_for_group(
-    group_root: Path, all_group_test_paths: list[Path], repository_root: Path
+    group_root: Path,
+    all_group_test_paths: list[Path],
+    repository_root: Path,
+    junit_xml_dir: Path | None = None,
+    environment: dict[str, str] | None = None,
 ) -> int:
     """Run pytest over one group's test files, split into budget-safe batches.
 
@@ -308,6 +476,13 @@ def _run_pytest_for_group(
         group_root: The owning test root used as the pytest working directory.
         all_group_test_paths: The staged test files that share *group_root*.
         repository_root: The repository root used to resolve a project venv.
+        junit_xml_dir: When given, a JUnit XML report is written per batch under
+            this directory, for a caller that needs per-test pass/fail identities
+            (the regression gate) alongside the exit code.
+        environment: When given, the environment every pytest subprocess runs
+            under; the regression gate passes a baseline environment here so the
+            HEAD run resolves its imports inside the baseline worktree. Defaults
+            to the staged environment.
 
     Returns:
         0 when every batch passes or collects nothing; the first failing batch's
@@ -321,49 +496,10 @@ def _run_pytest_for_group(
         [_relative_pytest_argument(each_path, group_root) for each_path in all_group_test_paths],
         MAXIMUM_STAGED_PYTEST_COMMAND_LINE_CHARACTERS - fixed_command_length,
     )
-    return _first_failing_batch_exit_code(all_fixed_command, all_batches, group_root)
-
-
-def _run_grouped_staged_tests(
-    all_tests_by_root: dict[Path, list[Path]], repository_root: Path
-) -> int:
-    """Run each staged test group and return the first failing exit code, or zero."""
-    first_failing_exit_code = 0
-    for each_group_root in sorted(all_tests_by_root):
-        group_exit_code = _run_pytest_for_group(
-            each_group_root, all_tests_by_root[each_group_root], repository_root
-        )
-        if group_exit_code == 0:
-            continue
-        sys.stderr.write(
-            STAGED_TEST_GROUP_FAILURE_MESSAGE.format(group_root=each_group_root) + "\n"
-        )
-        if first_failing_exit_code == 0:
-            first_failing_exit_code = group_exit_code
-    return first_failing_exit_code
-
-
-def run_staged_test_files(repository_root: Path) -> int:
-    """Run pytest over the staged test files and return the gate exit code.
-
-    ``conftest.py`` files are excluded from collection targets. Pytest still
-    loads them automatically when a nearby staged test runs under the same
-    owning root.
-
-    Args:
-        repository_root: The repository root the staged test files belong to.
-
-    Returns:
-        0 when no collectable test file is staged, when every group collects no
-        tests, or when every group passes. The first failing group's exit code
-        otherwise.
-    """
-    all_test_paths = _staged_test_file_paths(repository_root)
-    all_pytest_targets = _pytest_target_paths(all_test_paths)
-    if not all_pytest_targets:
-        return 0
-    all_tests_by_root = _group_staged_tests_by_root(all_pytest_targets, repository_root)
-    first_failing_exit_code = _run_grouped_staged_tests(all_tests_by_root, repository_root)
-    if first_failing_exit_code != 0:
-        sys.stderr.write(STAGED_TEST_FAILURE_HEADER + "\n")
-    return first_failing_exit_code
+    return _first_failing_batch_exit_code(
+        all_fixed_command,
+        all_batches,
+        group_root,
+        _staged_pytest_environment() if environment is None else environment,
+        junit_xml_dir=junit_xml_dir,
+    )

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

@@ -0,0 +1 @@
+"""Package marker so ``code_rules_gate_parts.tests`` submodules import by dotted path."""

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

@@ -0,0 +1,76 @@
+"""Shared real-git-repository builders for the code_rules_gate_parts test suite.
+
+Every helper drives a real ``git`` subprocess against a throwaway repository
+under ``tmp_path`` — no mocked git state — so a test proves the module works
+against the same git plumbing the live commit hook runs against.
+"""
+
+import subprocess
+from pathlib import Path
+
+from code_rules_gate_parts import git_file_sets
+
+
+def run_git(repository_root: Path, *arguments: str) -> subprocess.CompletedProcess[bytes]:
+    """Run one git subcommand in *repository_root* and raise on failure."""
+    return subprocess.run(
+        ["git", *arguments],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        env=git_file_sets.repository_environment(),
+    )
+
+
+def init_repository(repository_root: Path) -> None:
+    """Initialize *repository_root* as a git repo with one seed commit."""
+    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")
+    (repository_root / "seed.txt").write_text("seed\n", encoding="utf-8")
+    run_git(repository_root, "add", "-A")
+    run_git(repository_root, "commit", "--no-verify", "-m", "seed")
+
+
+def write_and_stage(repository_root: Path, relative_path: str, file_text: str) -> Path:
+    """Write *file_text* to *relative_path* under *repository_root* and stage it."""
+    file_path = repository_root / relative_path
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    file_path.write_text(file_text, encoding="utf-8")
+    run_git(repository_root, "add", "--", relative_path)
+    return file_path
+
+
+def write_commit_and_stage_change(
+    repository_root: Path, relative_path: str, committed_text: str, staged_text: str
+) -> Path:
+    """Commit *committed_text* at *relative_path*, then overwrite and stage *staged_text*.
+
+    Builds the shape a regression check compares: real history at HEAD (what
+    the baseline run sees), then a staged edit on top of it (what the staged
+    run sees).
+    """
+    file_path = write_and_stage(repository_root, relative_path, committed_text)
+    run_git(repository_root, "commit", "--no-verify", "-m", f"seed {relative_path}")
+    file_path.write_text(staged_text, encoding="utf-8")
+    run_git(repository_root, "add", "--", relative_path)
+    return file_path
+
+
+def repository_root_without_pytest_config(tmp_path: Path) -> Path:
+    """Return a fresh repository-root directory holding no pytest configuration."""
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    return repository_root
+
+
+def repository_with_root_pytest_config(tmp_path: Path) -> Path:
+    """Return a fresh repo under *tmp_path* with a root-level ``pytest.ini`` committed."""
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    init_repository(repository_root)
+    (repository_root / "pytest.ini").write_text("[pytest]\n", encoding="utf-8")
+    run_git(repository_root, "add", "-A")
+    run_git(repository_root, "commit", "--no-verify", "-m", "add pytest.ini")
+    return repository_root