collab-runtime 0.2.9__py3-none-any.whl

tests/backend/unit/scripts/test_generate_tests.py

@@ -0,0 +1,305 @@
+"""Tests for scripts/generate_tests.py."""
+
+from __future__ import annotations
+
+import runpy
+import sys
+
+import pytest
+
+from tests.backend.unit.scripts._helpers import load_script_module
+
+gen = load_script_module("generate_tests.py", "generate_tests_under_test")
+
+
+class TestCodeAnalyzer:
+    def test_analyze_finds_public_functions_and_classes(self, tmp_path):
+        src = tmp_path / "sample.py"
+        src.write_text(
+            "class Foo:\n    pass\n\n"
+            "def bar():\n    pass\n\n"
+            "def _private():\n    pass\n",
+            encoding="utf-8",
+        )
+        analyzer = gen.CodeAnalyzer(str(src))
+        entities = analyzer.analyze()
+        names = [e[0] for e in entities]
+        assert "Foo" in names
+        assert "bar" in names
+        assert "_private" not in names
+
+    def test_analyze_async_and_bom_and_syntax_error(self, tmp_path, capsys):
+        src = tmp_path / "async_mod.py"
+        src.write_text("async def fetch():\n    return 1\n", encoding="utf-8")
+        assert gen.CodeAnalyzer(str(src)).analyze() == [("fetch", "function")]
+
+        bom = tmp_path / "bom_mod.py"
+        bom.write_text("\ufeffdef hello():\n    return 'hi'\n", encoding="utf-8")
+        assert gen.CodeAnalyzer(str(bom)).analyze() == [("hello", "function")]
+
+        bad = tmp_path / "bad.py"
+        bad.write_text("def broken(:\n    pass\n", encoding="utf-8")
+        assert gen.CodeAnalyzer(str(bad)).analyze() == []
+        assert "Syntax error" in capsys.readouterr().out
+
+
+class TestTestGenerator:
+    def test_detect_category(self):
+        assert gen.TestGenerator("src/routes/api.py").category == "functional"
+        assert gen.TestGenerator("src/lock_client.py").category == "unit"
+        assert gen.TestGenerator("src/unknown.py").category == "unit"
+
+    def test_generate_empty_entities(self):
+        tg = gen.TestGenerator("src/foo.py")
+        assert tg.generate([]) == ""
+
+    def test_generate_import_block_for_src(self):
+        tg = gen.TestGenerator("src/my_module.py")
+        code = tg.generate([("MyClass", "class"), ("do_it", "function")])
+        assert "import pytest" in code
+        assert "from src.my_module import (" in code
+        assert "class TestMyClass:" in code
+        assert "test_do_it_is_callable" in code
+
+    def test_generate_path_loader_block_for_scripts(self):
+        tg = gen.TestGenerator("scripts/cleanup.py")
+        code = tg.generate([("clean_default", "function")])
+        assert "import importlib.util" in code
+        assert "def _find_repo_root() -> Path:" in code
+        assert "module_under_test = _load_module()" in code
+        assert "clean_default = module_under_test.clean_default" in code
+
+    def test_get_import_path(self, tmp_path):
+        tg = gen.TestGenerator("src/foo.py")
+        assert tg._get_import_path() == "foo"
+
+        tg2 = gen.TestGenerator("other/bar.py")
+        assert tg2._get_import_path().endswith("bar")
+
+        external_src = tmp_path / "src" / "pkg" / "mod.py"
+        external_src.parent.mkdir(parents=True, exist_ok=True)
+        external_src.write_text("x = 1\n", encoding="utf-8")
+        tg3 = gen.TestGenerator(
+            str(external_src), repo_root=tmp_path / "different-root"
+        )
+        tg3.relative_source_path = None
+        assert tg3._get_import_path() == "pkg.mod"
+
+        external_no_src = tmp_path / "outside" / "simple.py"
+        external_no_src.parent.mkdir(parents=True, exist_ok=True)
+        external_no_src.write_text("x = 1\n", encoding="utf-8")
+        tg4 = gen.TestGenerator(
+            str(external_no_src), repo_root=tmp_path / "another-root"
+        )
+        tg4.relative_source_path = None
+        assert tg4._get_import_path() == "simple"
+
+    def test_direct_import_module_extra_branches(self, tmp_path):
+        tg = gen.TestGenerator("run.py")
+        assert tg._get_direct_import_module() == "run"
+
+        # Force external-path branch with src/ in the absolute path.
+        external = tmp_path / "src" / "nested" / "mod.py"
+        external.parent.mkdir(parents=True, exist_ok=True)
+        external.write_text("def x():\n    return 1\n", encoding="utf-8")
+        tg2 = gen.TestGenerator(str(external), repo_root=tmp_path / "other-root")
+        assert tg2._get_direct_import_module() == "src.nested.mod"
+
+    def test_generate_adds_blank_line_when_import_block_has_no_trailing_empty(self):
+        tg = gen.TestGenerator("src/my_mod.py")
+        tg._build_import_block = (  # type: ignore[method-assign]
+            lambda _names: ["import pytest"]
+        )
+        code = tg.generate([("Foo", "class")])
+        assert "\n\nclass TestFoo:" in code
+
+    def test_build_module_path_expression_for_external_source(self, tmp_path):
+        ext = tmp_path / "external.py"
+        ext.write_text("x=1\n", encoding="utf-8")
+        tg = gen.TestGenerator(str(ext), repo_root=tmp_path / "repo2")
+        expr = tg._build_module_path_expression()
+        assert "Path(" in expr
+
+    def test_get_test_dir_and_file(self, tmp_path):
+        src = tmp_path / "src" / "collab"
+        src.mkdir(parents=True)
+        source_file = src / "foo.py"
+        source_file.write_text("def x():\n    return 1\n", encoding="utf-8")
+
+        tg = gen.TestGenerator(str(source_file), repo_root=tmp_path)
+        assert tg.get_test_dir() == tmp_path / "tests" / "backend" / "unit" / "collab"
+        assert tg.get_test_file() == (
+            tmp_path / "tests" / "backend" / "unit" / "collab" / "test_foo.py"
+        )
+
+        custom_root = tmp_path / "out"
+        assert tg.get_test_dir(output_root=custom_root) == custom_root / "unit"
+
+
+class TestDiscovery:
+    def test_find_untested_repo_scan(self, tmp_path):
+        (tmp_path / "pyproject.toml").write_text(
+            "[tool.pytest.ini_options]\n", encoding="utf-8"
+        )
+        (tmp_path / "AGENTS.md").write_text("# repo\n", encoding="utf-8")
+
+        scripts_dir = tmp_path / "scripts"
+        scripts_dir.mkdir()
+        (scripts_dir / "cleanup.py").write_text(
+            "def clean_default():\n    return None\n", encoding="utf-8"
+        )
+
+        src_dir = tmp_path / "src"
+        src_dir.mkdir(parents=True)
+        (src_dir / "alpha.py").write_text("def x():\n    return 1\n", encoding="utf-8")
+
+        tests_dir = tmp_path / "tests" / "backend" / "unit"
+        tests_dir.mkdir(parents=True)
+        (tests_dir / "test_cleanup.py").write_text("# existing\n", encoding="utf-8")
+
+        disc = gen.TestDiscovery(repo_root=tmp_path)
+        untested = disc.find_untested()
+
+        assert "scripts/cleanup.py" not in untested
+        assert "src/alpha.py" in untested
+
+    def test_find_untested_external(self, tmp_path):
+        src_dir = tmp_path / "external"
+        src_dir.mkdir()
+        (src_dir / "beta.py").write_text("x=1\n", encoding="utf-8")
+
+        disc = gen.TestDiscovery(repo_root=gen.ROOT)
+        untested = disc.find_untested(str(src_dir))
+        assert any("beta.py" in p for p in untested)
+
+    def test_find_untested_returns_empty_for_missing_path(self, tmp_path):
+        disc = gen.TestDiscovery(repo_root=tmp_path)
+        assert disc.find_untested(str(tmp_path / "does-not-exist")) == []
+
+    def test_iter_repo_source_files_for_non_repo_path(self, tmp_path):
+        src = tmp_path / "src"
+        src.mkdir()
+        f = src / "a.py"
+        f.write_text("x=1\n", encoding="utf-8")
+        disc = gen.TestDiscovery(repo_root=tmp_path / "other")
+        files = list(disc._iter_repo_source_files(src))
+        assert f.resolve() in files
+
+    def test_iter_python_files_file_mode_and_hidden_skip(self, tmp_path):
+        file_path = tmp_path / "alpha.py"
+        file_path.write_text("x=1\n", encoding="utf-8")
+        disc = gen.TestDiscovery(repo_root=tmp_path)
+        files = list(disc._iter_python_files(file_path))
+        assert files == [file_path.resolve()]
+        assert disc._should_skip_dir(tmp_path / ".hidden") is True
+        assert disc._is_candidate_source(tmp_path / "tests" / "x.py") is False
+
+
+class TestMain:
+    def test_scan_mode(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["generate_tests.py", "--scan"])
+        gen.main()
+        out = capsys.readouterr().out
+        assert "Untested modules" in out or "All modules have tests" in out
+
+    def test_no_source_file_prints_help(self, monkeypatch):
+        monkeypatch.setattr(sys, "argv", ["generate_tests.py"])
+        with pytest.raises(SystemExit) as exc_info:
+            gen.main()
+        assert exc_info.value.code == 1
+
+    def test_missing_file_exits(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["generate_tests.py", "missing.py"])
+        with pytest.raises(SystemExit) as exc_info:
+            gen.main()
+        assert exc_info.value.code == 1
+        assert "File not found" in capsys.readouterr().out
+
+    def test_directory_source_exits(self, monkeypatch, tmp_path, capsys):
+        monkeypatch.setattr(sys, "argv", ["generate_tests.py", str(tmp_path)])
+        with pytest.raises(SystemExit) as exc_info:
+            gen.main()
+        assert exc_info.value.code == 1
+        assert "Source path is a directory" in capsys.readouterr().out
+
+    def test_dry_run_and_write(self, monkeypatch, tmp_path, capsys):
+        src = tmp_path / "mod.py"
+        src.write_text("def hello():\n    return 1\n", encoding="utf-8")
+
+        monkeypatch.setattr(sys, "argv", ["generate_tests.py", str(src), "--dry-run"])
+        gen.main()
+        assert "Generated test template" in capsys.readouterr().out
+
+        out_root = tmp_path / "generated"
+        monkeypatch.setattr(
+            sys,
+            "argv",
+            ["generate_tests.py", str(src), "--output-root", str(out_root)],
+        )
+        gen.main()
+        # output-root puts files under <output-root>/<category>
+        assert (out_root / "unit" / "test_mod.py").exists()
+
+    def test_scan_mode_all_modules_have_tests_branch(self, monkeypatch, capsys):
+        class _Discovery:
+            def find_untested(self, _scan_target=None):
+                return []
+
+        monkeypatch.setattr(gen, "TestDiscovery", lambda: _Discovery())
+        monkeypatch.setattr(sys, "argv", ["generate_tests.py", "--scan"])
+        gen.main()
+        assert "All modules have tests" in capsys.readouterr().out
+
+    def test_no_entities_and_existing_file_branches(
+        self,
+        monkeypatch,
+        tmp_path,
+        capsys,
+    ):
+        src = tmp_path / "m.py"
+        src.write_text("x=1\n", encoding="utf-8")
+
+        class _Analyzer:
+            def __init__(self, *_a, **_k):
+                pass
+
+            def analyze(self):
+                return []
+
+        monkeypatch.setattr(gen, "CodeAnalyzer", _Analyzer)
+        monkeypatch.setattr(sys, "argv", ["generate_tests.py", str(src)])
+        gen.main()
+        assert "No testable entities found" in capsys.readouterr().out
+
+        class _Analyzer2:
+            def __init__(self, *_a, **_k):
+                pass
+
+            def analyze(self):
+                return [("hello", "function")]
+
+        monkeypatch.setattr(gen, "CodeAnalyzer", _Analyzer2)
+        out_root = tmp_path / "out"
+        out_root.mkdir()
+        existing = out_root / "unit" / "test_m.py"
+        existing.parent.mkdir(parents=True, exist_ok=True)
+        existing.write_text("# preexisting\n", encoding="utf-8")
+        monkeypatch.setattr(
+            sys,
+            "argv",
+            [
+                "generate_tests.py",
+                str(src),
+                "--output-root",
+                str(out_root),
+            ],
+        )
+        gen.main()
+        assert "File exists" in capsys.readouterr().out
+
+
+def test_generate_tests_dunder_main(monkeypatch, tmp_path):
+    src = tmp_path / "sample_mod.py"
+    src.write_text("def hello():\n    return 1\n", encoding="utf-8")
+    monkeypatch.setattr(sys, "argv", ["generate_tests.py", str(src), "--dry-run"])
+    runpy.run_path("scripts/generate_tests.py", run_name="__main__")

