claude-dev-env 1.0.0

package/hooks/validators/test_files/bad_inline_imports.py

@@ -0,0 +1,37 @@
+"""Test file with inline imports inside functions - this is a violation."""
+from unittest.mock import patch
+
+from django.test import TestCase, Client
+
+
+class ImportEvolutionsViewTest(TestCase):
+    def setUp(self) -> None:
+        self.luna_l1 = "Luna L1"
+        self.luna_l2 = "Lunara L2"
+        self.luna_l3 = "Lunabella L3"
+
+    @patch('example_app.views.settings')
+    def test_dry_run_shows_preview_without_saving(self, mock_settings: patch) -> None:
+        from pathlib import Path
+        from tempfile import TemporaryDirectory
+        with TemporaryDirectory() as temp_dir:
+            metadata_path = Path(temp_dir) / 'data' / 'metadata.json'
+            print(metadata_path)
+
+    @patch('example_app.views.settings')
+    def test_apply_mode_sets_evolves_from(self, mock_settings: patch) -> None:
+        from pathlib import Path
+        from tempfile import TemporaryDirectory
+        with TemporaryDirectory() as temp_dir:
+            metadata_path = Path(temp_dir) / 'data' / 'metadata.json'
+            print(metadata_path)
+
+    @patch('example_app.views.settings')
+    def test_skips_already_linked_evolutions(self, mock_settings: patch) -> None:
+        self.luna_l2 = self.luna_l1
+
+        from pathlib import Path
+        from tempfile import TemporaryDirectory
+        with TemporaryDirectory() as temp_dir:
+            metadata_path = Path(temp_dir) / 'data' / 'metadata.json'
+            print(metadata_path)

package/hooks/validators/test_files/management/commands/cmd_01_no_debug_check.py

@@ -0,0 +1,10 @@
+"""Management command with NO DEBUG check - SHOULD BE CAUGHT"""
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Test command without DEBUG check"
+
+    def handle(self, *args, **options):
+        print("Running without DEBUG check")
+        return "Success"

package/hooks/validators/test_files/management/commands/cmd_02_proper_debug_check.py

@@ -0,0 +1,14 @@
+"""Management command with proper DEBUG check - should NOT be caught"""
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test command with proper DEBUG check"
+
+    def handle(self, *args, **options):
+        if not settings.DEBUG:
+            raise CommandError("This command can only be run in DEBUG mode")
+
+        print("Running in DEBUG mode")
+        return "Success"

package/hooks/validators/test_files/management/commands/cmd_03_debug_check_with_return.py

@@ -0,0 +1,14 @@
+"""Management command with DEBUG check using return - should NOT be caught"""
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Test command with DEBUG check using return"
+
+    def handle(self, *args, **options):
+        if not settings.DEBUG:
+            return "ERROR: This command requires DEBUG mode"
+
+        print("Running in DEBUG mode")
+        return "Success"

package/hooks/validators/test_files/management/commands/cmd_04_imported_DEBUG.py

@@ -0,0 +1,14 @@
+"""Management command using imported DEBUG - EDGE CASE: should be caught (wrong pattern)"""
+from django.conf import settings, DEBUG
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test command with imported DEBUG"
+
+    def handle(self, *args, **options):
+        if not DEBUG:
+            raise CommandError("This command can only be run in DEBUG mode")
+
+        print("Running in DEBUG mode")
+        return "Success"

package/hooks/validators/test_files/management/commands/cmd_05_debug_check_in_helper.py

@@ -0,0 +1,16 @@
+"""Management command with DEBUG check in helper function - EDGE CASE: should be caught"""
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test command with DEBUG check in helper"
+
+    def _check_debug(self):
+        if not settings.DEBUG:
+            raise CommandError("This command can only be run in DEBUG mode")
+
+    def handle(self, *args, **options):
+        self._check_debug()
+        print("Running in DEBUG mode")
+        return "Success"

package/hooks/validators/test_files/management/commands/cmd_06_debug_check_late.py

@@ -0,0 +1,22 @@
+"""Management command with DEBUG check after 5 statements - EDGE CASE: might be caught or not"""
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test command with late DEBUG check"
+
+    def handle(self, *args, **options):
+        stmt1 = "one"
+        stmt2 = "two"
+        stmt3 = "three"
+        stmt4 = "four"
+        stmt5 = "five"
+        stmt6 = "six"
+
+        # DEBUG check on statement 8 (beyond first 5)
+        if not settings.DEBUG:
+            raise CommandError("This command can only be run in DEBUG mode")
+
+        print("Running in DEBUG mode")
+        return "Success"

package/hooks/validators/test_files/management/commands/cmd_07_positive_debug_check.py

