claude-dev-env 1.23.1 → 1.25.0

package/hooks/blocking/test_code_rules_enforcer_logger_fstring.py

@@ -0,0 +1,102 @@
+"""Tests for broadened logging f-string detection.
+
+Covers attribute-style calls (logger.*, logging.*, log.*) alongside
+the legacy snake_case helpers (log_info, log_error, ...).
+"""
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+ENFORCER_FILENAME = "code-rules-enforcer.py"
+ENFORCER_MODULE_NAME = "code_rules_enforcer_under_test"
+
+
+def load_enforcer_module() -> ModuleType:
+    enforcer_path = Path(__file__).parent / ENFORCER_FILENAME
+    module_spec = importlib.util.spec_from_file_location(
+        ENFORCER_MODULE_NAME, enforcer_path
+    )
+    assert module_spec is not None
+    assert module_spec.loader is not None
+    enforcer_module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(enforcer_module)
+    return enforcer_module
+
+
+enforcer = load_enforcer_module()
+
+FSTRING_OPENER = 'f"'
+FSTRING_CLOSER = '"'
+
+
+def build_fstring_call(call_prefix: str, body: str) -> str:
+    return call_prefix + "(" + FSTRING_OPENER + body + FSTRING_CLOSER + ")\n"
+
+
+def test_should_flag_logger_info_fstring() -> None:
+    source = build_fstring_call("logger.info", "processing {item}")
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+    assert "f-string in log call" in issues[0]
+
+
+def test_should_flag_logging_error_fstring() -> None:
+    source = build_fstring_call("logging.error", "failed: {err}")
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_flag_log_debug_fstring() -> None:
+    source = build_fstring_call("log.debug", "value={x}")
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_flag_logger_exception_fstring() -> None:
+    source = build_fstring_call("logger.exception", "boom {e}")
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_still_flag_log_info_snake_case() -> None:
+    source = build_fstring_call("log_info", "legacy helper {value}")
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_flag_log_exception_fstring() -> None:
+    source = build_fstring_call("log_exception", "snake exception {e}")
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_flag_uppercase_fstring_prefix() -> None:
+    source = 'logger.info(F"uppercase {item}")\n'
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_flag_raw_fstring_prefix_rf() -> None:
+    source = 'logger.info(rf"raw path {path}")\n'
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_flag_raw_fstring_prefix_fr() -> None:
+    source = 'logger.info(fr"raw path {path}")\n'
+    issues = enforcer.check_logging_fstrings(source)
+    assert len(issues) == 1
+
+
+def test_should_allow_logger_info_with_format_args() -> None:
+    source = 'logger.info("processing %s", item)\n'
+    issues = enforcer.check_logging_fstrings(source)
+    assert issues == []
+
+
+def test_should_allow_log_info_with_format_args() -> None:
+    source = 'log_info("processing %s", item)\n'
+    issues = enforcer.check_logging_fstrings(source)
+    assert issues == []

package/hooks/blocking/test_code_rules_enforcer_magic_allowlist.py

