claude-dev-env 1.0.0

package/hooks/validators/test_python_style_checks.py

@@ -0,0 +1,439 @@
+"""Tests for Python style checks."""
+
+import ast
+import tempfile
+from pathlib import Path
+from typing import List
+
+import pytest
+
+from python_style_checks import (
+    Violation,
+    check_imports_at_top,
+    check_no_empty_line_after_decorators,
+    check_single_empty_line_between_functions,
+    check_view_function_naming,
+    validate_file,
+)
+
+
+# Test data: Code samples
+GOOD_IMPORTS = '''import os
+import sys
+from typing import List
+
+def foo() -> None:
+    pass
+'''
+
+BAD_IMPORTS_AFTER_CODE = '''def foo() -> None:
+    pass
+
+import os
+'''
+
+BAD_IMPORTS_AFTER_CONSTANT = '''MY_CONSTANT = 42
+
+import os
+'''
+
+GOOD_DECORATOR_NO_BLANK = '''@decorator
+def foo() -> None:
+    pass
+'''
+
+BAD_DECORATOR_WITH_BLANK = '''@decorator
+
+def foo() -> None:
+    pass
+'''
+
+GOOD_SINGLE_LINE_BETWEEN_FUNCTIONS = '''def foo() -> None:
+    pass
+
+def bar() -> None:
+    pass
+'''
+
+BAD_NO_LINE_BETWEEN_FUNCTIONS = '''def foo() -> None:
+    pass
+def bar() -> None:
+    pass
+'''
+
+BAD_MULTIPLE_LINES_BETWEEN_FUNCTIONS = '''def foo() -> None:
+    pass
+
+
+def bar() -> None:
+    pass
+'''
+
+GOOD_VIEW_NAMING = '''def user_profile_view(request):
+    pass
+
+def get_tasks_view(request, user_id):
+    pass
+'''
+
+BAD_VIEW_NAMING = '''def user_profile(request):
+    pass
+
+def getTasks(request, user_id):
+    pass
+'''
+
+GOOD_NON_VIEW_FUNCTION = '''def helper_function(data):
+    pass
+
+def process_data(items):
+    pass
+'''
+
+# Async function test samples
+ASYNC_GOOD_DECORATOR_NO_BLANK = '''import asyncio
+
+@asyncio.coroutine
+async def foo() -> None:
+    await asyncio.sleep(0)
+'''
+
+ASYNC_BAD_DECORATOR_WITH_BLANK = '''import asyncio
+
+@asyncio.coroutine
+
+async def foo() -> None:
+    await asyncio.sleep(0)
+'''
+
+ASYNC_GOOD_SINGLE_LINE_BETWEEN = '''import asyncio
+
+async def foo() -> None:
+    await asyncio.sleep(0)
+
+async def bar() -> None:
+    await asyncio.sleep(0)
+'''
+
+ASYNC_BAD_MULTIPLE_LINES_BETWEEN = '''import asyncio
+
+async def foo() -> None:
+    await asyncio.sleep(0)
+
+
+async def bar() -> None:
+    await asyncio.sleep(0)
+'''
+
+ASYNC_GOOD_VIEW_NAMING = '''from django.http import HttpRequest, HttpResponse
+
+async def user_profile_view(request: HttpRequest) -> HttpResponse:
+    return HttpResponse("profile")
+
+async def get_tasks_view(request: HttpRequest, user_id: int) -> HttpResponse:
+    return HttpResponse("tasks")
+'''
+
+ASYNC_BAD_VIEW_NAMING = '''from django.http import HttpRequest, HttpResponse
+
+async def user_profile(request: HttpRequest) -> HttpResponse:
+    return HttpResponse("profile")
+
+async def getTasks(request: HttpRequest, user_id: int) -> HttpResponse:
+    return HttpResponse("tasks")
+'''
+
+ASYNC_BAD_INLINE_IMPORT = '''import asyncio
+
+async def foo() -> None:
+    import json
+    await asyncio.sleep(0)
+'''
+
+
+class TestImportsAtTop:
+    """Test import positioning validation."""
+
+    def test_imports_at_top_valid(self) -> None:
+        """All imports at top should pass."""
+        tree = ast.parse(GOOD_IMPORTS)
+        violations = check_imports_at_top(tree, "test.py")
+        assert violations == []
+
+    def test_import_after_function(self) -> None:
+        """Import after function should fail."""
+        tree = ast.parse(BAD_IMPORTS_AFTER_CODE)
+        violations = check_imports_at_top(tree, "test.py")
+        assert len(violations) == 1
+        assert violations[0].line == 4
+        assert "import" in violations[0].message.lower()
+
+    def test_import_after_constant(self) -> None:
+        """Import after constant should fail."""
+        tree = ast.parse(BAD_IMPORTS_AFTER_CONSTANT)
+        violations = check_imports_at_top(tree, "test.py")
+        assert len(violations) == 1
+        assert violations[0].line == 3
+
+    def test_async_inline_import_fails(self) -> None:
+        """Import inside async function should fail."""
+        tree = ast.parse(ASYNC_BAD_INLINE_IMPORT)
+        violations = check_imports_at_top(tree, "test.py")
+        assert len(violations) == 1
+        assert "inside function" in violations[0].message.lower()
+
+
+class TestNoEmptyLineAfterDecorators:
+    """Test decorator spacing validation."""
+
+    def test_no_blank_line_valid(self) -> None:
+        """Decorator directly above function should pass."""
+        violations = check_no_empty_line_after_decorators(
+            GOOD_DECORATOR_NO_BLANK, "test.py"
+        )
+        assert violations == []
+
+    def test_blank_line_after_decorator_fails(self) -> None:
+        """Blank line after decorator should fail."""
+        violations = check_no_empty_line_after_decorators(
+            BAD_DECORATOR_WITH_BLANK, "test.py"
+        )
+        assert len(violations) == 1
+        assert violations[0].line == 1
+        assert "decorator" in violations[0].message.lower()
+
+    def test_async_no_blank_line_valid(self) -> None:
+        """Decorator directly above async function should pass."""
+        violations = check_no_empty_line_after_decorators(
+            ASYNC_GOOD_DECORATOR_NO_BLANK, "test.py"
+        )
+        assert violations == []
+
+    def test_async_blank_line_after_decorator_fails(self) -> None:
+        """Blank line after decorator on async function should fail."""
+        violations = check_no_empty_line_after_decorators(
+            ASYNC_BAD_DECORATOR_WITH_BLANK, "test.py"
+        )
+        assert len(violations) == 1
+        assert violations[0].line == 3
+        assert "decorator" in violations[0].message.lower()
+
+
+class TestSingleEmptyLineBetweenFunctions:
+    """Test function spacing validation."""
+
+    def test_single_line_valid(self) -> None:
+        """Exactly one blank line should pass."""
+        violations = check_single_empty_line_between_functions(
+            GOOD_SINGLE_LINE_BETWEEN_FUNCTIONS, "test.py"
+        )
+        assert violations == []
+
+    def test_no_line_between_functions_fails(self) -> None:
+        """No blank line should fail."""
+        violations = check_single_empty_line_between_functions(
+            BAD_NO_LINE_BETWEEN_FUNCTIONS, "test.py"
+        )
+        assert len(violations) == 1
+        assert "empty line" in violations[0].message.lower()
+
+    def test_multiple_lines_between_functions_fails(self) -> None:
+        """Multiple blank lines should fail."""
+        violations = check_single_empty_line_between_functions(
+            BAD_MULTIPLE_LINES_BETWEEN_FUNCTIONS, "test.py"
+        )
+        assert len(violations) == 1
+        assert "empty line" in violations[0].message.lower()
+
+    def test_async_single_line_valid(self) -> None:
+        """Exactly one blank line between async functions should pass."""
+        violations = check_single_empty_line_between_functions(
+            ASYNC_GOOD_SINGLE_LINE_BETWEEN, "test.py"
+        )
+        assert violations == []
+
+    def test_async_multiple_lines_fails(self) -> None:
+        """Multiple blank lines between async functions should fail."""
+        violations = check_single_empty_line_between_functions(
+            ASYNC_BAD_MULTIPLE_LINES_BETWEEN, "test.py"
+        )
+        assert len(violations) == 1
+        assert "empty line" in violations[0].message.lower()
+
+
+class TestViewFunctionNaming:
+    """Test view function naming validation."""
+
+    def test_view_functions_named_correctly(self) -> None:
+        """View functions ending with _view should pass."""
+        tree = ast.parse(GOOD_VIEW_NAMING)
+        violations = check_view_function_naming(tree, "views.py")
+        assert violations == []
+
+    def test_view_functions_without_suffix_fail(self) -> None:
+        """View functions not ending with _view should fail."""
+        tree = ast.parse(BAD_VIEW_NAMING)
+        violations = check_view_function_naming(tree, "views.py")
+        assert len(violations) == 2
+        assert all("_view" in v.message for v in violations)
+
+    def test_non_view_file_ignored(self) -> None:
+        """Non-views.py files should be ignored."""
+        tree = ast.parse(BAD_VIEW_NAMING)
+        violations = check_view_function_naming(tree, "utils.py")
+        assert violations == []
+
+    def test_non_request_function_ignored(self) -> None:
+        """Functions without request parameter should be ignored."""
+        tree = ast.parse(GOOD_NON_VIEW_FUNCTION)
+        violations = check_view_function_naming(tree, "views.py")
+        assert violations == []
+
+    def test_async_view_functions_named_correctly(self) -> None:
+        """Async view functions ending with _view should pass."""
+        tree = ast.parse(ASYNC_GOOD_VIEW_NAMING)
+        violations = check_view_function_naming(tree, "views.py")
+        assert violations == []
+
+    def test_async_view_functions_without_suffix_fail(self) -> None:
+        """Async view functions not ending with _view should fail."""
+        tree = ast.parse(ASYNC_BAD_VIEW_NAMING)
+        violations = check_view_function_naming(tree, "views.py")
+        assert len(violations) == 2
+        assert all("_view" in v.message for v in violations)
+
+
+class TestValidateFile:
+    """Test file validation integration."""
+
+    def test_valid_file_passes(self) -> None:
+        """File with no violations should pass."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(GOOD_IMPORTS)
+            f.flush()
+            temp_path = Path(f.name)
+
+        try:
+            violations = validate_file(temp_path)
+            assert violations == []
+        finally:
+            temp_path.unlink()
+
+    def test_invalid_file_returns_violations(self) -> None:
+        """File with violations should return them."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(BAD_IMPORTS_AFTER_CODE)
+            f.flush()
+            temp_path = Path(f.name)
+
+        try:
+            violations = validate_file(temp_path)
+            assert len(violations) > 0
+            assert all(isinstance(v, Violation) for v in violations)
+        finally:
+            temp_path.unlink()
+
+    def test_syntax_error_returns_violation(self) -> None:
+        """File with syntax error should return violation."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("def foo(\n")  # Invalid syntax
+            f.flush()
+            temp_path = Path(f.name)
+
+        try:
+            violations = validate_file(temp_path)
+            assert len(violations) == 1
+            assert "syntax error" in violations[0].message.lower()
+        finally:
+            temp_path.unlink()
+
+
+class TestViolationClass:
+    """Test Violation dataclass."""
+
+    def test_violation_creation(self) -> None:
+        """Violation should store file, line, message."""
+        v = Violation("test.py", 42, "Test message")
+        assert v.file == "test.py"
+        assert v.line == 42
+        assert v.message == "Test message"
+
+    def test_violation_str_format(self) -> None:
+        """Violation should format as file:line: message."""
+        v = Violation("test.py", 42, "Test message")
+        assert str(v) == "test.py:42: Test message"
+
+
+class TestAutoFix:
+    """Test auto-fix capabilities."""
+
+    def test_fix_empty_line_after_decorator(self) -> None:
+        """Auto-fix should remove blank line between decorator and function."""
+        code = '''@decorator
+
+def foo():
+    pass
+'''
+        expected = '''@decorator
+def foo():
+    pass
+'''
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
+            temp_file.write(code)
+            temp_path = Path(temp_file.name)
+
+        try:
+            from python_style_checks import fix_file
+            fixed = fix_file(temp_path)
+            assert fixed is True
+            result = temp_path.read_text()
+            assert result.strip() == expected.strip()
+        finally:
+            temp_path.unlink()
+
+    def test_fix_multiple_blank_lines_between_functions(self) -> None:
+        """Auto-fix should collapse multiple blank lines to single."""
+        code = '''def foo():
+    pass
+
+
+def bar():
+    pass
+'''
+        expected = '''def foo():
+    pass
+
+def bar():
+    pass
+'''
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
+            temp_file.write(code)
+            temp_path = Path(temp_file.name)
+
+        try:
+            from python_style_checks import fix_file
+            fixed = fix_file(temp_path)
+            assert fixed is True
+            result = temp_path.read_text()
+            assert result.strip() == expected.strip()
+        finally:
+            temp_path.unlink()
+
+    def test_no_fix_needed_returns_false(self) -> None:
+        """Auto-fix should return False when no fixes needed."""
+        code = '''def foo():
+    pass
+
+def bar():
+    pass
+'''
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
+            temp_file.write(code)
+            temp_path = Path(temp_file.name)
+
+        try:
+            from python_style_checks import fix_file
+            fixed = fix_file(temp_path)
+            assert fixed is False
+        finally:
+            temp_path.unlink()

package/hooks/validators/test_react_checks.py

@@ -0,0 +1,213 @@
+"""Tests for React class component validator."""
+
+import pytest
+from pathlib import Path
+from react_checks import check_no_class_components, Violation
+
+
+def test_class_component_extends_component_should_fail(tmp_path: Path) -> None:
+    """Class component using Component should be detected."""
+    test_file = tmp_path / "BadComponent.tsx"
+    test_file.write_text("""import { Component } from 'react';
+
+class UserProfile extends Component {
+    render() {
+        return <div>Profile</div>;
+    }
+}
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 1
+    assert violations[0].file == str(test_file)
+    assert violations[0].line == 3
+    assert "class component" in violations[0].message.lower()
+
+
+def test_class_component_extends_react_component_should_fail(tmp_path: Path) -> None:
+    """Class component using React.Component should be detected."""
+    test_file = tmp_path / "BadComponent.tsx"
+    test_file.write_text("""import React from 'react';
+
+class TaskList extends React.Component {
+    render() {
+        return <ul>Tasks</ul>;
+    }
+}
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 1
+    assert violations[0].file == str(test_file)
+    assert violations[0].line == 3
+
+
+def test_class_component_extends_purecomponent_should_fail(tmp_path: Path) -> None:
+    """Class component using PureComponent should be detected."""
+    test_file = tmp_path / "BadPureComponent.tsx"
+    test_file.write_text("""import { PureComponent } from 'react';
+
+class OptimizedList extends PureComponent {
+    render() {
+        return <ul>Items</ul>;
+    }
+}
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 1
+    assert violations[0].file == str(test_file)
+    assert violations[0].line == 3
+    assert "class component" in violations[0].message.lower()
+
+
+def test_class_component_extends_react_purecomponent_should_fail(tmp_path: Path) -> None:
+    """Class component using React.PureComponent should be detected."""
+    test_file = tmp_path / "BadReactPureComponent.tsx"
+    test_file.write_text("""import React from 'react';
+
+class Dashboard extends React.PureComponent {
+    render() {
+        return <div>Dashboard</div>;
+    }
+}
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 1
+    assert violations[0].file == str(test_file)
+    assert violations[0].line == 3
+    assert "class component" in violations[0].message.lower()
+
+
+def test_functional_component_should_pass(tmp_path: Path) -> None:
+    """Functional components should not trigger violations."""
+    test_file = tmp_path / "GoodComponent.tsx"
+    test_file.write_text("""import React from 'react';
+
+function UserProfile() {
+    return <div>Profile</div>;
+}
+
+export const TaskList: React.FC = () => {
+    return <ul>Tasks</ul>;
+};
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 0
+
+
+def test_error_boundary_class_should_pass(tmp_path: Path) -> None:
+    """Error boundary classes should be allowed (documented exception)."""
+    test_file = tmp_path / "ErrorBoundary.tsx"
+    test_file.write_text("""import { Component, ErrorInfo, ReactNode } from 'react';
+
+interface Props {
+    children: ReactNode;
+}
+
+interface State {
+    hasError: boolean;
+}
+
+class ErrorBoundary extends Component<Props, State> {
+    state = { hasError: false };
+
+    static getDerivedStateFromError(): State {
+        return { hasError: true };
+    }
+
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void {
+        console.error('Error caught:', error, errorInfo);
+    }
+
+    render() {
+        if (this.state.hasError) {
+            return <h1>Something went wrong.</h1>;
+        }
+        return this.props.children;
+    }
+}
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 0
+
+
+def test_multiple_files_with_mixed_violations(tmp_path: Path) -> None:
+    """Should detect violations across multiple files."""
+    good_file = tmp_path / "GoodComponent.tsx"
+    good_file.write_text("""function MyComponent() {
+    return <div>Good</div>;
+}
+""")
+
+    bad_file1 = tmp_path / "BadComponent1.tsx"
+    bad_file1.write_text("""import { Component } from 'react';
+
+class Bad1 extends Component {
+    render() { return <div>Bad</div>; }
+}
+""")
+
+    bad_file2 = tmp_path / "BadComponent2.tsx"
+    bad_file2.write_text("""import React from 'react';
+
+class Bad2 extends React.Component {
+    render() { return <div>Bad</div>; }
+}
+""")
+
+    violations = check_no_class_components([
+        str(good_file),
+        str(bad_file1),
+        str(bad_file2)
+    ])
+
+    assert len(violations) == 2
+    assert any(str(bad_file1) in v.file for v in violations)
+    assert any(str(bad_file2) in v.file for v in violations)
+
+
+def test_non_react_class_should_pass(tmp_path: Path) -> None:
+    """Regular TypeScript classes should not trigger violations."""
+    test_file = tmp_path / "RegularClass.ts"
+    test_file.write_text("""class UserService {
+    fetchUser(id: string): Promise<User> {
+        return fetch(`/api/users/${id}`).then(r => r.json());
+    }
+}
+
+class TaskManager extends EventEmitter {
+    private tasks: Task[] = [];
+}
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 0
+
+
+def test_jsx_file_with_class_component_should_fail(tmp_path: Path) -> None:
+    """Should detect class components in .jsx files too."""
+    test_file = tmp_path / "OldComponent.jsx"
+    test_file.write_text("""const React = require('react');
+
+class OldComponent extends React.Component {
+    render() {
+        return <div>Old style</div>;
+    }
+}
+""")
+
+    violations = check_no_class_components([str(test_file)])
+
+    assert len(violations) == 1
+    assert violations[0].file == str(test_file)

package/hooks/validators/test_results.txt

@@ -0,0 +1,25 @@
+============================= test session starts =============================
+platform -- Python X.Y.Z, pytest-X.Y.Z -- python
+cachedir: .pytest_cache
+benchmark: 5.1.0 (defaults: timer=time.perf_counter disable_gc=False min_rounds=5 min_time=0.000005 max_time=1.0 calibration_precision=10 warmup=False warmup_iterations=100000)
+rootdir: hooks/validators
+plugins: anyio-4.9.0, asyncio-1.1.0, benchmark-5.1.0, cov-6.2.1, mock-3.14.1
+asyncio: mode=Mode.STRICT, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
+collecting ... collected 88 items / 2 errors
+
+=================================== ERRORS ====================================
+___ ERROR collecting test_files/skip_decorators/test_04_skip_with_parens.py ___
+test_files\skip_decorators\test_04_skip_with_parens.py:6: in <module>
+    @skip()
+     ^^^^^^
+E   TypeError: skip() missing 1 required positional argument: 'reason'
+_____________ ERROR collecting test_files/test_async_functions.py _____________
+test_files\test_async_functions.py:11: in <module>
+    @asyncio.coroutine
+     ^^^^^^^^^^^^^^^^^
+E   AttributeError: module 'asyncio' has no attribute 'coroutine'. Did you mean: 'coroutines'?
+=========================== short test summary info ===========================
+ERROR test_files/skip_decorators/test_04_skip_with_parens.py - TypeError: ski...
+ERROR test_files/test_async_functions.py - AttributeError: module 'asyncio' h...
+!!!!!!!!!!!!!!!!!!! Interrupted: 2 errors during collection !!!!!!!!!!!!!!!!!!!
+============================== 2 errors in 0.14s ==============================

package/hooks/validators/test_ruff_integration.py

@@ -0,0 +1,27 @@
+"""Tests for ruff integration module."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+from ruff_integration import RuffResult, check_ruff_available, run_ruff_check
+
+
+def test_ruff_result_dataclass() -> None:
+    """Test RuffResult dataclass creation."""
+    result = RuffResult(passed=True, output="test", fixed_count=0)
+    assert result.passed is True
+    assert result.output == "test"
+    assert result.fixed_count == 0
+
+
+def test_check_ruff_available_returns_false_when_not_installed() -> None:
+    """Test that check_ruff_available returns False when ruff not found."""
+    with patch("subprocess.run", side_effect=FileNotFoundError):
+        assert check_ruff_available() is False
+
+
+def test_run_ruff_check_returns_passed_for_empty_files() -> None:
+    """Test that run_ruff_check passes with no files."""
+    result = run_ruff_check([])
+    assert result.passed is True
+    assert "No files" in result.output