@@ -0,0 +1,15 @@
+"""Management command with positive DEBUG check - EDGE CASE: check line 186-187 logic"""
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test command with positive DEBUG check"
+
+    def handle(self, *args, **options):
+        if settings.DEBUG:
+            print("Running in DEBUG mode")
+        else:
+            raise CommandError("This command can only be run in DEBUG mode")
+
+        return "Success"

package/hooks/validators/test_files/management/commands/cmd_08_debug_with_and.py

@@ -0,0 +1,14 @@
+"""Management command with DEBUG and other condition - EDGE CASE: might not be caught"""
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test command with DEBUG AND condition"
+
+    def handle(self, *args, **options):
+        if not settings.DEBUG and True:
+            raise CommandError("This command can only be run in DEBUG mode")
+
+        print("Running")
+        return "Success"

package/hooks/validators/test_files/not_management_command.py

@@ -0,0 +1,10 @@
+"""Regular file NOT in management/commands/ - should NOT be checked"""
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "This is not in management/commands/ directory"
+
+    def handle(self, *args, **options):
+        print("No DEBUG check needed")
+        return "Success"

package/hooks/validators/test_files/skip_decorators/test_01_simple_skip.py

@@ -0,0 +1,8 @@
+"""Test file with simple @skip decorator - SHOULD BE CAUGHT"""
+import pytest
+from unittest import skip
+
+
+@skip
+def test_something():
+    assert True

package/hooks/validators/test_files/skip_decorators/test_02_pytest_skipif.py

@@ -0,0 +1,8 @@
+"""Test file with @pytest.mark.skipif - SHOULD BE CAUGHT"""
+import pytest
+import sys
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Windows not supported")
+def test_something():
+    assert True

package/hooks/validators/test_files/skip_decorators/test_03_unittest_skipIf.py

@@ -0,0 +1,8 @@
+"""Test file with @unittest.skipIf - SHOULD BE CAUGHT"""
+import unittest
+
+
+class TestCase(unittest.TestCase):
+    @unittest.skipIf(True, "Reason")
+    def test_something(self):
+        self.assertTrue(True)

package/hooks/validators/test_files/skip_decorators/test_04_skip_with_parens.py

@@ -0,0 +1,8 @@
+"""Test file with @skip() with parentheses - SHOULD BE CAUGHT"""
+import pytest
+from unittest import skip
+
+
+@skip("test reason")
+def test_something():
+    assert True

package/hooks/validators/test_files/skip_decorators/test_05_xfail.py

@@ -0,0 +1,7 @@
+"""Test file with @pytest.mark.xfail - should NOT be caught (allowed)"""
+import pytest
+
+
+@pytest.mark.xfail(reason="Known bug")
+def test_something():
+    assert False

package/hooks/validators/test_files/skip_decorators/test_06_custom_skip.py

@@ -0,0 +1,11 @@
+"""Test file with custom @skip_on_windows - should NOT be caught"""
+import pytest
+
+
+def skip_on_windows(func):
+    return func
+
+
+@skip_on_windows
+def test_something():
+    assert True

package/hooks/validators/test_files/skip_decorators/test_07_capital_Skip.py

@@ -0,0 +1,8 @@
+"""Test file with @Skip (capital S) - EDGE CASE: might slip through"""
+import unittest
+from unittest import skip as Skip
+
+
+@Skip
+def test_something():
+    assert True

package/hooks/validators/test_files/skip_decorators/test_08_skipUnless.py

@@ -0,0 +1,7 @@
+"""Test file with @unittest.skipUnless - SHOULD BE CAUGHT"""
+import unittest
+
+
+@unittest.skipUnless(False, "Reason")
+def test_something():
+    assert True

package/hooks/validators/test_files/skip_decorators/test_09_pytest_mark_skip_simple.py

@@ -0,0 +1,7 @@
+"""Test file with @pytest.mark.skip (no args) - SHOULD BE CAUGHT"""
+import pytest
+
+
+@pytest.mark.skip
+def test_something():
+    assert True

package/hooks/validators/test_files/test_async_functions.py

@@ -0,0 +1,45 @@
+"""Test file with async functions to verify AsyncFunctionDef support."""
+
+import asyncio
+
+
+def dummy_decorator(func):
+    """Simple decorator for testing."""
+    return func
+
+
+async def async_func_with_decorator_spacing():
+    """Async function - should pass."""
+    await asyncio.sleep(0)
+
+
+@dummy_decorator
+async def async_func_with_empty_line_after_decorator():
+    """Should fail - empty line after decorator."""
+    await asyncio.sleep(0)
+
+
+async def async_func_one():
+    """First async function."""
+    await asyncio.sleep(0)
+
+
+async def async_func_two():
+    """Second async function - should pass with single empty line."""
+    await asyncio.sleep(0)
+
+
+async def async_func_three():
+    """Third async function - should pass."""
+    await asyncio.sleep(0)
+
+
+
+async def async_func_four():
+    """Fourth async function - should fail with multiple empty lines."""
+    await asyncio.sleep(0)
+
+
+def regular_func():
+    """Regular function between async functions."""
+    pass

