test: comprehensive test coverage from 31% to 87% (#90)

* test: comprehensive test coverage from 31% to 87% (#90)

Add 1885 tests across 22 new test files covering all scripts/ and
.github/scripts/ modules. Key areas: validate_agents, create_prs,
apply_autofix, bedrock_helper, notify_slack, security_consensus,
generate-docstrings, generate-type-hints, run_stochastic_local,
compute_pass_rates, readme_checker, and validate_schema.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* fix: mock requests via sys.modules for CI without requests installed

The .github/scripts/notify_slack.py imports requests inside its
function body. CI doesn't have requests installed, so tests must
use patch.dict("sys.modules", ...) instead of patch("requests.post").

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: Tony363

coverage.json

@@ -0,0 +1,22 @@
+"""Conftest for .github/scripts tests.
+
+Mocks the `anthropic` module since it's not installed in the test environment.
+The .github/scripts files do `import anthropic` at module level and sys.exit(1)
+if it's missing. We need to provide a fake module before importing them.
+"""
+
+import sys
+import types
+from unittest.mock import MagicMock
+
+
+def _ensure_anthropic_mock():
+    """Install a fake anthropic module if the real one isn't available."""
+    if "anthropic" not in sys.modules:
+        mock_mod = types.ModuleType("anthropic")
+        mock_mod.Anthropic = MagicMock
+        mock_mod.APIError = type("APIError", (Exception,), {})
+        sys.modules["anthropic"] = mock_mod
+
+
+_ensure_anthropic_mock()

tests/github_scripts/__init__.py

@@ -0,0 +1,167 @@
+"""Tests for .github/scripts/apply-docstrings.py pure functions."""
+
+import importlib
+import json
+import sys
+from pathlib import Path
+
+scripts_dir = str(Path(__file__).parent.parent.parent / ".github" / "scripts")
+if scripts_dir not in sys.path:
+    sys.path.insert(0, scripts_dir)
+
+mod = importlib.import_module("apply-docstrings")
+
+is_protected = mod.is_protected
+find_function_info = mod.find_function_info
+find_def_end_line = mod.find_def_end_line
+get_body_indent = mod.get_body_indent
+format_docstring = mod.format_docstring
+apply_docstrings = mod.apply_docstrings
+
+
+class TestIsProtected:
+    """Tests for is_protected."""
+
+    def test_workflow_protected(self):
+        assert is_protected(".github/workflows/ci.yml") is True
+
+    def test_agents_protected(self):
+        assert is_protected("agents/core/dev.md") is True
+
+    def test_regular_ok(self):
+        assert is_protected("src/main.py") is False
+
+
+class TestFindFunctionInfo:
+    """Tests for find_function_info."""
+
+    def test_finds_simple_function(self):
+        source = "def foo():\n    pass\n"
+        info = find_function_info(source, "foo")
+        assert info is not None
+        assert info["lineno"] == 1
+        assert info["has_docstring"] is False
+
+    def test_finds_function_with_docstring(self):
+        source = 'def bar():\n    """Hello."""\n    pass\n'
+        info = find_function_info(source, "bar")
+        assert info is not None
+        assert info["has_docstring"] is True
+
+    def test_finds_async_function(self):
+        source = "async def baz():\n    pass\n"
+        info = find_function_info(source, "baz")
+        assert info is not None
+        assert info["lineno"] == 1
+
+    def test_returns_none_for_missing(self):
+        source = "def foo():\n    pass\n"
+        info = find_function_info(source, "nonexistent")
+        assert info is None
+
+    def test_returns_none_for_syntax_error(self):
+        source = "def foo(:\n    broken syntax"
+        info = find_function_info(source, "foo")
+        assert info is None
+
+
+class TestFindDefEndLine:
+    """Tests for find_def_end_line."""
+
+    def test_single_line_def(self):
+        lines = ["def foo():\n", "    pass\n"]
+        assert find_def_end_line(lines, 0) == 0
+
+    def test_multiline_def(self):
+        lines = [
+            "def foo(\n",
+            "    x,\n",
+            "    y,\n",
+            "):\n",
+            "    pass\n",
+        ]
+        assert find_def_end_line(lines, 0) == 3
+
+
+class TestGetBodyIndent:
+    """Tests for get_body_indent."""
+
+    def test_standard_indent(self):
+        lines = ["def foo():\n", "    pass\n"]
+        indent = get_body_indent(lines, 0)
+        assert indent == "    "
+
+    def test_nested_indent(self):
+        lines = ["class X:\n", "    def foo():\n", "        pass\n"]
+        indent = get_body_indent(lines, 1)
+        assert indent == "        "
+
+
+class TestFormatDocstring:
+    """Tests for format_docstring."""
+
+    def test_single_line(self):
+        result = format_docstring("Short summary.", "    ")
+        assert len(result) == 1
+        assert result[0] == '    """Short summary."""\n'
+
+    def test_multi_line(self):
+        result = format_docstring("Summary.\n\nArgs:\n    x: value", "    ")
+        assert result[0] == '    """Summary.\n'
+        assert result[-1] == '    """\n'
+
+
+class TestApplyDocstrings:
+    """Tests for apply_docstrings integration."""
+
+    def test_empty_suggestions(self, tmp_path: Path):
+        p = tmp_path / "suggestions.json"
+        p.write_text(json.dumps({"functions_documented": []}))
+
+        result = apply_docstrings(str(p))
+        assert result["files_modified"] == 0
+        assert result["docstrings_inserted"] == 0
+
+    def test_applies_docstring_to_file(self, tmp_path: Path):
+        # Create target file
+        target = tmp_path / "target.py"
+        target.write_text("def greet():\n    return 'hello'\n")
+
+        suggestions = {
+            "functions_documented": [
+                {
+                    "file": str(target),
+                    "function": "greet",
+                    "docstring": "Return a greeting.",
+                }
+            ]
+        }
+        p = tmp_path / "suggestions.json"
+        p.write_text(json.dumps(suggestions))
+
+        result = apply_docstrings(str(p))
+        assert result["docstrings_inserted"] == 1
+        assert result["files_modified"] == 1
+
+        modified = target.read_text()
+        assert '"""Return a greeting."""' in modified
+
+    def test_skips_existing_docstring(self, tmp_path: Path):
+        target = tmp_path / "target.py"
+        target.write_text('def greet():\n    """Existing."""\n    return "hello"\n')
+
+        suggestions = {
+            "functions_documented": [
+                {
+                    "file": str(target),
+                    "function": "greet",
+                    "docstring": "New docstring.",
+                }
+            ]
+        }
+        p = tmp_path / "suggestions.json"
+        p.write_text(json.dumps(suggestions))
+
+        result = apply_docstrings(str(p))
+        assert result["skipped_existing"] == 1
+        assert result["docstrings_inserted"] == 0

tests/github_scripts/conftest.py

@@ -0,0 +1,140 @@
+"""Tests for .github/scripts/apply-type-hints.py pure functions."""
+
+import importlib
+import json
+import sys
+from pathlib import Path
+
+scripts_dir = str(Path(__file__).parent.parent.parent / ".github" / "scripts")
+if scripts_dir not in sys.path:
+    sys.path.insert(0, scripts_dir)
+
+mod = importlib.import_module("apply-type-hints")
+
+is_protected = mod.is_protected
+find_function_line = mod.find_function_line
+find_def_end_line = mod.find_def_end_line
+get_existing_imports = mod.get_existing_imports
+find_last_import_line = mod.find_last_import_line
+normalize_import = mod.normalize_import
+apply_type_hints = mod.apply_type_hints
+
+
+class TestIsProtected:
+    """Tests for is_protected."""
+
+    def test_github_scripts_protected(self):
+        assert is_protected(".github/scripts/helper.py") is True
+
+    def test_claude_dir_protected(self):
+        assert is_protected(".claude/rules/test.md") is True
+
+    def test_validate_agents_protected(self):
+        assert is_protected("scripts/validate_agents.py") is True
+
+    def test_regular_ok(self):
+        assert is_protected("src/service.py") is False
+
+
+class TestFindFunctionLine:
+    """Tests for find_function_line."""
+
+    def test_simple_function(self):
+        source = "x = 1\ndef foo():\n    pass\n"
+        assert find_function_line(source, "foo") == 2
+
+    def test_async_function(self):
+        source = "async def bar():\n    pass\n"
+        assert find_function_line(source, "bar") == 1
+
+    def test_not_found(self):
+        source = "def foo(): pass\n"
+        assert find_function_line(source, "bar") is None
+
+    def test_syntax_error(self):
+        source = "def incomplete("
+        assert find_function_line(source, "incomplete") is None
+
+
+class TestFindDefEndLine:
+    """Tests for find_def_end_line."""
+
+    def test_single_line(self):
+        lines = ["def foo():\n", "    pass\n"]
+        assert find_def_end_line(lines, 0) == 0
+
+    def test_multiline_signature(self):
+        lines = ["def foo(\n", "    a: int,\n", "    b: str,\n", ") -> None:\n", "    pass\n"]
+        assert find_def_end_line(lines, 0) == 3
+
+
+class TestGetExistingImports:
+    """Tests for get_existing_imports."""
+
+    def test_finds_imports(self):
+        source = "import os\nfrom pathlib import Path\n\nx = 1"
+        imports = get_existing_imports(source)
+        assert "import os" in imports
+        assert "from pathlib import Path" in imports
+        assert len(imports) == 2
+
+    def test_no_imports(self):
+        source = "x = 1\ny = 2"
+        imports = get_existing_imports(source)
+        assert imports == set()
+
+
+class TestFindLastImportLine:
+    """Tests for find_last_import_line."""
+
+    def test_finds_last(self):
+        lines = ["import os\n", "from sys import path\n", "\n", "x = 1\n"]
+        assert find_last_import_line(lines) == 1
+
+    def test_no_imports(self):
+        lines = ["x = 1\n", "y = 2\n"]
+        assert find_last_import_line(lines) == -1
+
+
+class TestNormalizeImport:
+    """Tests for normalize_import."""
+
+    def test_strips_whitespace(self):
+        result = normalize_import("  from typing import Any  ")
+        assert result == ["from typing import Any"]
+
+
+class TestApplyTypeHints:
+    """Tests for apply_type_hints integration."""
+
+    def test_empty_suggestions(self, tmp_path: Path):
+        p = tmp_path / "suggestions.json"
+        p.write_text(json.dumps({"functions_annotated": []}))
+
+        result = apply_type_hints(str(p))
+        assert result["files_modified"] == 0
+        assert result["functions_applied"] == 0
+
+    def test_applies_hint_to_file(self, tmp_path: Path):
+        target = tmp_path / "target.py"
+        target.write_text("def greet(name):\n    return f'hello {name}'\n")
+
+        suggestions = {
+            "functions_annotated": [
+                {
+                    "file": str(target),
+                    "function": "greet",
+                    "typed_signature": "def greet(name: str) -> str:",
+                    "imports_needed": [],
+                }
+            ]
+        }
+        p = tmp_path / "suggestions.json"
+        p.write_text(json.dumps(suggestions))
+
+        result = apply_type_hints(str(p))
+        assert result["functions_applied"] == 1
+
+        modified = target.read_text()
+        assert "name: str" in modified
+        assert "-> str" in modified