collab-runtime 0.2.9__py3-none-any.whl

tests/backend/unit/live_locks_watcher/test_live_locks_watcher_scan.py

@@ -0,0 +1,296 @@
+"""Tests for _scan_remote_locks behavior in live_locks_watcher."""
+
+from __future__ import annotations
+
+from ._helpers import load_watcher_module
+
+
+class FakeScanClient:
+    """Mock Supabase client for _scan_remote_locks tests."""
+
+    def __init__(self, data=None, raise_exc=None):
+        self._data = data or []
+        self._raise_exc = raise_exc
+
+    def table(self, *args, **kwargs):
+        return self
+
+    def select(self, *args, **kwargs):
+        if self._raise_exc:
+            raise self._raise_exc
+        return self
+
+    def execute(self):
+        if self._raise_exc:
+            raise self._raise_exc
+
+        class Resp:
+            data = self._data
+
+        return Resp()
+
+
+def test_scan_remote_locks_warns_about_other_devs(monkeypatch, caplog):
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    mod._warned_remote_locks.clear()
+    monkeypatch.setattr(mod, "_notify", lambda *a, **k: None)
+
+    client = FakeScanClient(
+        data=[
+            {"file_path": "src/app.py", "developer_id": "bob"},
+        ]
+    )
+
+    import logging
+
+    with caplog.at_level(logging.WARNING, logger="collab.pycharm_watcher"):
+        mod._scan_remote_locks(client)
+
+    assert "src/app.py" in mod._warned_remote_locks
+    assert any("REMOTE LOCK" in r.message for r in caplog.records)
+    mod._warned_remote_locks.clear()
+
+
+def test_scan_remote_locks_skips_own_locks(monkeypatch):
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    mod._warned_remote_locks.clear()
+
+    client = FakeScanClient(data=[{"file_path": "src/app.py", "developer_id": "alice"}])
+    mod._scan_remote_locks(client)
+
+    assert "src/app.py" not in mod._warned_remote_locks
+    mod._warned_remote_locks.clear()
+
+
+def test_scan_remote_locks_clears_released_warnings(monkeypatch, caplog):
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    mod._warned_remote_locks.clear()
+    monkeypatch.setattr(mod, "_notify", lambda *a, **k: None)
+
+    # First scan: bob holds a lock
+    client_with_lock = FakeScanClient(
+        data=[{"file_path": "src/app.py", "developer_id": "bob"}]
+    )
+    mod._scan_remote_locks(client_with_lock)
+    assert "src/app.py" in mod._warned_remote_locks
+
+    # Second scan: lock released
+    import logging
+
+    with caplog.at_level(logging.INFO, logger="collab.pycharm_watcher"):
+        client_empty = FakeScanClient(data=[])
+        mod._scan_remote_locks(client_empty)
+
+    assert "src/app.py" not in mod._warned_remote_locks
+    assert any("Remote lock cleared" in r.message for r in caplog.records)
+    mod._warned_remote_locks.clear()
+
+
+def test_scan_remote_locks_no_duplicate_warnings(monkeypatch):
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    mod._warned_remote_locks.clear()
+    notify_calls = []
+    monkeypatch.setattr(mod, "_notify", lambda t, m: notify_calls.append((t, m)))
+
+    client = FakeScanClient(data=[{"file_path": "src/app.py", "developer_id": "bob"}])
+
+    mod._scan_remote_locks(client)
+    mod._scan_remote_locks(client)  # second call — should NOT notify again
+
+    assert len(notify_calls) == 1
+    mod._warned_remote_locks.clear()
+
+
+def test_scan_remote_locks_handles_exception(monkeypatch):
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    mod._warned_remote_locks.clear()
+
+    client = FakeScanClient(raise_exc=RuntimeError("network down"))
+    mod._scan_remote_locks(client)  # should not raise
+
+    assert len(mod._warned_remote_locks) == 0
+
+
+def test_scan_remote_locks_skips_empty_file_path(monkeypatch):
+    mod = load_watcher_module()
+    monkeypatch.setattr(mod, "DEVELOPER_ID", "alice")
+    mod._warned_remote_locks.clear()
+    monkeypatch.setattr(mod, "_notify", lambda *a, **k: None)
+
+    client = FakeScanClient(data=[{"file_path": "", "developer_id": "bob"}])
+    mod._scan_remote_locks(client)
+
+    assert len(mod._warned_remote_locks) == 0
+
+
+def test_scan_remote_locks_client_exception(monkeypatch):
+    mod = load_watcher_module()
+
+    class FakeResp:
+        def __init__(self, data=None):
+            self.data = data
+
+    class FakeClient:
+        def __init__(self, data=None, explode=False):
+            self._data = data
+            self._explode = explode
+
+        def table(self, *a, **k):
+            return self
+
+        def select(self, *a, **k):
+            return self
+
+        def execute(self):
+            if self._explode:
+                raise RuntimeError("backend down")
+            return FakeResp(self._data)
+
+    fake = FakeClient(explode=True)
+    mod._warned_remote_locks.clear()
+    mod._known_remote_locks.clear()
+    mod._scan_remote_locks(fake)
+
+
+def test_scan_remote_locks_warns_for_other_owner(monkeypatch):
+    mod = load_watcher_module()
+    fake_data = [
+        {
+            "developer_id": "other_user",
+            "file_path": "src/locked.txt",
+            "branch_name": None,
+            "reason": None,
+        }
+    ]
+    fake = type(
+        "C",
+        (),
+        {
+            "_data": fake_data,
+            "table": lambda self, *a, **k: self,
+            "select": lambda self, *a, **k: self,
+            "execute": lambda self: type("R", (), {"data": self._data})(),
+        },
+    )()
+    mod.DEVELOPER_ID = "me"
+    mod._warned_remote_locks.clear()
+    mod._known_remote_locks.clear()
+    mod._scan_remote_locks(fake)
+    assert "src/locked.txt" in mod._warned_remote_locks
+
+
+def test_scan_remote_locks_same_owner_updates_known():
+    mod = load_watcher_module()
+    fake_data = [
+        {
+            "developer_id": "me",
+            "file_path": "src/mine.txt",
+            "branch_name": None,
+            "reason": None,
+        }
+    ]
+
+    class FakeClient3:
+        def __init__(self, data):
+            self._data = data
+
+        def table(self, *a, **k):
+            return self
+
+        def select(self, *a, **k):
+            return self
+
+        def execute(self):
+            class R:
+                data = self._data
+
+            return R()
+
+    fake = FakeClient3(fake_data)
+    mod.DEVELOPER_ID = "me"
+    mod._known_remote_locks.clear()
+    mod._warned_remote_locks.clear()
+    mod._scan_remote_locks(fake)
+    assert "src/mine.txt" in mod._known_remote_locks
+
+
+# ---- Auto-migrated from migrated_remaining ----
+
+
+def test_scan_remote_locks_skips_local_owned(monkeypatch):
+    mod = load_watcher_module()
+    # If a remote lock entry belongs to our developer and we already have it in
+    # _local_owned_locks, the scan should skip notifications for it.
+    fake_data = [
+        {
+            "developer_id": "me",
+            "file_path": "src/owned.txt",
+            "branch_name": None,
+            "reason": None,
+        }
+    ]
+
+    class FakeClientLocal:
+        def __init__(self, data=None):
+            self._data = data
+
+        def table(self, *a, **k):
+            return self
+
+        def select(self, *a, **k):
+            return self
+
+        def execute(self):
+            class R:
+                data = self._data
+
+            return R()
+
+    fake = FakeClientLocal(data=fake_data)
+    mod.DEVELOPER_ID = "me"
+    mod._local_owned_locks.clear()
+    mod._local_owned_locks.add("src/owned.txt")
+    mod._warned_remote_locks.clear()
+    mod._known_remote_locks.clear()
+
+    # Should not raise and should not add to _warned_remote_locks
+    mod._scan_remote_locks(fake)
+    assert "src/owned.txt" not in mod._warned_remote_locks
+
+
+def test_scan_remote_locks_removed_discards_local_owned(monkeypatch):
+    mod = load_watcher_module()
+    # Simulate a previously-known remote lock that was released; if we had it
+    # recorded locally, the code path should discard it from _local_owned_locks.
+    mod._known_remote_locks.clear()
+    mod._known_remote_locks.add("src/released.txt")
+    mod._local_owned_locks.clear()
+    mod._local_owned_locks.add("src/released.txt")
+
+    # Fake client returns no locks (empty list)
+    class EmptyClient:
+        def table(self, *a, **k):
+            return self
+
+        def select(self, *a, **k):
+            return self
+
+        def execute(self):
+            class R:
+                data = []
+
+            return R()
+
+    fake = EmptyClient()
+
+    mod._scan_remote_locks(fake)
+    # After scanning, released lock should be removed from local-owned set
+    assert "src/released.txt" not in mod._local_owned_locks
+
+
+watcher = load_watcher_module()

