collab-runtime 0.2.9__py3-none-any.whl

tests/backend/unit/scripts/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for repository scripts."""

tests/backend/unit/scripts/_helpers.py

@@ -0,0 +1,42 @@
+"""Helpers for loading script modules in tests."""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+from tests.backend.unit.lock_client._helpers import (
+    FakeResponse,
+    load_lock_client_module,
+    make_create_client,
+)
+
+
+def _find_repo_root() -> Path:
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        if (parent / "pyproject.toml").exists() and (parent / "scripts").exists():
+            return parent
+    raise FileNotFoundError("Could not locate repository root")
+
+
+ROOT = _find_repo_root()
+SCRIPTS_DIR = ROOT / "scripts"
+
+
+def load_script_module(script_name: str, module_name: str):
+    """Load a script file from scripts/ as an importable module object."""
+    module_path = SCRIPTS_DIR / script_name
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    assert spec and spec.loader
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+__all__ = [
+    "FakeResponse",
+    "load_lock_client_module",
+    "load_script_module",
+    "make_create_client",
+]

tests/backend/unit/scripts/test_cleanup.py

@@ -0,0 +1,285 @@
+"""Tests for scripts/cleanup.py."""
+
+from __future__ import annotations
+
+import runpy
+import sys
+from pathlib import Path
+
+import pytest
+
+from tests.backend.unit.scripts._helpers import load_script_module
+
+cleanup = load_script_module("cleanup.py", "cleanup_under_test")
+
+
+class TestIsProtected:
+    def test_protected_paths(self):
+        assert cleanup._is_protected(Path(".venv/something")) is True
+        assert cleanup._is_protected(Path("node_modules/pkg")) is True
+        assert cleanup._is_protected(Path(".git/objects")) is True
+        assert cleanup._is_protected(Path("instance/db")) is True
+        assert cleanup._is_protected(Path("test_data/dummy.json")) is True
+
+    def test_unprotected_paths(self):
+        assert cleanup._is_protected(Path("htmlcov/index.html")) is False
+        assert cleanup._is_protected(Path(".coverage")) is False
+        assert cleanup._is_protected(Path("__pycache__")) is False
+
+
+class TestRemove:
+    def test_remove_nonexistent(self, tmp_path):
+        ok, msg = cleanup._remove(tmp_path / "ghost", False)
+        assert ok is False
+        assert msg == ""
+
+    def test_remove_file(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        f = tmp_path / ".coverage"
+        f.write_text("data", encoding="utf-8")
+        ok, _ = cleanup._remove(f, dry_run=False)
+        assert ok is True
+        assert not f.exists()
+
+    def test_remove_directory(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        d = tmp_path / "htmlcov"
+        d.mkdir()
+        (d / "index.html").write_text("<html/>", encoding="utf-8")
+        ok, _ = cleanup._remove(d, dry_run=False)
+        assert ok is True
+        assert not d.exists()
+
+    def test_dry_run_does_not_delete(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        f = tmp_path / "coverage.xml"
+        f.write_text("xml", encoding="utf-8")
+        ok, msg = cleanup._remove(f, dry_run=True)
+        assert ok is True
+        assert "[DRY-RUN]" in msg
+        assert f.exists()
+
+    def test_remove_permission_error(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        f = tmp_path / "locked"
+        f.write_text("x", encoding="utf-8")
+        monkeypatch.setattr(Path, "is_dir", lambda self: False)
+        monkeypatch.setattr(
+            Path,
+            "unlink",
+            lambda self: (_ for _ in ()).throw(PermissionError("nope")),
+        )
+        ok, msg = cleanup._remove(f, dry_run=False)
+        assert ok is False
+        assert "Could not remove" in msg
+
+
+class TestCleanItemsAndGlob:
+    def test_cleans_existing_items(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        (tmp_path / "htmlcov").mkdir()
+        (tmp_path / ".coverage").write_text("data", encoding="utf-8")
+        count = cleanup._clean_items(["htmlcov", ".coverage", "nonexistent"], False)
+        assert count == 2
+
+    def test_cleans_matching_patterns(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        cache = tmp_path / "__pycache__"
+        cache.mkdir()
+        (cache / "mod.pyc").write_text("", encoding="utf-8")
+        count = cleanup._clean_glob(["**/__pycache__"], False)
+        assert count >= 1
+
+    def test_skips_protected(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        protected = tmp_path / "node_modules"
+        protected.mkdir()
+        count = cleanup._clean_glob(["node_modules"], False)
+        assert count == 0
+        assert protected.exists()
+
+
+class TestCleanFunctions:
+    def test_clean_coverage(self, tmp_path, monkeypatch, capsys):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        (tmp_path / "coverage").mkdir()
+        (tmp_path / "coverage" / "lcov.info").write_text("lcov", encoding="utf-8")
+        (tmp_path / ".coverage").write_text("data", encoding="utf-8")
+        (tmp_path / "coverage.xml").write_text("<xml/>", encoding="utf-8")
+        count = cleanup.clean_coverage(dry_run=False)
+        assert count >= 3
+        assert "Cleaning coverage" in capsys.readouterr().out
+
+    def test_clean_test_output(self, tmp_path, monkeypatch, capsys):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        (tmp_path / "test-results").mkdir()
+        (tmp_path / "playwright-report").mkdir()
+        (tmp_path / "blob-report").mkdir()
+        count = cleanup.clean_test_output(dry_run=False)
+        assert count >= 3
+        assert "Cleaning test output" in capsys.readouterr().out
+
+    def test_clean_caches(self, tmp_path, monkeypatch, capsys):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        (tmp_path / ".pytest_cache").mkdir()
+        (tmp_path / ".ruff_cache").mkdir()
+        count = cleanup.clean_caches(dry_run=False)
+        assert count >= 2
+        assert "Cleaning tool caches" in capsys.readouterr().out
+
+    def test_clean_default_and_all(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        (tmp_path / ".coverage").write_text("data", encoding="utf-8")
+        (tmp_path / "test-results").mkdir()
+        (tmp_path / ".ruff_cache").mkdir()
+        assert cleanup.clean_default(dry_run=False) >= 2
+        assert cleanup.clean_all(dry_run=False) >= 1
+
+
+class TestMainCLI:
+    def _run_main(self, monkeypatch, tmp_path, args):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        monkeypatch.setattr(sys, "argv", ["cleanup.py"] + args)
+        return cleanup.main()
+
+    def test_default_mode(self, monkeypatch, tmp_path, capsys):
+        (tmp_path / ".coverage").write_text("x", encoding="utf-8")
+        rc = self._run_main(monkeypatch, tmp_path, [])
+        assert rc == 0
+        assert "test artifacts + coverage" in capsys.readouterr().out
+
+    def test_switches(self, monkeypatch, tmp_path, capsys):
+        (tmp_path / ".ruff_cache").mkdir()
+        assert self._run_main(monkeypatch, tmp_path, ["--all"]) == 0
+
+        (tmp_path / "coverage.xml").write_text("x", encoding="utf-8")
+        assert self._run_main(monkeypatch, tmp_path, ["--coverage"]) == 0
+
+        (tmp_path / "test-results").mkdir()
+        assert self._run_main(monkeypatch, tmp_path, ["--tests"]) == 0
+
+        (tmp_path / ".mypy_cache").mkdir()
+        assert self._run_main(monkeypatch, tmp_path, ["--caches"]) == 0
+
+        out = capsys.readouterr().out
+        assert "ARTIFACT CLEANUP" in out
+
+    def test_main_nothing_to_clean_and_dry_run_banner(
+        self,
+        monkeypatch,
+        tmp_path,
+        capsys,
+    ):
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        rc = self._run_main(monkeypatch, tmp_path, ["--dry-run"])
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "[DRY-RUN]" in out
+        assert "Nothing to clean" in out
+
+    def test_packaging_dry_run(self, monkeypatch, tmp_path, capsys):
+        # Dry-run should list packaging artifacts without deleting
+        (tmp_path / "dist").mkdir()
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        monkeypatch.setattr(sys, "argv", ["cleanup.py", "--packaging", "--dry-run"])
+        rc = cleanup.main()
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "[DRY-RUN]" in out
+        assert "Cleaning packaging artifacts" in out
+
+    def test_packaging_abort_on_no(self, monkeypatch, tmp_path, capsys):
+        # If user answers 'no' to confirmation, main should abort with code 2
+        (tmp_path / "dist").mkdir()
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        monkeypatch.setattr(sys, "argv", ["cleanup.py", "--packaging"])
+        monkeypatch.setattr("builtins.input", lambda prompt: "n")
+        rc = cleanup.main()
+        assert rc == 2
+        out = capsys.readouterr().out
+        assert "Aborted by user." in out
+
+    def test_packaging_confirm_yes_removes(self, monkeypatch, tmp_path, capsys):
+        # If user confirms, packaging artifacts should be removed
+        d = tmp_path / "dist"
+        d.mkdir()
+        (tmp_path / "build").mkdir()
+        monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+        monkeypatch.setattr(sys, "argv", ["cleanup.py", "--packaging"])
+        monkeypatch.setattr("builtins.input", lambda prompt: "y")
+        rc = cleanup.main()
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "Removed" in out or "Would remove" in out
+        assert not d.exists()
+
+
+def test_clean_glob_duplicate_and_value_error_paths(monkeypatch, tmp_path):
+    monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+    d = tmp_path / "__pycache__"
+    d.mkdir()
+
+    # Duplicate pattern should hit seen-guard path.
+    assert cleanup._clean_glob(["__pycache__", "__pycache__"], False) == 1
+
+    class _BadPath:
+        def __hash__(self):
+            return 1
+
+        def __eq__(self, _other):
+            return False
+
+        def relative_to(self, _root):
+            raise ValueError("outside")
+
+    class _FakeRoot:
+        def glob(self, _pattern):
+            return [_BadPath()]
+
+    monkeypatch.setattr(cleanup, "ROOT", _FakeRoot())
+    assert cleanup._clean_glob(["anything"], False) == 0
+
+
+def test_remove_handles_oserror(tmp_path, monkeypatch):
+    monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+    target = tmp_path / "problem.txt"
+    target.write_text("x", encoding="utf-8")
+
+    monkeypatch.setattr(
+        Path,
+        "unlink",
+        lambda self: (_ for _ in ()).throw(OSError("busy")),
+    )
+    ok, msg = cleanup._remove(target, dry_run=False)
+    assert ok is False
+    assert "Could not remove" in msg
+
+
+def test_clean_glob_skips_duplicate_entries(monkeypatch, tmp_path):
+    duplicate = tmp_path / "dup.pyc"
+    duplicate.write_text("data", encoding="utf-8")
+
+    monkeypatch.setattr(cleanup, "ROOT", tmp_path)
+    monkeypatch.setattr(
+        cleanup.Path,
+        "glob",
+        lambda self, _pattern: [duplicate, duplicate] if self == tmp_path else [],
+    )
+
+    removed = []
+    monkeypatch.setattr(
+        cleanup,
+        "_remove",
+        lambda path, dry_run: removed.append(path) or (True, ""),
+    )
+
+    count = cleanup._clean_glob(["**/*.pyc"], dry_run=False)
+    assert count == 1
+    assert removed == [duplicate]
+
+
+def test_cleanup_module_dunder_main(monkeypatch):
+    monkeypatch.setattr(sys, "argv", ["cleanup.py", "--dry-run"])
+    with pytest.raises(SystemExit) as exc:
+        runpy.run_path("scripts/cleanup.py", run_name="__main__")
+    assert exc.value.code == 0

tests/backend/unit/scripts/test_collab_git_hook.py

@@ -0,0 +1,280 @@
+"""Tests for scripts/collab_git_hook.py."""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import runpy
+import sys
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tests.backend.unit.scripts._helpers import load_script_module
+
+hook = load_script_module("collab_git_hook.py", "collab_git_hook_under_test")
+
+
+def test_git_output_success(monkeypatch):
+    monkeypatch.setattr(
+        hook.subprocess,
+        "run",
+        lambda *a, **k: SimpleNamespace(returncode=0, stdout="a\n", stderr=""),
+    )
+    assert hook._git_output("status") == "a"
+
+
+def test_git_output_error_raises(monkeypatch):
+    monkeypatch.setattr(
+        hook.subprocess,
+        "run",
+        lambda *a, **k: SimpleNamespace(returncode=1, stdout="", stderr="boom"),
+    )
+    try:
+        hook._git_output("status")
+        assert False
+    except RuntimeError as exc:
+        assert "boom" in str(exc)
+
+
+def test_get_staged_files(monkeypatch):
+    monkeypatch.setattr(hook, "_git_output", lambda *a: "a.py\n\n b.py \n")
+    assert hook._get_staged_files() == ["a.py", "b.py"]
+
+
+def test_read_pid_file_missing(monkeypatch, tmp_path):
+    pid_file = tmp_path / "daemon.pid"
+    monkeypatch.setattr("src.lock_client.PID_FILE", str(pid_file))
+    assert hook._read_pid_file() is None
+
+
+def test_read_pid_file_json_and_plain(monkeypatch, tmp_path):
+    pid_file = tmp_path / "daemon.pid"
+    monkeypatch.setattr("src.lock_client.PID_FILE", str(pid_file))
+
+    pid_file.write_text(json.dumps({"pid": 123}), encoding="utf-8")
+    assert hook._read_pid_file() == 123
+
+    pid_file.write_text("456", encoding="utf-8")
+    assert hook._read_pid_file() == 456
+
+    pid_file.write_text("not-int", encoding="utf-8")
+    assert hook._read_pid_file() is None
+
+
+def test_read_pid_file_empty_and_oserror(monkeypatch, tmp_path):
+    pid_file = tmp_path / "daemon.pid"
+    monkeypatch.setattr("src.lock_client.PID_FILE", str(pid_file))
+
+    pid_file.write_text("\n", encoding="utf-8")
+    assert hook._read_pid_file() is None
+
+    monkeypatch.setattr(
+        Path,
+        "read_text",
+        lambda *a, **k: (_ for _ in ()).throw(OSError("x")),
+    )
+    assert hook._read_pid_file() is None
+
+
+def test_pid_is_running_psutil_branch(monkeypatch):
+    class _Psutil:
+        @staticmethod
+        def pid_exists(_pid):
+            return True
+
+    monkeypatch.setitem(sys.modules, "psutil", _Psutil)
+    assert hook._pid_is_running(1) is True
+
+
+def test_pid_is_running_fallback_kill(monkeypatch):
+    monkeypatch.setitem(
+        sys.modules,
+        "psutil",
+        SimpleNamespace(pid_exists=lambda _pid: (_ for _ in ()).throw(RuntimeError())),
+    )
+
+    called = {"count": 0}
+
+    def _fake_kill(pid, sig):
+        called["count"] += 1
+        if pid == 10:
+            raise OSError("gone")
+
+    monkeypatch.setattr(os, "kill", _fake_kill)
+    assert hook._pid_is_running(9) is True
+    assert hook._pid_is_running(10) is False
+    assert called["count"] >= 2
+
+
+def test_pid_is_running_permission_error(monkeypatch):
+    monkeypatch.setitem(
+        sys.modules,
+        "psutil",
+        SimpleNamespace(pid_exists=lambda _pid: (_ for _ in ()).throw(RuntimeError())),
+    )
+
+    def _fake_kill(_pid, _sig):
+        raise PermissionError("denied")
+
+    monkeypatch.setattr(os, "kill", _fake_kill)
+    assert hook._pid_is_running(123) is True
+
+
+def test_watcher_pid(monkeypatch):
+    monkeypatch.setattr(hook, "_read_pid_file", lambda: 77)
+    monkeypatch.setattr(hook, "_pid_is_running", lambda pid: True)
+    assert hook._watcher_pid() == 77
+
+    monkeypatch.setattr(hook, "_pid_is_running", lambda pid: False)
+    assert hook._watcher_pid() is None
+
+
+def test_watcher_pid_none_branch(monkeypatch):
+    monkeypatch.setattr(hook, "_read_pid_file", lambda: None)
+    assert hook._watcher_pid() is None
+
+
+def test_acquire_staged_no_files(monkeypatch):
+    monkeypatch.setattr(hook, "_get_staged_files", lambda: [])
+    assert hook.acquire_staged() == 0
+
+
+def test_acquire_staged_skips_when_watcher_running(monkeypatch):
+    monkeypatch.setattr(hook, "_get_staged_files", lambda: ["a.py"])
+    monkeypatch.setattr(hook, "_watcher_pid", lambda: 999)
+    err = io.StringIO()
+    with redirect_stderr(err):
+        rc = hook.acquire_staged()
+    assert rc == 0
+    assert "Watcher running" in err.getvalue()
+
+
+def test_acquire_staged_strict_failure(monkeypatch):
+    monkeypatch.setattr(hook, "_get_staged_files", lambda: ["a.py"])
+    monkeypatch.setattr(hook, "_watcher_pid", lambda: None)
+
+    class _BrokenClient:
+        def __init__(self):
+            raise RuntimeError("lock backend down")
+
+    monkeypatch.setattr("src.lock_client.LockClient", _BrokenClient)
+    monkeypatch.setenv("LOCK_STRICT", "1")
+    err = io.StringIO()
+    with redirect_stderr(err):
+        rc = hook.acquire_staged()
+    assert rc == 1
+    assert "lock check failed" in err.getvalue()
+
+
+def test_acquire_staged_conflict(monkeypatch):
+    monkeypatch.setattr(hook, "_get_staged_files", lambda: ["a.py"])
+    monkeypatch.setattr(hook, "_watcher_pid", lambda: None)
+
+    class _Client:
+        def acquire_multiple(self, *_a, **_k):
+            return False, ["a.py"], "conflict"
+
+        def get_lock_status(self, _f):
+            return {"locked_by": "dev1"}
+
+    monkeypatch.setattr("src.lock_client.LockClient", lambda: _Client())
+
+    err = io.StringIO()
+    with redirect_stderr(err):
+        rc = hook.acquire_staged()
+    assert rc == 1
+    assert "Commit blocked" in err.getvalue()
+    assert "@dev1" in err.getvalue()
+
+
+def test_acquire_staged_conflict_status_exception(monkeypatch):
+    monkeypatch.setattr(hook, "_get_staged_files", lambda: ["a.py"])
+    monkeypatch.setattr(hook, "_watcher_pid", lambda: None)
+
+    class _Client:
+        def acquire_multiple(self, *_a, **_k):
+            return False, ["a.py"], "conflict"
+
+        def get_lock_status(self, _f):
+            raise RuntimeError("boom")
+
+    monkeypatch.setattr("src.lock_client.LockClient", lambda: _Client())
+
+    err = io.StringIO()
+    with redirect_stderr(err):
+        rc = hook.acquire_staged()
+    assert rc == 1
+    assert "@unknown" in err.getvalue()
+
+
+def test_acquire_staged_success(monkeypatch):
+    monkeypatch.setattr(hook, "_get_staged_files", lambda: ["a.py", "b.py"])
+    monkeypatch.setattr(hook, "_watcher_pid", lambda: None)
+
+    class _Client:
+        def acquire_multiple(self, *_a, **_k):
+            return True, [], "ok"
+
+    monkeypatch.setattr("src.lock_client.LockClient", lambda: _Client())
+    err = io.StringIO()
+    with redirect_stderr(err):
+        rc = hook.acquire_staged()
+    assert rc == 0
+    assert "Locks acquired" in err.getvalue()
+
+
+def test_release_all_success_and_failure(monkeypatch):
+    class _ClientOk:
+        def release_all(self):
+            return 3
+
+    monkeypatch.setattr("src.lock_client.LockClient", lambda: _ClientOk())
+    err = io.StringIO()
+    with redirect_stderr(err):
+        assert hook.release_all() == 0
+    assert "Released 3" in err.getvalue()
+
+    class _ClientBad:
+        def __init__(self):
+            raise RuntimeError("fail")
+
+    monkeypatch.setattr("src.lock_client.LockClient", _ClientBad)
+    err = io.StringIO()
+    with redirect_stderr(err):
+        assert hook.release_all() == 0
+    assert "lock cleanup failed" in err.getvalue()
+
+
+def test_main_command_dispatch(monkeypatch):
+    monkeypatch.setattr(hook, "acquire_staged", lambda: 7)
+    monkeypatch.setattr(hook, "release_all", lambda: 8)
+
+    monkeypatch.setattr(sys, "argv", ["collab_git_hook.py", "acquire-staged"])
+    assert hook.main() == 7
+
+    monkeypatch.setattr(sys, "argv", ["collab_git_hook.py", "release-all"])
+    assert hook.main() == 8
+
+    monkeypatch.setattr(sys, "argv", ["collab_git_hook.py", "unknown"])
+    err = io.StringIO()
+    with redirect_stderr(err):
+        assert hook.main() == 2
+    assert "Unknown command" in err.getvalue()
+
+    monkeypatch.setattr(sys, "argv", ["collab_git_hook.py"])
+    out = io.StringIO()
+    with redirect_stdout(out):
+        assert hook.main() == 2
+    assert "Usage" in out.getvalue()
+
+
+def test_collab_git_hook_dunder_main(monkeypatch):
+    monkeypatch.setattr(sys, "argv", ["collab_git_hook.py", "acquire-staged"])
+    monkeypatch.setattr(hook, "acquire_staged", lambda: 0)
+    with pytest.raises(SystemExit) as exc:
+        runpy.run_path("scripts/collab_git_hook.py", run_name="__main__")
+    assert exc.value.code == 0

tests/backend/unit/scripts/test_collab_git_hook_ported.py

@@ -0,0 +1,50 @@
+"""Extra branch coverage tests for scripts/collab_git_hook.py."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+
+def _repo_root() -> Path:
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        if (parent / "pyproject.toml").exists() and (parent / "scripts").exists():
+            return parent
+    raise FileNotFoundError("Could not locate repository root")
+
+
+def _load_fresh(module_name: str):
+    root = _repo_root()
+    module_path = root / "scripts" / "collab_git_hook.py"
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    assert spec and spec.loader
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def test_src_root_added_to_sys_path(monkeypatch):
+    root = _repo_root()
+    src_root = str((root / "src").resolve())
+    if src_root in sys.path:
+        sys.path.remove(src_root)
+
+    mod = _load_fresh("collab_git_hook_fresh_path")
+    assert str(mod.SRC_ROOT) in sys.path
+
+
+def test_read_pid_file_json_decode_and_non_int_pid(monkeypatch, tmp_path):
+    from tests.backend.unit.scripts._helpers import load_script_module
+
+    hook = load_script_module("collab_git_hook.py", "collab_git_hook_extra_pid")
+    pid_file = tmp_path / "daemon.pid"
+    monkeypatch.setattr("src.lock_client.PID_FILE", str(pid_file))
+
+    pid_file.write_text("{bad-json", encoding="utf-8")
+    assert hook._read_pid_file() is None
+
+    pid_file.write_text(json.dumps({"pid": "abc"}), encoding="utf-8")
+    assert hook._read_pid_file() is None