claude-dev-env 1.94.0 → 1.95.0

package/hooks/validators/python_style_helpers.py

@@ -0,0 +1,95 @@
+"""Shared source-line and function-discovery helpers for the style checks.
+
+These pure helpers underlie the style checks and the blank-line fixers:
+splitting source into ast-aligned lines, locating function definitions, and
+matching the source newline convention.
+"""
+
+import ast
+from collections.abc import Iterator
+
+FunctionNode = ast.FunctionDef | ast.AsyncFunctionDef
+
+
+def iter_function_definitions(tree: ast.AST) -> Iterator[FunctionNode]:
+    """Yield every function and async-function definition in the tree."""
+    for each_node in ast.walk(tree):
+        if isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            yield each_node
+
+
+def top_level_functions(source: str) -> list[FunctionNode]:
+    """Return the module's top-level function definitions, ordered by line."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+    if not isinstance(tree, ast.Module):
+        return []
+    functions: list[FunctionNode] = [
+        node for node in tree.body if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+    ]
+    functions.sort(key=lambda function_node: function_node.lineno)
+    return functions
+
+
+def function_start_line(function_node: FunctionNode) -> int:
+    """Return the first source line of a function, counting its decorators."""
+    if not function_node.decorator_list:
+        return function_node.lineno
+    return min(each_decorator.lineno for each_decorator in function_node.decorator_list)
+
+
+def gap_is_blank_only(all_gap_lines: list[str]) -> bool:
+    """Return True when every line between two functions is blank."""
+    return all(each_line.strip() == "" for each_line in all_gap_lines)
+
+
+def blank_line_for_source(source: str) -> str:
+    """Return the blank-line string matching the source newline convention.
+
+    Path.read_text() normalizes disk newlines to \\n before this runs, so the
+    CRLF branch serves an in-memory caller that builds a CRLF string directly.
+    """
+    if "\r\n" in source:
+        return "\r\n"
+    return "\n"
+
+
+def _advance_past_newline(source: str, scan_index: int) -> int | None:
+    """Return the index past a CR, LF, or CRLF at scan_index, or None.
+
+    None marks a character that is not a line ending.
+    """
+    character = source[scan_index]
+    if character == "\r":
+        scan_index += 1
+        if scan_index < len(source) and source[scan_index] == "\n":
+            scan_index += 1
+        return scan_index
+    if character == "\n":
+        return scan_index + 1
+    return None
+
+
+def real_newline_lines(source: str) -> list[str]:
+    """Split source on CR, LF, and CRLF only, keeping each line ending.
+
+    Line indices stay aligned with ast line numbers because the split
+    ignores form feed and other control characters ast does not count.
+    """
+    lines: list[str] = []
+    line_start = 0
+    scan_index = 0
+    total_length = len(source)
+    while scan_index < total_length:
+        line_end = _advance_past_newline(source, scan_index)
+        if line_end is None:
+            scan_index += 1
+            continue
+        scan_index = line_end
+        lines.append(source[line_start:scan_index])
+        line_start = scan_index
+    if line_start < total_length:
+        lines.append(source[line_start:])
+    return lines

package/hooks/validators/test_python_style_checks.py

@@ -1,9 +1,6 @@
 """Tests for Python style checks."""
 
 import ast
-import os
-import subprocess
-import sys
 from pathlib import Path
 
 import pytest
@@ -14,8 +11,6 @@ from .python_style_checks import (
     check_imports_at_top,
     check_no_empty_line_after_decorators,
     check_view_function_naming,
-    fix_file,
-    fix_function_spacing,
     validate_file,
 )
 
@@ -138,14 +133,6 @@ def bar() -> None:
     pass
 '''
 
-ONE_BLANK_BEFORE_DECORATED = '''def foo() -> None:
-    pass
-
-@decorator
-def bar() -> None:
-    pass
-'''
-
 COMMENT_BETWEEN_FUNCTIONS = '''def foo() -> None:
     pass
 
@@ -178,8 +165,6 @@ def bar() -> None:
     pass
 '''
 
-FORM_FEED_BETWEEN_FUNCTIONS = "def foo():\n    pass\n\x0c\n\ndef bar():\n    pass\n"
-
 
 class TestImportsAtTop:
     """Test import positioning validation."""
@@ -401,152 +386,3 @@ class TestViolationClass:
         """Violation should format as file:line: message."""
         violation = Violation("test.py", 42, "Test message")
         assert str(violation) == "test.py:42: Test message"
-
-
-class TestAutoFix:
-    """Test auto-fix capabilities."""
-
-    def test_fix_empty_line_after_decorator(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Auto-fix should remove blank line between decorator and function."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("TMPDIR", str(tmp_path))
-        code = '''@decorator
-
-def foo():
-    pass
-'''
-        expected = '''@decorator
-def foo():
-    pass
-'''
-        temp_path = tmp_path / "decorator_module.py"
-        temp_path.write_text(code, encoding="utf-8")
-        fixed = fix_file(temp_path)
-        assert fixed is True
-        result_text = temp_path.read_text()
-        assert result_text.strip() == expected.strip()
-
-    def test_fix_collapses_three_blank_lines_to_two(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Auto-fix should collapse three or more blank lines down to two."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("TMPDIR", str(tmp_path))
-        code = '''def foo():
-    pass
-
-
-
-def bar():
-    pass
-'''
-        expected = '''def foo():
-    pass
-
-
-def bar():
-    pass
-'''
-        temp_path = tmp_path / "spacing_module.py"
-        temp_path.write_text(code, encoding="utf-8")
-        fixed = fix_file(temp_path)
-        assert fixed is True
-        result_text = temp_path.read_text()
-        assert result_text.strip() == expected.strip()
-
-    def test_fix_inserts_missing_blank_lines(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Auto-fix should insert blank lines for under-spaced functions."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("TMPDIR", str(tmp_path))
-        temp_path = tmp_path / "underspaced_module.py"
-        temp_path.write_text(BAD_ONE_LINE_BETWEEN_FUNCTIONS, encoding="utf-8")
-        fixed = fix_file(temp_path)
-        assert fixed is True
-        assert temp_path.read_text() == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
-
-    def test_no_fix_needed_returns_false(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Auto-fix should return False when the file already uses two blank lines."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("TMPDIR", str(tmp_path))
-        code = '''def foo():
-    pass
-
-
-def bar():
-    pass
-'''
-        temp_path = tmp_path / "clean_module.py"
-        temp_path.write_text(code, encoding="utf-8")
-        fixed = fix_file(temp_path)
-        assert fixed is False
-
-    def test_form_feed_gap_stays_check_clean_after_fix(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """A form feed in a blank gap converges without corrupting the file."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("TMPDIR", str(tmp_path))
-        assert (
-            check_blank_lines_between_functions(FORM_FEED_BETWEEN_FUNCTIONS, "test.py")
-            == []
-        )
-        temp_path = tmp_path / "form_feed_module.py"
-        temp_path.write_text(FORM_FEED_BETWEEN_FUNCTIONS, encoding="utf-8")
-        fix_file(temp_path)
-        fixed_text = temp_path.read_text()
-        assert check_blank_lines_between_functions(fixed_text, "test.py") == []
-        assert fix_file(temp_path) is False
-
-
-class TestFixFunctionSpacing:
-    """Test blank-line normalization between top-level functions."""
-
-    def test_inserts_two_blank_lines_when_adjacent(self) -> None:
-        """Adjacent functions gain exactly two blank lines."""
-        fixed_source = fix_function_spacing(BAD_NO_LINE_BETWEEN_FUNCTIONS)
-        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
-
-    def test_inserts_second_blank_line_when_one(self) -> None:
-        """A single blank line grows to exactly two."""
-        fixed_source = fix_function_spacing(BAD_ONE_LINE_BETWEEN_FUNCTIONS)
-        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
-
-    def test_collapses_three_blank_lines_to_two(self) -> None:
-        """Three blank lines collapse to exactly two."""
-        fixed_source = fix_function_spacing(BAD_THREE_LINES_BETWEEN_FUNCTIONS)
-        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
-
-    def test_normalizes_before_decorated_function(self) -> None:
-        """Blank lines before a decorated function normalize to two."""
-        fixed_source = fix_function_spacing(ONE_BLANK_BEFORE_DECORATED)
-        assert fixed_source == DECORATED_NEXT_TWO_LINES
-
-
-class TestDirectInvocation:
-    """Test running the checker as a standalone script."""
-
-    def test_direct_invocation_resolves_hooks_constants(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Direct invocation bootstraps hooks_constants without PYTHONPATH."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("TMPDIR", str(tmp_path))
-        script_path = Path(__file__).resolve().parent / "python_style_checks.py"
-        target_path = tmp_path / "clean_sample.py"
-        target_path.write_text(GOOD_IMPORTS, encoding="utf-8")
-        scrubbed_environment = dict(os.environ)
-        scrubbed_environment.pop("PYTHONPATH", None)
-        completed_process = subprocess.run(
-            [sys.executable, "-S", str(script_path), str(target_path)],
-            capture_output=True,
-            text=True,
-            env=scrubbed_environment,
-        )
-        assert "ModuleNotFoundError" not in completed_process.stderr
-        assert completed_process.returncode == 0

package/hooks/validators/test_python_style_checks_decorator_gap.py

@@ -0,0 +1,119 @@
+"""Tests for multi-line decorator gap detection and repair.
+
+These cover the case where a decorator spans several source lines: the
+validator measures the gap from the decorator's last line to the def, and
+the fixer removes any blank line that falls in that gap.
+"""
+
+import ast
+
+from .python_style_checks import (
+    check_no_empty_line_after_decorators,
+    fix_empty_lines_after_decorators,
+)
+
+MULTILINE_DECORATOR_NO_BLANK = """@parametrize(
+    "value",
+    [1, 2, 3],
+)
+def check_values() -> None:
+    pass
+"""
+
+MULTILINE_DECORATOR_WITH_BLANK = """@parametrize(
+    "value",
+    [1, 2, 3],
+)
+
+def check_values() -> None:
+    pass
+"""
+
+SINGLE_DECORATOR_NO_BLANK = """@decorator
+def foo() -> None:
+    pass
+"""
+
+SINGLE_DECORATOR_WITH_BLANK = """@decorator
+
+def foo() -> None:
+    pass
+"""
+
+STACKED_DECORATORS_WITH_INNER_BLANK = """@first
+
+@second
+def foo() -> None:
+    pass
+"""
+
+STACKED_DECORATORS_NO_BLANK = """@first
+@second
+def foo() -> None:
+    pass
+"""
+
+
+class TestMultilineDecoratorValidator:
+    """Validate gap detection for decorators spanning several lines."""
+
+    def test_multiline_decorator_no_blank_valid(self) -> None:
+        """A multi-line decorator directly above its def passes."""
+        violations = check_no_empty_line_after_decorators(MULTILINE_DECORATOR_NO_BLANK, "test.py")
+        assert violations == []
+
+    def test_multiline_decorator_with_blank_fails(self) -> None:
+        """A blank line after a multi-line decorator is flagged."""
+        violations = check_no_empty_line_after_decorators(MULTILINE_DECORATOR_WITH_BLANK, "test.py")
+        assert len(violations) == 1
+        assert "decorator" in violations[0].message.lower()
+
+    def test_single_decorator_no_blank_valid(self) -> None:
+        """A single-line decorator directly above its def passes."""
+        violations = check_no_empty_line_after_decorators(SINGLE_DECORATOR_NO_BLANK, "test.py")
+        assert violations == []
+
+    def test_single_decorator_with_blank_fails(self) -> None:
+        """A blank line after a single-line decorator is flagged."""
+        violations = check_no_empty_line_after_decorators(SINGLE_DECORATOR_WITH_BLANK, "test.py")
+        assert len(violations) == 1
+        assert violations[0].line == 1
+        assert "decorator" in violations[0].message.lower()
+
+
+class TestMultilineDecoratorFixer:
+    """Validate blank-line removal around decorators spanning several lines."""
+
+    def test_fixer_removes_multiline_decorator_gap(self) -> None:
+        """The fixer removes the blank between a multi-line decorator and its def."""
+        fixed_source = fix_empty_lines_after_decorators(MULTILINE_DECORATOR_WITH_BLANK)
+        ast.parse(fixed_source)
+        assert check_no_empty_line_after_decorators(fixed_source, "test.py") == []
+        assert fixed_source == MULTILINE_DECORATOR_NO_BLANK
+
+    def test_fixer_removes_single_decorator_gap(self) -> None:
+        """The fixer removes the blank after a single-line decorator."""
+        fixed_source = fix_empty_lines_after_decorators(SINGLE_DECORATOR_WITH_BLANK)
+        assert fixed_source == SINGLE_DECORATOR_NO_BLANK
+
+    def test_fixer_removes_blank_between_stacked_decorators(self) -> None:
+        """The fixer removes a blank line separating stacked decorators."""
+        fixed_source = fix_empty_lines_after_decorators(STACKED_DECORATORS_WITH_INNER_BLANK)
+        ast.parse(fixed_source)
+        assert fixed_source == STACKED_DECORATORS_NO_BLANK
+
+    def test_fixer_leaves_clean_multiline_decorator_untouched(self) -> None:
+        """A multi-line decorator with no gap survives the fixer unchanged."""
+        fixed_source = fix_empty_lines_after_decorators(MULTILINE_DECORATOR_NO_BLANK)
+        assert fixed_source == MULTILINE_DECORATOR_NO_BLANK
+
+    def test_fixer_is_idempotent(self) -> None:
+        """Applying the fixer twice matches applying it once."""
+        once = fix_empty_lines_after_decorators(MULTILINE_DECORATOR_WITH_BLANK)
+        twice = fix_empty_lines_after_decorators(once)
+        assert twice == once
+
+    def test_fixer_returns_source_unchanged_on_syntax_error(self) -> None:
+        """Unparseable source is returned unchanged rather than corrupted."""
+        broken_source = "@decorator\n\ndef foo(\n"
+        assert fix_empty_lines_after_decorators(broken_source) == broken_source

package/hooks/validators/test_python_style_fixes.py

@@ -0,0 +1,251 @@
+"""Tests for the blank-line auto-fixers and standalone invocation."""
+
+import ast
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from .python_style_checks import (
+    check_blank_lines_between_functions,
+    fix_file,
+    fix_function_spacing,
+)
+
+GOOD_IMPORTS = """import os
+import sys
+
+def foo() -> None:
+    pass
+"""
+
+GOOD_TWO_LINES_BETWEEN_FUNCTIONS = """def foo() -> None:
+    pass
+
+
+def bar() -> None:
+    pass
+"""
+
+BAD_NO_LINE_BETWEEN_FUNCTIONS = """def foo() -> None:
+    pass
+def bar() -> None:
+    pass
+"""
+
+BAD_ONE_LINE_BETWEEN_FUNCTIONS = """def foo() -> None:
+    pass
+
+def bar() -> None:
+    pass
+"""
+
+BAD_THREE_LINES_BETWEEN_FUNCTIONS = """def foo() -> None:
+    pass
+
+
+
+def bar() -> None:
+    pass
+"""
+
+DECORATED_NEXT_TWO_LINES = """def foo() -> None:
+    pass
+
+
+@decorator
+def bar() -> None:
+    pass
+"""
+
+ONE_BLANK_BEFORE_DECORATED = """def foo() -> None:
+    pass
+
+@decorator
+def bar() -> None:
+    pass
+"""
+
+FORM_FEED_BETWEEN_FUNCTIONS = "def foo():\n    pass\n\x0c\n\ndef bar():\n    pass\n"
+
+
+class TestAutoFix:
+    """Test auto-fix capabilities."""
+
+    def test_fix_empty_line_after_decorator(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Auto-fix should remove blank line between decorator and function."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        code = """@decorator
+
+def foo():
+    pass
+"""
+        expected = """@decorator
+def foo():
+    pass
+"""
+        temp_path = tmp_path / "decorator_module.py"
+        temp_path.write_text(code, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is True
+        result_text = temp_path.read_text()
+        assert result_text.strip() == expected.strip()
+
+    def test_fix_collapses_three_blank_lines_to_two(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Auto-fix should collapse three or more blank lines down to two."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        code = """def foo():
+    pass
+
+
+
+def bar():
+    pass
+"""
+        expected = """def foo():
+    pass
+
+
+def bar():
+    pass
+"""
+        temp_path = tmp_path / "spacing_module.py"
+        temp_path.write_text(code, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is True
+        result_text = temp_path.read_text()
+        assert result_text.strip() == expected.strip()
+
+    def test_fix_inserts_missing_blank_lines(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Auto-fix should insert blank lines for under-spaced functions."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        temp_path = tmp_path / "underspaced_module.py"
+        temp_path.write_text(BAD_ONE_LINE_BETWEEN_FUNCTIONS, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is True
+        assert temp_path.read_text() == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_no_fix_needed_returns_false(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Auto-fix should return False when the file already uses two blank lines."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        code = """def foo():
+    pass
+
+
+def bar():
+    pass
+"""
+        temp_path = tmp_path / "clean_module.py"
+        temp_path.write_text(code, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is False
+
+    def test_form_feed_gap_stays_check_clean_after_fix(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """A form feed in a blank gap converges without corrupting the file."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        assert check_blank_lines_between_functions(FORM_FEED_BETWEEN_FUNCTIONS, "test.py") == []
+        temp_path = tmp_path / "form_feed_module.py"
+        temp_path.write_text(FORM_FEED_BETWEEN_FUNCTIONS, encoding="utf-8")
+        fix_file(temp_path)
+        fixed_text = temp_path.read_text()
+        assert check_blank_lines_between_functions(fixed_text, "test.py") == []
+        assert fix_file(temp_path) is False
+
+
+class TestFixFunctionSpacing:
+    """Test blank-line normalization between top-level functions."""
+
+    def test_inserts_two_blank_lines_when_adjacent(self) -> None:
+        """Adjacent functions gain exactly two blank lines."""
+        fixed_source = fix_function_spacing(BAD_NO_LINE_BETWEEN_FUNCTIONS)
+        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_inserts_second_blank_line_when_one(self) -> None:
+        """A single blank line grows to exactly two."""
+        fixed_source = fix_function_spacing(BAD_ONE_LINE_BETWEEN_FUNCTIONS)
+        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_collapses_three_blank_lines_to_two(self) -> None:
+        """Three blank lines collapse to exactly two."""
+        fixed_source = fix_function_spacing(BAD_THREE_LINES_BETWEEN_FUNCTIONS)
+        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_normalizes_before_decorated_function(self) -> None:
+        """Blank lines before a decorated function normalize to two."""
+        fixed_source = fix_function_spacing(ONE_BLANK_BEFORE_DECORATED)
+        assert fixed_source == DECORATED_NEXT_TWO_LINES
+
+
+class TestDirectInvocation:
+    """Test running the checker as a standalone script."""
+
+    def test_direct_invocation_resolves_hooks_constants(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Direct invocation bootstraps hooks_constants without PYTHONPATH."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        script_path = Path(__file__).resolve().parent / "python_style_checks.py"
+        target_path = tmp_path / "clean_sample.py"
+        target_path.write_text(GOOD_IMPORTS, encoding="utf-8")
+        scrubbed_environment = dict(os.environ)
+        scrubbed_environment.pop("PYTHONPATH", None)
+        completed_process = subprocess.run(
+            [sys.executable, "-S", str(script_path), str(target_path)],
+            capture_output=True,
+            text=True,
+            env=scrubbed_environment,
+            check=False,
+        )
+        assert "ModuleNotFoundError" not in completed_process.stderr
+        assert completed_process.returncode == 0
+
+    def test_direct_invocation_with_hooks_constants_resolvable_off_path(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """First import succeeds while the validators package stays off sys.path."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        synthetic_constants_root = tmp_path / "synthetic_root"
+        constants_package = synthetic_constants_root / "hooks_constants"
+        constants_package.mkdir(parents=True)
+        (constants_package / "__init__.py").write_text("", encoding="utf-8")
+        (constants_package / "python_style_checks_constants.py").write_text(
+            "EXPECTED_BLANK_LINES_BETWEEN_FUNCTIONS = 2\nMINIMUM_ARGUMENT_COUNT = 1\n",
+            encoding="utf-8",
+        )
+        script_path = Path(__file__).resolve().parent / "python_style_checks.py"
+        target_path = tmp_path / "clean_sample.py"
+        target_path.write_text(GOOD_IMPORTS, encoding="utf-8")
+        isolated_environment = dict(os.environ)
+        isolated_environment["PYTHONPATH"] = str(synthetic_constants_root)
+        completed_process = subprocess.run(
+            [sys.executable, str(script_path), str(target_path)],
+            capture_output=True,
+            text=True,
+            env=isolated_environment,
+            check=False,
+        )
+        assert "NameError" not in completed_process.stderr
+        assert completed_process.returncode == 0
+
+    def test_ast_module_import_available(self) -> None:
+        """The ast module the checker depends on parses a trivial module."""
+        assert ast.parse("x = 1").body