@@ -0,0 +1,76 @@
+"""Tests for magic-value allowlist alignment with CODE_RULES §HOOK-ENFORCED.
+
+CODE_RULES.md and .github/copilot-instructions.md both state that only
+0, 1, and -1 (plus their float forms 0.0, 1.0) are exempt from the
+magic-value check. Prior to this change, the hook silently allowed 2
+and 100 as well, making the hook more permissive than the written rule.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_enforcer_module() -> ModuleType:
+    module_path = Path(__file__).parent / "code-rules-enforcer.py"
+    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+
+PRODUCTION_FILE_PATH = "packages/claude-dev-env/hooks/blocking/example_production.py"
+
+
+def test_check_magic_values_should_flag_literal_two_in_function_body() -> None:
+    source = (
+        "def compute_something(amount):\n"
+        "    threshold = amount * 2\n"
+        "    return threshold\n"
+    )
+    issues = code_rules_enforcer.check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert any(
+        issue.endswith("Magic value 2 - extract to named constant") for issue in issues
+    ), f"Expected magic-value issue for literal 2, got: {issues}"
+
+
+def test_check_magic_values_should_flag_literal_one_hundred_in_function_body() -> None:
+    source = (
+        "def compute_percentage(amount):\n"
+        "    scaled = amount * 100\n"
+        "    return scaled\n"
+    )
+    issues = code_rules_enforcer.check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert any(
+        issue.endswith("Magic value 100 - extract to named constant") for issue in issues
+    ), f"Expected magic-value issue for literal 100, got: {issues}"
+
+
+def test_check_magic_values_should_still_allow_zero_one_minus_one() -> None:
+    source = (
+        "def pick_sign(flag: int) -> int:\n"
+        "    first = 0\n"
+        "    second = 1\n"
+        "    third = -1\n"
+        "    return first + second + third + flag\n"
+    )
+    issues = code_rules_enforcer.check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Expected no issues for 0/1/-1, got: {issues}"
+
+
+def test_check_magic_values_should_still_allow_float_zero_and_float_one() -> None:
+    source = (
+        "def pick_float(flag: float) -> float:\n"
+        "    low = 0.0\n"
+        "    high = 1.0\n"
+        "    return low + high + flag\n"
+    )
+    issues = code_rules_enforcer.check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Expected no issues for 0.0/1.0, got: {issues}"

package/hooks/blocking/test_code_rules_enforcer_naming_pattern.py

@@ -0,0 +1,176 @@
+"""Unit tests for code-rules-enforcer boolean naming-pattern check."""
+
+import importlib.util
+import pathlib
+import sys
+
+
+_HOOK_DIRECTORY = pathlib.Path(__file__).parent
+if str(_HOOK_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIRECTORY))
+
+_hook_spec = importlib.util.spec_from_file_location(
+    "code_rules_enforcer",
+    _HOOK_DIRECTORY / "code-rules-enforcer.py",
+)
+assert _hook_spec is not None
+assert _hook_spec.loader is not None
+_hook_module = importlib.util.module_from_spec(_hook_spec)
+_hook_spec.loader.exec_module(_hook_module)
+check_boolean_naming = _hook_module.check_boolean_naming
+validate_content = _hook_module.validate_content
+
+
+PRODUCTION_FILE_PATH = "src/app/feature.py"
+TEST_FILE_PATH = "src/app/test_feature.py"
+CONFIG_FILE_PATH = "src/config/settings.py"
+WORKFLOW_FILE_PATH = "src/workflow/orders_tab.py"
+HOOK_FILE_PATH = "/home/user/.claude/hooks/blocking/my_hook.py"
+EXPECTED_PREFIX_GUIDANCE = "prefix with is_/has_/should_/can_"
+
+
+def _assert_flags_name(issues: list[str], name: str, line_number: int) -> None:
+    expected = f"Line {line_number}: Boolean {name} - {EXPECTED_PREFIX_GUIDANCE}"
+    assert expected in issues, f"expected {expected!r} in {issues!r}"
+
+
+def test_should_flag_boolean_assignment_without_is_prefix() -> None:
+    source = "def f() -> None:\n    valid = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    _assert_flags_name(issues, "valid", 2)
+    assert len(issues) == 1
+
+
+def test_should_flag_boolean_assignment_without_has_prefix() -> None:
+    source = "def f() -> None:\n    permission = False\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    _assert_flags_name(issues, "permission", 2)
+    assert len(issues) == 1
+
+
+def test_should_allow_is_prefix() -> None:
+    source = "def f() -> None:\n    is_valid = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_allow_has_prefix() -> None:
+    source = "def f() -> None:\n    has_permission = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_allow_should_prefix() -> None:
+    source = "def f() -> None:\n    should_retry = False\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_allow_can_prefix() -> None:
+    source = "def f() -> None:\n    can_edit = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_allow_uppercase_constant_boolean() -> None:
+    source = "DEBUG_MODE = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_allow_annotated_boolean_with_valid_prefix() -> None:
+    source = "def f() -> None:\n    is_active: bool = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_flag_annotated_boolean_without_prefix() -> None:
+    source = "def f() -> None:\n    active: bool = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    _assert_flags_name(issues, "active", 2)
+    assert len(issues) == 1
+
+
+def test_should_skip_test_files() -> None:
+    source = "def f() -> None:\n    valid = True\n"
+    issues = check_boolean_naming(source, TEST_FILE_PATH)
+    assert issues == []
+
+
+def test_should_skip_bare_bool_annotation_without_literal_value() -> None:
+    source = "def f() -> None:\n    active: bool\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_skip_annotated_bool_with_non_literal_rhs() -> None:
+    source = "def f() -> None:\n    active: bool = compute()\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_flag_tuple_unpacking_of_bool_constants() -> None:
+    source = "def f() -> None:\n    valid, permitted = True, False\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    _assert_flags_name(issues, "valid", 2)
+    _assert_flags_name(issues, "permitted", 2)
+    assert len(issues) == 2
+
+
+def test_should_flag_walrus_boolean_assignment() -> None:
+    source = "def f() -> None:\n    if (matched := True):\n        pass\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    _assert_flags_name(issues, "matched", 2)
+    assert len(issues) == 1
+
+
+def test_should_allow_class_body_uppercase_constant_boolean() -> None:
+    source = "class FeatureFlags:\n    DEBUG_MODE: bool = True\n    TRACING_ENABLED = False\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_skip_hook_infrastructure_files() -> None:
+    source = "def f() -> None:\n    valid = True\n"
+    issues = check_boolean_naming(source, HOOK_FILE_PATH)
+    assert issues == []
+
+
+def test_should_skip_config_files() -> None:
+    source = "class Settings:\n    enabled: bool = True\n"
+    issues = check_boolean_naming(source, CONFIG_FILE_PATH)
+    assert issues == []
+
+
+def test_should_skip_workflow_registry_files() -> None:
+    source = "def f() -> None:\n    active = True\n"
+    issues = check_boolean_naming(source, WORKFLOW_FILE_PATH)
+    assert issues == []
+
+
+def test_should_cap_issues_at_three() -> None:
+    source = (
+        "def f() -> None:\n"
+        "    one = True\n"
+        "    two = False\n"
+        "    three = True\n"
+        "    four = False\n"
+        "    five = True\n"
+    )
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert len(issues) == 3
+
+
+def test_should_not_flag_syntax_error_as_issue() -> None:
+    source = "def f(:\n    valid = True\n"
+    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_validate_content_invokes_boolean_naming_check() -> None:
+    source = "def f() -> None:\n    valid = True\n"
+    issues = validate_content(source, PRODUCTION_FILE_PATH, old_content="")
+    matching_issues = [issue for issue in issues if "Boolean valid" in issue]
+    assert matching_issues, (
+        f"expected validate_content to surface the boolean-naming issue, got {issues!r}"
+    )

package/hooks/blocking/test_code_rules_enforcer_type_checking_scope.py

@@ -0,0 +1,112 @@
+"""Unit tests for TYPE_CHECKING-scoped import exemption in code-rules-enforcer."""
+
+import importlib.util
+import pathlib
+import sys
+
+_HOOK_DIR = pathlib.Path(__file__).parent
+if str(_HOOK_DIR) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIR))
+
+hook_spec = importlib.util.spec_from_file_location(
+    "code_rules_enforcer",
+    _HOOK_DIR / "code-rules-enforcer.py",
+)
+assert hook_spec is not None
+assert hook_spec.loader is not None
+hook_module = importlib.util.module_from_spec(hook_spec)
+hook_spec.loader.exec_module(hook_module)
+check_imports_at_top = hook_module.check_imports_at_top
+
+
+def test_should_allow_import_inside_if_type_checking_block() -> None:
+    content = (
+        "from typing import TYPE_CHECKING\n"
+        "\n"
+        "if TYPE_CHECKING:\n"
+        "    from foo import Bar\n"
+    )
+    issues = check_imports_at_top(content)
+    assert issues == []
+
+
+def test_should_flag_runtime_import_inside_function_even_if_file_uses_type_checking() -> (
+    None
+):
+    content = (
+        "from typing import TYPE_CHECKING\n"
+        "\n"
+        "if TYPE_CHECKING:\n"
+        "    from foo import Bar\n"
+        "\n"
+        "def baz():\n"
+        "    import os\n"
+        "    return os\n"
+    )
+    issues = check_imports_at_top(content)
+    assert len(issues) == 1
+    assert issues[0].startswith("Line 7:")
+    assert "Import inside function" in issues[0]
+
+
+def test_should_still_allow_top_level_imports() -> None:
+    content = (
+        "import os\n"
+        "import sys\n"
+        "from pathlib import Path\n"
+        "\n"
+        "def do_something():\n"
+        "    return os.getcwd()\n"
+    )
+    issues = check_imports_at_top(content)
+    assert issues == []
+
+
+def test_should_flag_import_inside_function_in_file_without_type_checking() -> None:
+    content = "import os\n\ndef do_something():\n    import sys\n    return sys\n"
+    issues = check_imports_at_top(content)
+    assert len(issues) == 1
+    assert "Import inside function" in issues[0]
+
+
+def test_should_allow_typing_dot_type_checking_block() -> None:
+    content = "import typing\n\nif typing.TYPE_CHECKING:\n    from foo import Bar\n"
+    issues = check_imports_at_top(content)
+    assert issues == []
+
+
+def test_should_flag_function_import_after_type_checking_block_ends() -> None:
+    content = (
+        "from typing import TYPE_CHECKING\n"
+        "\n"
+        "if TYPE_CHECKING:\n"
+        "    from foo import Bar\n"
+        "\n"
+        "def helper():\n"
+        "    from json import loads\n"
+        "    return loads\n"
+    )
+    issues = check_imports_at_top(content)
+    assert len(issues) == 1
+    assert "Import inside function" in issues[0]
+
+
+def test_should_track_only_innermost_type_checking_block() -> None:
+    """Pin documented single-level tracking: after a nested inner block ends,
+    subsequent function-body imports at the outer block's indent are flagged
+    as if outside any TYPE_CHECKING scope. See check_imports_at_top docstring.
+    """
+    content = (
+        "from typing import TYPE_CHECKING\n"
+        "\n"
+        "if TYPE_CHECKING:\n"
+        "    def helper():\n"
+        "        if TYPE_CHECKING:\n"
+        "            from a import A\n"
+        "        from b import B\n"
+        "        return B\n"
+    )
+    issues = check_imports_at_top(content)
+    assert len(issues) == 1
+    assert issues[0].startswith("Line 7:")
+    assert "Import inside function" in issues[0]