tests/backend/unit/scripts/test_hook_templates.py

@@ -0,0 +1,357 @@
+"""Regression tests for collab git hook templates and installer overlay."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+import pytest
+
+from tests.backend.unit.scripts._helpers import ROOT
+
+GIT_SH_CANDIDATES = [
+    shutil.which("sh"),
+    r"C:\Users\kmartineztamayo\AppData\Local\Programs\Git\bin\sh.exe",
+    r"C:\Program Files\Git\bin\sh.exe",
+]
+
+
+@pytest.fixture(scope="module")
+def git_sh() -> str:
+    """Return a shell executable compatible with git hook scripts."""
+    for candidate in GIT_SH_CANDIDATES:
+        if candidate and Path(candidate).exists():
+            return candidate
+    pytest.skip("Git shell executable not available for hook template tests")
+
+
+@pytest.fixture()
+def hook_repo(tmp_path: Path) -> Path:
+    """Create a temporary git repo with minimal collab hook runtime."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    subprocess.run(["git", "init"], cwd=repo, check=True, capture_output=True)
+    subprocess.run(
+        ["git", "config", "user.name", "Hook Tester"],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.email", "hook-tester@example.com"],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+    )
+
+    (repo / "hooks").mkdir(parents=True)
+    (repo / ".venv" / "bin").mkdir(parents=True)
+    (repo / "scripts").mkdir(parents=True)
+    (repo / ".git" / "hooks").mkdir(parents=True, exist_ok=True)
+    (repo / ".pre-commit-config.yaml").write_text("repos: []\n", encoding="utf-8")
+
+    for hook_name in ("pre-commit", "post-commit", "pre-push", "commit-msg"):
+        source = ROOT / "hooks" / hook_name
+        target = repo / "hooks" / hook_name
+        target.write_text(source.read_text(encoding="utf-8"), encoding="utf-8")
+
+    install_source = ROOT / "install_hooks.sh"
+    install_target = repo / "install_hooks.sh"
+    install_target.write_text(
+        install_source.read_text(encoding="utf-8"),
+        encoding="utf-8",
+    )
+
+    fake_python = repo / ".venv" / "bin" / "python"
+    # Use the absolute path of the running interpreter so that when the
+    # pre-push hook prepends .venv/bin to PATH, `python` never resolves
+    # back to this wrapper script causing an infinite self-referential loop.
+    real_python = sys.executable.replace("\\", "/")
+    fake_python.write_text(
+        textwrap.dedent(f"""
+            #!/bin/sh
+            exec "{real_python}" "$@"
+            """).lstrip(),
+        encoding="utf-8",
+    )
+    fake_python.chmod(0o755)
+
+    fake_pre_commit = repo / ".venv" / "bin" / "pre-commit"
+    fake_pre_commit.write_text(
+        textwrap.dedent("""
+            #!/bin/sh
+            stage=""
+            while [ $# -gt 0 ]; do
+                if [ "$1" = "--hook-stage" ]; then
+                    stage="$2"
+                    shift 2
+                    continue
+                fi
+                shift
+            done
+            printf '[fake-pre-commit] %s\n' "$stage"
+            if [ "$stage" = "pre-push" ] && [ -n "$FAKE_PRE_PUSH_FAIL" ]; then
+                exit 1
+            fi
+            exit 0
+            """).lstrip(),
+        encoding="utf-8",
+    )
+    fake_pre_commit.chmod(0o755)
+
+    collab_hook_helper = repo / "scripts" / "collab_git_hook.py"
+    collab_hook_helper.write_text(
+        textwrap.dedent("""
+            import os
+            import sys
+
+            command = sys.argv[1]
+            if command == "acquire-staged":
+                mode = os.getenv("FAKE_ACQUIRE_MODE", "watcher")
+                if mode == "watcher":
+                    message = (
+                        "[collab] Watcher running (PID: 3500) "
+                        "— skipping pre-commit lock acquisition."
+                    )
+                    print(
+                        message,
+                        file=sys.stderr,
+                    )
+                    raise SystemExit(0)
+                if mode == "conflict":
+                    print(
+                        "[collab] Commit blocked due to lock conflicts:",
+                        file=sys.stderr,
+                    )
+                    print("  - conflicted.txt (locked by @otherdev)", file=sys.stderr)
+                    raise SystemExit(1)
+                print("[collab] Locks acquired for 1 staged file(s).", file=sys.stderr)
+                raise SystemExit(0)
+            if command == "release-all":
+                count = os.getenv("FAKE_RELEASE_COUNT", "1")
+                print(f"[collab] Released {count} lock(s).", file=sys.stderr)
+                raise SystemExit(0)
+            raise SystemExit(2)
+            """).lstrip(),
+        encoding="utf-8",
+    )
+
+    return repo
+
+
+def _run_sh(
+    script: Path,
+    shell_path: str,
+    cwd: Path,
+    env: dict[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    run_env = os.environ.copy()
+    if env:
+        run_env.update(env)
+    return subprocess.run(
+        [shell_path, str(script)],
+        cwd=cwd,
+        env=run_env,
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def _normalized_output(result: subprocess.CompletedProcess[str]) -> str:
+    """Normalize common Git Bash mojibake so assertions stay stable on Windows."""
+    return (result.stdout + result.stderr).replace("—", "—")
+
+
+def test_install_hooks_copies_templates_into_git_hooks(hook_repo: Path, git_sh: str):
+    result = _run_sh(hook_repo / "install_hooks.sh", git_sh, hook_repo)
+
+    assert result.returncode == 0
+    assert "Installed git hooks from hooks/" in result.stdout
+    for hook_name in ("pre-commit", "post-commit", "pre-push", "commit-msg"):
+        expected = (hook_repo / "hooks" / hook_name).read_text(encoding="utf-8")
+        actual = (hook_repo / ".git" / "hooks" / hook_name).read_text(encoding="utf-8")
+        assert actual == expected
+
+
+def test_pre_commit_hook_prints_watcher_message_then_runs_framework(
+    hook_repo: Path,
+    git_sh: str,
+):
+    staged = hook_repo / "tracked.txt"
+    staged.write_text("content\n", encoding="utf-8")
+    subprocess.run(["git", "add", "tracked.txt"], cwd=hook_repo, check=True)
+
+    result = _run_sh(
+        hook_repo / "hooks" / "pre-commit",
+        git_sh,
+        hook_repo,
+        env={"SKIP": "validate-code"},
+    )
+
+    assert result.returncode == 0
+    combined = _normalized_output(result)
+    assert (
+        "[collab] Watcher running (PID: 3500) — skipping pre-commit lock acquisition."
+        in combined
+    )
+    assert "[fake-pre-commit] pre-commit" in combined
+
+
+def test_pre_commit_hook_blocks_on_conflict(hook_repo: Path, git_sh: str):
+    staged = hook_repo / "conflicted.txt"
+    staged.write_text("content\n", encoding="utf-8")
+    subprocess.run(["git", "add", "conflicted.txt"], cwd=hook_repo, check=True)
+
+    result = _run_sh(
+        hook_repo / "hooks" / "pre-commit",
+        git_sh,
+        hook_repo,
+        env={"FAKE_ACQUIRE_MODE": "conflict"},
+    )
+
+    assert result.returncode == 1
+    combined = _normalized_output(result)
+    assert "[collab] Commit blocked due to lock conflicts:" in combined
+    assert "conflicted.txt" in combined
+    assert "[collab] Commit aborted due to file lock conflicts." in combined
+    assert "[fake-pre-commit] pre-commit" not in combined
+
+
+def test_post_commit_hook_prints_message_and_chains_framework(
+    hook_repo: Path,
+    git_sh: str,
+):
+    result = _run_sh(
+        hook_repo / "hooks" / "post-commit",
+        git_sh,
+        hook_repo,
+    )
+
+    assert result.returncode == 0
+    combined = _normalized_output(result)
+    assert (
+        "[collab] Commit detected. Locks remain active until files are pushed."
+        in combined
+    )
+    assert "[fake-pre-commit] post-commit" in combined
+
+
+def test_pre_push_hook_keeps_locks_when_validation_fails(hook_repo: Path, git_sh: str):
+    result = _run_sh(
+        hook_repo / "hooks" / "pre-push",
+        git_sh,
+        hook_repo,
+        env={"FAKE_PRE_PUSH_FAIL": "1"},
+    )
+
+    assert result.returncode == 1
+    combined = _normalized_output(result)
+    assert "[fake-pre-commit] pre-push" in combined
+    assert "[collab] Pre-push validation failed - keeping locks active." in combined
+    assert (
+        "[collab] Releasing all locks after successful pre-push validation..."
+        not in combined
+    )
+
+
+def test_pre_push_hook_releases_locks_after_success(hook_repo: Path, git_sh: str):
+    result = _run_sh(
+        hook_repo / "hooks" / "pre-push",
+        git_sh,
+        hook_repo,
+        env={"FAKE_RELEASE_COUNT": "4"},
+    )
+
+    assert result.returncode == 0
+    combined = _normalized_output(result)
+    assert "[fake-pre-commit] pre-push" in combined
+    assert (
+        "[collab] Releasing all locks after successful pre-push validation..."
+        in combined
+    )
+    assert "[collab] Released 4 lock(s)." in combined
+
+
+def _run_sh_with_arg(
+    script: Path,
+    shell_path: str,
+    cwd: Path,
+    arg: str,
+    env: dict[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    run_env = os.environ.copy()
+    if env:
+        run_env.update(env)
+    return subprocess.run(
+        [shell_path, str(script), arg],
+        cwd=cwd,
+        env=run_env,
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def test_commit_msg_hook_passes_valid_conventional_commit(hook_repo: Path, git_sh: str):
+    msg_file = hook_repo / ".git" / "COMMIT_EDITMSG"
+    msg_file.write_text("feat(core): add new feature\n", encoding="utf-8")
+
+    result = _run_sh_with_arg(
+        hook_repo / "hooks" / "commit-msg",
+        git_sh,
+        hook_repo,
+        arg=str(msg_file),
+    )
+
+    assert result.returncode == 0
+
+
+def test_commit_msg_hook_blocks_invalid_message(hook_repo: Path, git_sh: str):
+    msg_file = hook_repo / ".git" / "COMMIT_EDITMSG"
+    msg_file.write_text("added some stuff\n", encoding="utf-8")
+
+    result = _run_sh_with_arg(
+        hook_repo / "hooks" / "commit-msg",
+        git_sh,
+        hook_repo,
+        arg=str(msg_file),
+    )
+
+    assert result.returncode == 1
+    assert "Conventional Commits" in result.stderr
+
+
+def test_commit_msg_hook_allows_merge_commit(hook_repo: Path, git_sh: str):
+    msg_file = hook_repo / ".git" / "COMMIT_EDITMSG"
+    msg_file.write_text("Merge branch 'main' into feature\n", encoding="utf-8")
+
+    result = _run_sh_with_arg(
+        hook_repo / "hooks" / "commit-msg",
+        git_sh,
+        hook_repo,
+        arg=str(msg_file),
+    )
+
+    assert result.returncode == 0
+
+
+def test_commit_msg_hook_allows_fixup_commit(hook_repo: Path, git_sh: str):
+    msg_file = hook_repo / ".git" / "COMMIT_EDITMSG"
+    msg_file.write_text("fixup! feat(core): add new feature\n", encoding="utf-8")
+
+    result = _run_sh_with_arg(
+        hook_repo / "hooks" / "commit-msg",
+        git_sh,
+        hook_repo,
+        arg=str(msg_file),
+    )
+
+    assert result.returncode == 0