tests/backend/unit/lock_client/__init__.py

@@ -0,0 +1 @@
+# lock_client test package

tests/backend/unit/lock_client/_helpers.py

@@ -0,0 +1,132 @@
+"""Shared helpers for LockClient tests in the lock_client test package."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import sys
+from pathlib import Path
+from unittest import mock
+
+# Ensure supabase is mocked so importing the module doesn't raise if supabase
+# isn't installed in the test environment.
+sys.modules.setdefault("supabase", mock.MagicMock())
+
+
+def _find_lock_client_path() -> Path:
+    p = Path(__file__).resolve()
+    for parent in p.parents:
+        candidate = parent / "src" / "lock_client.py"
+        if candidate.exists():
+            return candidate
+    candidate = Path(__file__).resolve().parents[4] / "src" / "lock_client.py"
+    if candidate.exists():
+        return candidate
+    raise FileNotFoundError("lock_client.py not found in repo")
+
+
+def load_lock_client_module():
+    candidate = _find_lock_client_path()
+    repo_root = candidate.parents[2]
+    root_str = str(repo_root)
+    if root_str not in sys.path:
+        sys.path.insert(0, root_str)
+
+    # Always import via package machinery so src.main and tests share the
+    # exact same module object for monkeypatching.
+    if "src.lock_client" in sys.modules:
+        return sys.modules["src.lock_client"]
+    return importlib.import_module("src.lock_client")
+
+
+def _load_lock_client_module():
+    """Backward-compatible alias for older tests that call `_load_lock_client_module()`.
+
+    Prefer `load_lock_client_module()` in new tests.
+    """
+    return load_lock_client_module()
+
+
+def _find_watcher_path() -> Path:
+    p = Path(__file__).resolve()
+    for parent in p.parents:
+        candidate = parent / "src" / "live_locks_watcher.py"
+        if candidate.exists():
+            return candidate
+    candidate = Path(__file__).resolve().parents[5] / "src" / "live_locks_watcher.py"
+    if candidate.exists():
+        return candidate
+    raise FileNotFoundError("live_locks_watcher.py not found in repo")
+
+
+def load_watcher_module():
+    candidate = _find_watcher_path()
+    spec = importlib.util.spec_from_file_location(
+        "src.live_locks_watcher", str(candidate)
+    )
+    mod = importlib.util.module_from_spec(spec)
+    assert spec and spec.loader
+    spec.loader.exec_module(mod)  # type: ignore[arg-type]
+    return mod
+
+
+class FakeResponse:
+    def __init__(self, status=200, data=None, error=None):
+        self.status = status
+        self.data = data if data is not None else []
+        self.error = error
+
+
+class FakeClient:
+    def __init__(self, resp):
+        self._resp = resp
+
+    def rpc(self, *a, **k):
+        return self
+
+    def table(self, *a, **k):
+        return self
+
+    def select(self, *a, **k):
+        return self
+
+    def delete(self, *a, **k):
+        return self
+
+    def eq(self, *a, **k):
+        return self
+
+    def insert(self, *a, **k):
+        return self
+
+    def update(self, *a, **k):
+        return self
+
+    def order(self, *a, **k):
+        return self
+
+    def limit(self, *a, **k):
+        return self
+
+    def ilike(self, *a, **k):
+        return self
+
+    def execute(self):
+        return self._resp
+
+
+def make_create_client(resp):
+    def fake_create(url, key):
+        return FakeClient(resp)
+
+    return fake_create
+
+
+def make_get_create_client(resp):
+    def fake_get_create_client():
+        def create_client(url, key):
+            return FakeClient(resp)
+
+        return create_client
+
+    return fake_get_create_client

tests/backend/unit/lock_client/test_lock_client_acquire.py

@@ -0,0 +1,214 @@
+"""Acquire-related tests for LockClient."""
+
+from __future__ import annotations
+
+from ._helpers import (
+    FakeClient,
+    FakeResponse,
+    load_lock_client_module,
+    make_create_client,
+    make_get_create_client,
+)
+
+mod = load_lock_client_module()
+
+
+def test_acquire_multiple_success(monkeypatch, tmp_path):
+    """Test batch lock acquisition."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+
+    file1 = tmp_path / "src" / "app.py"
+    file2 = tmp_path / "src" / "routes.py"
+    file1.parent.mkdir(parents=True)
+    file1.write_text("# code")
+    file2.write_text("# code")
+
+    response = FakeResponse(status=200, data=[{"status": "ok", "lock_id": "batch123"}])
+    monkeypatch.setattr(mod, "_get_create_client", lambda: make_create_client(response))
+
+    lc = mod.LockClient(developer_id="test_user")
+    ok, failed, msg = lc.acquire_multiple([str(file1), str(file2)])
+    assert isinstance(ok, bool)
+    assert isinstance(failed, list)
+
+
+# RESTORED: test_acquire_and_release_ephemeral (migrated from additional)
+def test_acquire_and_release_ephemeral(tmp_path, monkeypatch):
+    # Create a temp file to acquire
+    f = tmp_path / "file.txt"
+    f.write_text("x")
+
+    client = object.__new__(mod.LockClient)
+    # Simulate ephemeral developer
+    client.developer_id = "test_dev_123"
+    client._is_ephemeral = True
+
+    ok, token = mod.LockClient.acquire(client, str(f))
+    assert ok and token.startswith("ephemeral-")
+
+    ok_rel, msg = mod.LockClient.release(client, str(f))
+    assert ok_rel and "ephemeral" in msg
+
+
+# RESTORED: test_acquire_api_exception (migrated from monolith)
+def test_acquire_api_exception(monkeypatch, tmp_path):
+    """Test acquire when API call raises an exception."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+
+    test_file = tmp_path / "src" / "app.py"
+    test_file.parent.mkdir(parents=True)
+    test_file.write_text("# code")
+
+    class ExplodingClient(FakeClient):
+        def execute(self):
+            raise RuntimeError("API exploded")
+
+    monkeypatch.setattr(
+        mod,
+        "_get_create_client",
+        lambda: lambda url, key: ExplodingClient(FakeResponse()),
+    )
+    monkeypatch.setattr(mod, "_PROJECT_ROOT", str(tmp_path))
+
+    lc = mod.LockClient(developer_id="test_user")
+    ok, msg = lc.acquire(str(test_file))
+    assert ok is False
+    assert "API Error" in msg
+
+
+# RESTORED: test_acquire_missing_file_returns_false (migrated from monolith)
+def test_acquire_missing_file_returns_false(monkeypatch):
+    monkeypatch.setenv("SUPABASE_URL", "https://example.invalid")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "anon:fake")
+    monkeypatch.setattr(
+        mod,
+        "_get_create_client",
+        make_get_create_client({"status": 200, "data": []}),
+    )
+
+    lc = mod.LockClient(developer_id="tester")
+    ok, msg = lc.acquire("this/path/does/not/exist.file")
+    assert not ok
+    assert "does not exist" in msg
+
+
+def test_acquire_missing_file_allowed_when_in_progress(monkeypatch):
+    """Deleted paths remain lockable when git marks them in progress."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+
+    response = FakeResponse(status=200, data=[{"status": "ok"}])
+    monkeypatch.setattr(mod, "_get_create_client", lambda: make_create_client(response))
+
+    lc = mod.LockClient(developer_id="tester")
+    target = ".github/workflows/validate-on-pr.yml"
+    monkeypatch.setattr(lc, "_get_modified_and_unpushed_files", lambda: [target])
+
+    ok, token = lc.acquire(target)
+    assert ok is True
+    assert isinstance(token, str) and len(token) > 0
+
+
+def test_acquire_missing_file_in_progress_lookup_error(monkeypatch):
+    """If in-progress detection fails, missing paths are rejected safely."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod,
+        "_get_create_client",
+        make_get_create_client({"status": 200, "data": []}),
+    )
+
+    lc = mod.LockClient(developer_id="tester")
+
+    def _boom():
+        raise RuntimeError("git scan failed")
+
+    monkeypatch.setattr(lc, "_get_modified_and_unpushed_files", _boom)
+    ok, msg = lc.acquire("deleted/path.py")
+    assert ok is False
+    assert "does not exist" in msg
+
+
+def test_acquire_directory_returns_false(monkeypatch, tmp_path):
+    """Directory paths are not lockable."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", make_get_create_client({"status": 200, "data": []})
+    )
+
+    instance_dir = tmp_path / "apps" / "reporting" / "instance"
+    instance_dir.mkdir(parents=True)
+    monkeypatch.setattr(mod, "_PROJECT_ROOT", str(tmp_path))
+
+    lc = mod.LockClient(developer_id="tester")
+    ok, msg = lc.acquire("apps/reporting/instance")
+    assert ok is False
+    assert "directory" in msg.lower()
+
+
+def test_acquire_ephemeral(tmp_path):
+    """Acquire a file with ephemeral developer ID (local_only)."""
+    mod = load_lock_client_module()
+    f = tmp_path / "a.txt"
+    f.write_text("x")
+    client = mod.LockClient(local_only=True, developer_id="test_dev_joe")
+    ok, token = client.acquire(str(f))
+    assert ok is True
+    assert isinstance(token, str) and token.startswith("ephemeral-")
+
+
+def test_acquire_success_and_conflict(tmp_path):
+    """Acquire success and conflict scenarios via supabase client."""
+    mod = load_lock_client_module()
+    f = tmp_path / "b.txt"
+    f.write_text("x")
+
+    # Success
+    client = mod.LockClient(local_only=True, developer_id="alice")
+    client._client = FakeClient(FakeResponse(status=200, data=[{"status": "ok"}]))
+    ok, token = client.acquire(str(f))
+    assert ok is True
+    assert isinstance(token, str) and len(token) == 16
+
+    # Conflict
+    client2 = mod.LockClient(local_only=True, developer_id="bob")
+    client2._client = FakeClient(
+        FakeResponse(status=200, data=[{"status": "conflict", "owner": "eve"}])
+    )
+    ok2, msg2 = client2.acquire(str(f))
+    assert ok2 is False
+    assert "@eve" in msg2
+
+
+def test_acquire_api_error(tmp_path):
+    """Acquire when supabase returns a 500 error."""
+    mod = load_lock_client_module()
+    f = tmp_path / "c.txt"
+    f.write_text("x")
+    client = mod.LockClient(local_only=True, developer_id="carol")
+    client._client = FakeClient(
+        FakeResponse(status=500, data=None, error={"message": "rpc fail"})
+    )
+    ok, msg = client.acquire(str(f))
+    assert ok is False
+    assert "API Error" in msg
+
+
+def test_acquire_unexpected_response(tmp_path):
+    """Cover line 738 unexpected-response path.
+
+    acquire returns "Unexpected response" when status is not 200/201 and data is empty.
+    """
+    mod = load_lock_client_module()
+    f = tmp_path / "u.txt"
+    f.write_text("x")
+    client = mod.LockClient(local_only=True, developer_id="user1")
+    # Return empty data list and non-200/201 status to trigger line 738
+    client._client = FakeClient(FakeResponse(status=503, data=[], error=None))
+    ok, msg = client.acquire(str(f))
+    assert ok is False
+    assert "Unexpected response" in msg