collab-runtime 0.2.9__py3-none-any.whl

tests/backend/unit/live_locks_watcher/test_live_locks_watcher_module.py

@@ -0,0 +1,187 @@
+"""Module-level tests for live_locks_watcher."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+from ._helpers import load_watcher_module
+
+
+def _repo_root() -> Path:
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        if (parent / "pyproject.toml").exists() and (parent / "src").exists():
+            return parent
+    raise FileNotFoundError("Could not locate repository root")
+
+
+def test_main_function_exists():
+    mod = load_watcher_module()
+    assert hasattr(mod, "main") and callable(mod.main)
+
+
+def test_module_imports():
+    mod = load_watcher_module()
+    assert hasattr(mod, "main")
+    assert hasattr(mod, "_parse_git_status_path")
+    assert hasattr(mod, "_should_ignore_path")
+
+
+def test_main_block_present():
+    module_file = _repo_root().joinpath("src/live_locks_watcher.py")
+    src = module_file.read_text(encoding="utf-8")
+    assert '__name__ == "__main__"' in src or "__name__ == '__main__'" in src
+
+
+def test_reload_watcher_with_colorama_and_plyer(monkeypatch):
+    """Reload the watcher module with fake colorama and plyer to exercise optional-
+    import branches executed at module import time."""
+    fake_colorama = types.SimpleNamespace(
+        Fore=types.SimpleNamespace(GREEN="G", YELLOW="Y", CYAN="C", MAGENTA="M"),
+        Style=types.SimpleNamespace(RESET_ALL="R"),
+        init=lambda: None,
+    )
+    fake_plyer = types.SimpleNamespace(
+        notification=types.SimpleNamespace(
+            notify=lambda **k: None,
+        ),
+    )
+    fake_supa = types.SimpleNamespace(create_client=lambda url, key: object())
+
+    # Inject into sys.modules and monkeypatch find_spec so importlib sees them
+    sys.modules["colorama"] = fake_colorama
+    sys.modules["plyer"] = types.SimpleNamespace(notification=fake_plyer.notification)
+    sys.modules["supabase"] = fake_supa
+    orig_find_spec = importlib.util.find_spec
+    monkeypatch.setattr(importlib.util, "find_spec", lambda name: object())
+
+    try:
+        spec = importlib.util.spec_from_file_location(
+            "tmp_watcher",
+            _repo_root().joinpath("src/live_locks_watcher.py"),
+        )
+        assert spec and spec.loader
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)  # type: ignore[arg-defined]
+
+        # Basic smoke checks on functions that depend on the optional imports
+        assert callable(mod._color)
+        # _notify should use our fake notification without raising
+        mod._notify("T", "M")
+    finally:
+        for name in ("colorama", "plyer", "supabase"):
+            try:
+                del sys.modules[name]
+            except KeyError:
+                pass
+        import importlib as _importlib
+
+        monkeypatch.setattr(_importlib.util, "find_spec", orig_find_spec)
+
+
+def test_color_without_colorama():
+    mod = load_watcher_module()
+    mod._HAS_COLORAMA = False
+    out = mod._color("hello", "X")
+    assert out == "hello"
+
+
+def test_setup_collab_logging_fallback_to_basic_config(monkeypatch):
+    """setup_collab_logging falls back to basicConfig when _setup_collab_logging_obj is
+    None."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "_setup_collab_logging_obj", None)
+    called = []
+    monkeypatch.setattr(
+        mod.logging, "basicConfig", lambda **kwargs: called.append(kwargs)
+    )
+    mod.setup_collab_logging(collab_dir="/fake/collab")
+    assert called, "basicConfig should be called when _setup_collab_logging_obj is None"
+
+
+def test_reload_watcher_handles_find_spec_exceptions(monkeypatch):
+    """Import-time optional dependency probes should tolerate find_spec errors."""
+    module_path = _repo_root().joinpath("src/live_locks_watcher.py")
+
+    def _raising_find_spec(_name):
+        raise RuntimeError("probe failed")
+
+    monkeypatch.setattr(importlib.util, "find_spec", _raising_find_spec)
+
+    spec = importlib.util.spec_from_file_location("tmp_watcher_probe_fail", module_path)
+    assert spec and spec.loader
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)  # type: ignore[arg-defined]
+
+    # Module should still import with optional dependencies disabled.
+    assert mod._HAS_COLORAMA is False
+    assert mod.create_client is None
+    assert mod.desktop_notify is None
+
+
+def test_reload_watcher_exits_on_local_supabase_shadow(monkeypatch):
+    """Watcher should abort when a local .collab/supabase module shadows package."""
+    module_path = _repo_root().joinpath("src/live_locks_watcher.py")
+    # Force a deterministic runtime collab root so shadow detection doesn't
+    # depend on the process cwd/environment.
+    monkeypatch.setenv("COLLAB_HOME", str(module_path.parent))
+    fake_supa_spec = types.SimpleNamespace(
+        origin=str(module_path.parent / "supabase.py")
+    )
+
+    def _find_spec(name):
+        if name == "supabase":
+            return fake_supa_spec
+        return None
+
+    monkeypatch.setattr(importlib.util, "find_spec", _find_spec)
+
+    spec = importlib.util.spec_from_file_location(
+        "tmp_watcher_shadowed_supa", module_path
+    )
+    assert spec and spec.loader
+    mod = importlib.util.module_from_spec(spec)
+
+    with pytest.raises(SystemExit):
+        spec.loader.exec_module(mod)  # type: ignore[arg-defined]
+
+
+def test_watcher_allows_project_venv_site_packages_origin(monkeypatch):
+    """Watcher import should allow installed packages from a repo-local virtualenv."""
+    module_path = _repo_root().joinpath("src/live_locks_watcher.py")
+    project_root = module_path.parents[2]
+    monkeypatch.delenv("COLLAB_HOME", raising=False)
+    monkeypatch.setenv("COLLAB_PROJECT_ROOT", str(project_root))
+    fake_supa_spec = types.SimpleNamespace(
+        origin=str(
+            project_root
+            / ".venv"
+            / "Lib"
+            / "site-packages"
+            / "supabase"
+            / "__init__.py"
+        )
+    )
+
+    def _find_spec(name):
+        if name == "supabase":
+            return fake_supa_spec
+        return None
+
+    fake_supa = types.SimpleNamespace(create_client=lambda *_a, **_k: object())
+    monkeypatch.setitem(sys.modules, "supabase", fake_supa)
+    monkeypatch.setattr(importlib.util, "find_spec", _find_spec)
+
+    spec = importlib.util.spec_from_file_location(
+        "tmp_watcher_site_packages_supa", module_path
+    )
+    assert spec and spec.loader
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)  # type: ignore[arg-defined]
+    assert callable(mod.create_client)