package/hooks/validators/test_files/test_purecomponent/PureComponentExample.tsx

@@ -0,0 +1,7 @@
+import { PureComponent } from 'react';
+
+class OptimizedList extends PureComponent {
+    render() {
+        return <ul>Items</ul>;
+    }
+}

package/hooks/validators/test_files/test_purecomponent/ReactPureComponentExample.tsx

@@ -0,0 +1,7 @@
+import React from 'react';
+
+class Dashboard extends React.PureComponent {
+    render() {
+        return <div>Dashboard</div>;
+    }
+}

package/hooks/validators/test_git_checks.py

@@ -0,0 +1,295 @@
+"""Tests for git and GitHub validation checks."""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import List
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from git_checks import (
+    Violation,
+    check_single_commit_when_pr_exists,
+    check_draft_pr_state,
+    main,
+)
+
+
+class TestSingleCommitWhenPrExists:
+    """Test that PR branches have exactly 1 commit ahead of base."""
+
+    @patch("git_checks.subprocess.run")
+    def test_no_pr_returns_empty(self, mock_run: MagicMock) -> None:
+        """When no PR exists, check should return empty list."""
+        mock_run.return_value = MagicMock(returncode=0, stdout="[]", stderr="")
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_single_commit_ahead_passes(self, mock_run: MagicMock) -> None:
+        """Exactly 1 commit ahead should pass."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout='[{"baseRefName": "main", "number": 123}]', stderr=""),
+            MagicMock(returncode=0, stdout="1", stderr=""),
+        ]
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_zero_commits_ahead_fails(self, mock_run: MagicMock) -> None:
+        """Zero commits ahead should fail."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout='[{"baseRefName": "main", "number": 123}]', stderr=""),
+            MagicMock(returncode=0, stdout="0", stderr=""),
+        ]
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert len(violations) == 1
+        assert violations[0].file == ""
+        assert violations[0].line == 0
+        assert "exactly 1 commit" in violations[0].message
+        assert "0 commits" in violations[0].message
+
+    @patch("git_checks.subprocess.run")
+    def test_multiple_commits_ahead_fails(self, mock_run: MagicMock) -> None:
+        """More than 1 commit ahead should fail."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout='[{"baseRefName": "main", "number": 123}]', stderr=""),
+            MagicMock(returncode=0, stdout="3", stderr=""),
+        ]
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert len(violations) == 1
+        assert "exactly 1 commit" in violations[0].message
+        assert "3 commits" in violations[0].message
+
+    @patch("git_checks.subprocess.run")
+    def test_gh_cli_not_available_returns_empty(self, mock_run: MagicMock) -> None:
+        """When gh CLI not available, should return empty (warning, not failure)."""
+        mock_run.side_effect = FileNotFoundError("gh not found")
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_git_not_available_returns_empty(self, mock_run: MagicMock) -> None:
+        """When git not available, should return empty."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout='[{"baseRefName": "main", "number": 123}]', stderr=""),
+            FileNotFoundError("git not found"),
+        ]
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_extracts_base_branch_from_pr_info(self, mock_run: MagicMock) -> None:
+        """Should extract base branch name from gh pr list JSON output."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout='[{"baseRefName": "develop", "number": 123}]', stderr=""),
+            MagicMock(returncode=0, stdout="2", stderr=""),
+        ]
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert len(violations) == 1
+        mock_run.assert_any_call(
+            ["git", "rev-list", "--count", "develop..HEAD"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=30,
+        )
+
+    @patch("git_checks.subprocess.run")
+    def test_non_numeric_commit_count_returns_empty(self, mock_run: MagicMock) -> None:
+        """When git rev-list returns non-numeric output, should return empty."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout='[{"baseRefName": "main", "number": 123}]', stderr=""),
+            MagicMock(returncode=0, stdout="not a number\n", stderr=""),
+        ]
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_gh_timeout_returns_empty(self, mock_run: MagicMock) -> None:
+        """When gh CLI times out, should return empty (warning, not failure)."""
+        mock_run.side_effect = subprocess.TimeoutExpired(cmd=["gh", "pr", "list"], timeout=30)
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_git_timeout_returns_empty(self, mock_run: MagicMock) -> None:
+        """When git times out, should return empty (warning, not failure)."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout='[{"baseRefName": "main", "number": 123}]', stderr=""),
+            subprocess.TimeoutExpired(cmd=["git", "rev-list"], timeout=30),
+        ]
+
+        violations = check_single_commit_when_pr_exists()
+
+        assert violations == []
+
+
+class TestDraftPrState:
+    """Test that PR is in draft state when pushing review fixes."""
+
+    @patch("git_checks.subprocess.run")
+    def test_no_pr_returns_empty(self, mock_run: MagicMock) -> None:
+        """When no PR exists, check should return empty list."""
+        mock_run.return_value = MagicMock(returncode=0, stdout="[]", stderr="")
+
+        violations = check_draft_pr_state()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_draft_pr_passes(self, mock_run: MagicMock) -> None:
+        """Draft PR should pass."""
+        mock_run.return_value = MagicMock(
+            returncode=0,
+            stdout='[{"number": 123, "isDraft": true}]',
+            stderr=""
+        )
+
+        violations = check_draft_pr_state()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_non_draft_pr_fails(self, mock_run: MagicMock) -> None:
+        """Non-draft PR should fail."""
+        mock_run.return_value = MagicMock(
+            returncode=0,
+            stdout='[{"number": 123, "isDraft": false}]',
+            stderr=""
+        )
+
+        violations = check_draft_pr_state()
+
+        assert len(violations) == 1
+        assert violations[0].file == ""
+        assert violations[0].line == 0
+        assert "draft" in violations[0].message.lower()
+        assert "gh pr ready --undo" in violations[0].message
+
+    @patch("git_checks.subprocess.run")
+    def test_gh_cli_not_available_returns_empty(self, mock_run: MagicMock) -> None:
+        """When gh CLI not available, should return empty (warning, not failure)."""
+        mock_run.side_effect = FileNotFoundError("gh not found")
+
+        violations = check_draft_pr_state()
+
+        assert violations == []
+
+    @patch("git_checks.subprocess.run")
+    def test_gh_timeout_returns_empty(self, mock_run: MagicMock) -> None:
+        """When gh CLI times out, should return empty (warning, not failure)."""
+        mock_run.side_effect = subprocess.TimeoutExpired(cmd=["gh", "pr", "list"], timeout=30)
+
+        violations = check_draft_pr_state()
+
+        assert violations == []
+
+
+class TestMain:
+    """Test main function integration."""
+
+    @patch("git_checks.check_single_commit_when_pr_exists")
+    @patch("git_checks.check_draft_pr_state")
+    def test_main_no_violations_exits_zero(
+        self,
+        mock_draft: MagicMock,
+        mock_commit: MagicMock,
+        capsys,
+    ) -> None:
+        """main() should exit 0 when no violations found."""
+        mock_commit.return_value = []
+        mock_draft.return_value = []
+
+        with pytest.raises(SystemExit) as exc_info:
+            main()
+
+        assert exc_info.value.code == 0
+        captured = capsys.readouterr()
+        assert captured.out == ""
+
+    @patch("git_checks.check_single_commit_when_pr_exists")
+    @patch("git_checks.check_draft_pr_state")
+    def test_main_with_violations_exits_one(
+        self,
+        mock_draft: MagicMock,
+        mock_commit: MagicMock,
+        capsys,
+    ) -> None:
+        """main() should exit 1 and print violations when found."""
+        mock_commit.return_value = [
+            Violation(file="", line=0, message="Branch has 3 commits ahead")
+        ]
+        mock_draft.return_value = []
+
+        with pytest.raises(SystemExit) as exc_info:
+            main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Branch has 3 commits ahead" in captured.out
+
+    @patch("git_checks.check_single_commit_when_pr_exists")
+    @patch("git_checks.check_draft_pr_state")
+    def test_main_prints_violations_without_file_line(
+        self,
+        mock_draft: MagicMock,
+        mock_commit: MagicMock,
+        capsys,
+    ) -> None:
+        """main() should print git violations without file:line: prefix."""
+        mock_commit.return_value = []
+        mock_draft.return_value = [
+            Violation(file="", line=0, message="PR must be in draft state")
+        ]
+
+        with pytest.raises(SystemExit) as exc_info:
+            main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert captured.out == "PR must be in draft state\n"
+        assert ":0:" not in captured.out
+
+    @patch("git_checks.check_single_commit_when_pr_exists")
+    @patch("git_checks.check_draft_pr_state")
+    def test_main_prints_all_violations(
+        self,
+        mock_draft: MagicMock,
+        mock_commit: MagicMock,
+        capsys,
+    ) -> None:
+        """main() should print all violations."""
+        mock_commit.return_value = [
+            Violation(file="", line=0, message="Branch has 2 commits")
+        ]
+        mock_draft.return_value = [
+            Violation(file="", line=0, message="PR not in draft")
+        ]
+
+        with pytest.raises(SystemExit) as exc_info:
+            main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Branch has 2 commits" in captured.out
+        assert "PR not in draft" in captured.out

package/hooks/validators/test_good.tsx

@@ -0,0 +1,5 @@
+import React from 'react';
+
+function GoodComponent() {
+    return <div>Good</div>;
+}