tests/backend/unit/live_locks_watcher/test_live_locks_watcher_multi_session.py

@@ -0,0 +1,320 @@
+"""Multi-session and post-restart conflict handling tests for live_locks_watcher."""
+
+from __future__ import annotations
+
+import sys
+
+import pytest
+
+from ._helpers import load_watcher_module
+
+
+def test_handle_multi_session_interactive_readopt_choice_1(monkeypatch):
+    """Test interactive multi-session lock re-adopt (choice 1)."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: "1")
+
+    update_called = []
+
+    class FakeTable:
+        def update(self, *args):
+            update_called.append("update")
+            return self
+
+        def eq(self, *args):
+            return self
+
+        def execute(self):
+            return None
+
+    class FakeClient:
+        def table(self, name):
+            return FakeTable()
+
+    client = FakeClient()
+    mod._local_owned_locks.clear()
+
+    mod._handle_multi_session_lock(client, "src/multi.py", "old-token")
+
+    assert "update" in update_called
+    assert "src/multi.py" in mod._local_owned_locks
+
+
+def test_handle_multi_session_interactive_release_choice_3(monkeypatch):
+    """Test interactive multi-session lock release (choice 3)."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: "3")
+
+    delete_called = []
+
+    class FakeTable:
+        def delete(self):
+            delete_called.append("delete")
+            return self
+
+        def eq(self, *args):
+            return self
+
+        def execute(self):
+            return None
+
+    class FakeClient:
+        def table(self, name):
+            return FakeTable()
+
+    client = FakeClient()
+    mod._local_owned_locks.clear()
+
+    mod._handle_multi_session_lock(client, "src/multi.py", "old-token")
+
+    assert "delete" in delete_called
+    assert "src/multi.py" not in mod._local_owned_locks
+
+
+def test_handle_multi_session_interactive_leave_choice_2(monkeypatch):
+    """Test interactive multi-session lock leave (choice 2)."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: "2")
+
+    touched_db = []
+
+    class FakeTable:
+        def update(self, *args):
+            touched_db.append(True)
+            return self
+
+        def delete(self):
+            touched_db.append(True)
+            return self
+
+        def eq(self, *args):
+            return self
+
+        def execute(self):
+            return None
+
+    class FakeClient:
+        def table(self, name):
+            return FakeTable()
+
+    client = FakeClient()
+    mod._local_owned_locks.clear()
+
+    mod._handle_multi_session_lock(client, "src/multi.py", "old-token")
+
+    assert not touched_db
+    assert "src/multi.py" not in mod._local_owned_locks
+
+
+def test_handle_post_restart_conflict_interactive_abort_choice_4(monkeypatch):
+    """Test interactive post-restart conflict aborts on choice 4."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    inputs = iter(["4"])
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: next(inputs))
+
+    exit_called = []
+
+    def mock_exit(code):
+        exit_called.append(code)
+        raise SystemExit(code)
+
+    monkeypatch.setattr(sys, "exit", mock_exit)
+
+    shutdown_called = []
+    monkeypatch.setattr(mod, "_graceful_shutdown", lambda: shutdown_called.append(True))
+    monkeypatch.setattr(mod, "_notify", lambda t, m: None)
+
+    mod._active_conflicts.clear()
+
+    with pytest.raises(SystemExit):
+        mod._handle_post_restart_conflict(None, "src/conflict.py", {"owner": "bob"})
+
+    assert shutdown_called
+    assert exit_called == [1]
+
+
+def test_handle_post_restart_conflict_interactive_show_diff_then_continue(monkeypatch):
+    """Choice 2 shows git diff, then choice 1 continues and tracks conflict."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    # First select "show diff", then continue
+    inputs = iter(["2", "1"])
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: next(inputs))
+    monkeypatch.setattr(
+        mod.subprocess,
+        "check_output",
+        lambda *a, **k: b"diff --git a/src/conflict.py b/src/conflict.py\n",
+    )
+    monkeypatch.setattr(mod, "_notify", lambda t, m: None)
+
+    mod._active_conflicts.clear()
+    mod._handle_post_restart_conflict(
+        None,
+        "src/conflict.py",
+        {"owner": "bob", "branch": "main", "reason": "test"},
+    )
+
+    assert "src/conflict.py" in mod._active_conflicts
+
+
+def test_handle_post_restart_conflict_interactive_diff_failure_then_continue(
+    monkeypatch,
+):
+    """Choice 2 handles git diff failure and still allows continue."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    # First select "show diff" (fails), then continue
+    inputs = iter(["2", "1"])
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: next(inputs))
+
+    def _boom(*args, **kwargs):
+        raise RuntimeError("git diff unavailable")
+
+    monkeypatch.setattr(mod.subprocess, "check_output", _boom)
+    monkeypatch.setattr(mod, "_notify", lambda t, m: None)
+
+    mod._active_conflicts.clear()
+    mod._handle_post_restart_conflict(None, "src/conflict.py", {"owner": "bob"})
+
+    assert "src/conflict.py" in mod._active_conflicts
+
+
+def test_handle_post_restart_conflict_tty_input_eof_defaults_continue(monkeypatch):
+    """EOF/interrupt in prompt defaults to choice 1 (continue)."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    import builtins
+
+    def _raise_eof(prompt):
+        raise EOFError()
+
+    monkeypatch.setattr(builtins, "input", _raise_eof)
+    monkeypatch.setattr(mod, "_notify", lambda t, m: None)
+
+    mod._active_conflicts.clear()
+    mod._handle_post_restart_conflict(None, "src/eof_conflict.py", {"owner": "bob"})
+
+    assert "src/eof_conflict.py" in mod._active_conflicts
+
+
+def test_handle_multi_session_interactive_eof_defaults_leave(monkeypatch):
+    """EOF in interactive prompt should fall back to leave-lock option."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    import builtins
+
+    def _raise_eof(prompt):
+        raise EOFError()
+
+    monkeypatch.setattr(builtins, "input", _raise_eof)
+    touched = []
+
+    class FakeTable:
+        def update(self, *args):
+            touched.append("update")
+            return self
+
+        def delete(self):
+            touched.append("delete")
+            return self
+
+        def eq(self, *args):
+            return self
+
+        def execute(self):
+            return None
+
+    class FakeClient:
+        def table(self, name):
+            return FakeTable()
+
+    mod._handle_multi_session_lock(FakeClient(), "src/multi.py", "old-token")
+    assert touched == []
+
+
+def test_handle_multi_session_choice1_update_exception(monkeypatch):
+    """Update failure on choice 1 should be caught and still re-adopt locally."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: "1")
+    mod._local_owned_locks.clear()
+
+    class FakeTable:
+        def update(self, *args):
+            return self
+
+        def eq(self, *args):
+            return self
+
+        def execute(self):
+            raise RuntimeError("db down")
+
+    class FakeClient:
+        def table(self, name):
+            return FakeTable()
+
+    mod._handle_multi_session_lock(FakeClient(), "src/err_update.py", "old-token")
+    assert "src/err_update.py" in mod._local_owned_locks
+
+
+def test_handle_multi_session_choice3_delete_exception(monkeypatch):
+    """Delete failure on choice 3 should be caught without crashing."""
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    monkeypatch.setattr(sys, "stdin", type("F", (), {"isatty": lambda s: True})())
+
+    import builtins
+
+    monkeypatch.setattr(builtins, "input", lambda p: "3")
+
+    class FakeTable:
+        def delete(self):
+            return self
+
+        def eq(self, *args):
+            return self
+
+        def execute(self):
+            raise RuntimeError("db down")
+
+    class FakeClient:
+        def table(self, name):
+            return FakeTable()
+
+    # no raise expected
+    mod._handle_multi_session_lock(FakeClient(), "src/err_delete.py", "old-token")

tests/backend/unit/live_locks_watcher/test_live_locks_watcher_notify.py

@@ -0,0 +1,67 @@
+"""Notification-related tests for live_locks_watcher."""
+
+from __future__ import annotations
+
+from ._helpers import load_watcher_module
+
+
+def test_notify_uses_desktop_notify_if_available(monkeypatch, caplog):
+    mod = load_watcher_module()
+    called = {}
+
+    class FakeDesktop:
+        def notify(self, title=None, message=None, app_name=None, timeout=None):
+            called["title"] = title
+            called["msg"] = message
+
+    monkeypatch.setattr(mod, "desktop_notify", FakeDesktop())
+    monkeypatch.setenv("COLLAB_TEST_MODE", "0")
+    mod._notify("T", "M")
+    assert called.get("title") == "T"
+    assert "M" in called.get("msg")
+
+
+def test_notify_with_title_and_message(monkeypatch):
+    mod = load_watcher_module()
+    notify_called = []
+
+    def mock_notify(title, message, app_name=None):
+        notify_called.append((title, message, app_name))
+
+    monkeypatch.setattr(mod, "_desktop_notify", mock_notify, raising=False)
+
+    try:
+        mod._notify("Test Title", "Test Message")
+    except Exception:
+        pass
+
+    if notify_called:
+        assert notify_called[0][0] == "Test Title"
+        assert notify_called[0][1] == "Test Message"
+
+
+def test_notify_fallback_no_desktop_notify(monkeypatch, caplog):
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "desktop_notify", None)
+    import logging
+
+    with caplog.at_level(logging.INFO):
+        monkeypatch.setenv("COLLAB_TEST_MODE", "0")
+        mod._notify("Test Title", "Test Message")
+    assert "Test Title" in caplog.text or "Test Message" in caplog.text
+
+
+def test_notify_desktop_notify_exception(monkeypatch, caplog):
+    mod = load_watcher_module()
+
+    class FailingNotify:
+        def notify(self, **kwargs):
+            raise RuntimeError("notify failed")
+
+    monkeypatch.setattr(mod, "desktop_notify", FailingNotify())
+    import logging
+
+    with caplog.at_level(logging.INFO):
+        monkeypatch.setenv("COLLAB_TEST_MODE", "0")
+        mod._notify("Fail Title", "Fail Message")
+    assert "Fail Title" in caplog.text or "Fail Message" in caplog.text