collab-runtime 0.2.9__py3-none-any.whl

tests/backend/unit/lock_client/test_lock_client_history.py

@@ -0,0 +1,301 @@
+"""History-related tests for LockClient."""
+
+from __future__ import annotations
+
+import pytest
+
+from ._helpers import FakeResponse, load_lock_client_module, make_create_client
+
+mod = load_lock_client_module()
+
+
+def test_history_all_files(monkeypatch):
+    """Test fetching lock history for all files."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+
+    history_data = [
+        {"file_path": "src/app.py", "developer_id": "user1", "action": "acquired"},
+        {"file_path": "src/app.py", "developer_id": "user1", "action": "released"},
+    ]
+    response = FakeResponse(status=200, data=history_data)
+    monkeypatch.setattr(mod, "_get_create_client", lambda: make_create_client(response))
+
+    lc = mod.LockClient(developer_id="test_user")
+    history = lc.history()
+    assert isinstance(history, list)
+
+
+def test_history_specific_file(monkeypatch):
+    """Test fetching lock history for a specific file."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+
+    history_data = [
+        {"file_path": "src/app.py", "developer_id": "user1", "action": "acquired"}
+    ]
+    response = FakeResponse(status=200, data=history_data)
+    monkeypatch.setattr(mod, "_get_create_client", lambda: make_create_client(response))
+
+    lc = mod.LockClient(developer_id="test_user")
+    history = lc.history(file_path="src/app.py", limit=10)
+    assert isinstance(history, list)
+
+
+def test_history_exception(monkeypatch):
+    """Test history returns empty list when API raises exception."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+
+    class ExplodingClient:
+        def __init__(self, resp):
+            self._resp = resp
+
+        def table(self, *a, **k):
+            raise RuntimeError("DB error")
+
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: (lambda url, key: ExplodingClient(None))
+    )
+
+    lc = mod.LockClient(developer_id="test_user")
+    history = lc.history()
+    assert history == []
+
+
+# RESTORED: test_history_fallback_exception
+def test_history_fallback_exception(monkeypatch):
+    """Test history partial exception."""
+    monkeypatch.setattr(mod, "SUPABASE_SERVICE_ROLE_KEY", "admin_key")
+    monkeypatch.setattr(mod, "_supabase_create_client", lambda url, key: None)
+
+    class FakeQuery:
+        def select(self, *args):
+            return self
+
+        def eq(self, *args):
+            return self
+
+        def is_(self, *args):
+            return self
+
+        def ilike(self, *args):
+            return self
+
+        def order(self, *args, **kwargs):
+            return self
+
+        def limit(self, *args):
+            return self
+
+        def execute(self):
+            return None
+
+    class FakeClient:
+        def table(self, *args):
+            return FakeQuery()
+
+    client = getattr(mod, "LockClient")()
+    client._client = FakeClient()
+    monkeypatch.setattr(client, "_parse_response", lambda res: (False, [], None))
+
+    # Pass an object that throws when string methods are called
+    class Exploder:
+        def replace(self, *args, **kwargs):
+            raise Exception("boom")
+
+    res = client.history(limit=5, file_path=Exploder())
+    assert res == []
+
+
+def test_prune_history_rejects_invalid_retention(monkeypatch):
+    """prune_history should reject retention values < 1."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+
+    lc = mod.LockClient(developer_id="test_user")
+    ok, deleted, msg = lc.prune_history(retention_days=0)
+
+    assert ok is False
+    assert deleted == 0
+    assert ">= 1" in msg
+
+
+def test_prune_history_rpc_success(monkeypatch):
+    """prune_history should return deleted count from RPC when available."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+
+    class RpcClient:
+        def rpc(self, *args, **kwargs):
+            return self
+
+        def execute(self):
+            return None
+
+    lc = mod.LockClient(developer_id="test_user")
+    lc._client = RpcClient()
+    monkeypatch.setattr(
+        lc, "_parse_response", lambda _res: (200, [{"prune_lock_history": 7}], None)
+    )
+    monkeypatch.setattr(mod, "_retry_on_network_error", lambda fn: fn())
+
+    ok, deleted, msg = lc.prune_history(retention_days=30)
+
+    assert ok is True
+    assert deleted == 7
+    assert msg == "history-pruned"
+
+
+def test_prune_history_fallback_success(monkeypatch):
+    """prune_history should fall back to REST delete when RPC is unavailable."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+
+    class FallbackQuery:
+        def __init__(self):
+            self.lt_called = False
+
+        def delete(self):
+            return self
+
+        def lt(self, *_args, **_kwargs):
+            self.lt_called = True
+            return self
+
+        def execute(self):
+            return None
+
+    class FallbackClient:
+        def __init__(self):
+            self.query = FallbackQuery()
+
+        def rpc(self, *args, **kwargs):
+            raise RuntimeError("missing RPC")
+
+        def table(self, *args, **kwargs):
+            return self.query
+
+    lc = mod.LockClient(developer_id="test_user")
+    fake_client = FallbackClient()
+    lc._client = fake_client
+    monkeypatch.setattr(mod, "_retry_on_network_error", lambda fn: fn())
+    monkeypatch.setattr(
+        lc, "_parse_response", lambda _res: (200, [{"id": 1}, {"id": 2}], None)
+    )
+
+    ok, deleted, msg = lc.prune_history(retention_days=30)
+
+    assert ok is True
+    assert deleted == 2
+    assert msg == "history-pruned-fallback"
+    assert fake_client.query.lt_called is True
+
+
+def test_prune_history_fallback_api_error(monkeypatch):
+    """prune_history should surface API errors from fallback delete path."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+
+    class FallbackQuery:
+        def delete(self):
+            return self
+
+        def lt(self, *_args, **_kwargs):
+            return self
+
+        def execute(self):
+            return None
+
+    class FallbackClient:
+        def rpc(self, *args, **kwargs):
+            raise RuntimeError("missing RPC")
+
+        def table(self, *args, **kwargs):
+            return FallbackQuery()
+
+    lc = mod.LockClient(developer_id="test_user")
+    lc._client = FallbackClient()
+    monkeypatch.setattr(mod, "_retry_on_network_error", lambda fn: fn())
+    monkeypatch.setattr(
+        lc, "_parse_response", lambda _res: (500, None, {"message": "boom"})
+    )
+
+    ok, deleted, msg = lc.prune_history(retention_days=30)
+
+    assert ok is False
+    assert deleted == 0
+    assert "API Error" in msg
+
+
+@pytest.mark.parametrize(
+    ("rpc_data", "expected_deleted"),
+    [
+        ([{"prune_lock_history": "not-an-int", "count": "3"}], 3),
+        ([11], 11),
+        (9, 9),
+    ],
+)
+def test_prune_history_rpc_data_shapes(monkeypatch, rpc_data, expected_deleted):
+    """prune_history should parse multiple RPC return shapes robustly."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+
+    class RpcClient:
+        def rpc(self, *args, **kwargs):
+            return self
+
+        def execute(self):
+            return None
+
+    lc = mod.LockClient(developer_id="test_user")
+    lc._client = RpcClient()
+    monkeypatch.setattr(lc, "_parse_response", lambda _res: (200, rpc_data, None))
+    monkeypatch.setattr(mod, "_retry_on_network_error", lambda fn: fn())
+
+    ok, deleted, msg = lc.prune_history(retention_days=30)
+
+    assert ok is True
+    assert deleted == expected_deleted
+    assert msg == "history-pruned"
+
+
+def test_prune_history_fallback_exception_path(monkeypatch):
+    """prune_history should return API Error when fallback delete raises."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+
+    class FallbackClient:
+        def rpc(self, *args, **kwargs):
+            raise RuntimeError("missing RPC")
+
+        def table(self, *args, **kwargs):
+            raise RuntimeError("delete boom")
+
+    lc = mod.LockClient(developer_id="test_user")
+    lc._client = FallbackClient()
+    monkeypatch.setattr(mod, "_retry_on_network_error", lambda fn: fn())
+
+    ok, deleted, msg = lc.prune_history(retention_days=30)
+
+    assert ok is False
+    assert deleted == 0
+    assert "delete boom" in msg

tests/backend/unit/lock_client/test_lock_client_isolation.py

@@ -0,0 +1,316 @@
+"""Comprehensive tests for production/test environment isolation.
+
+This test module ensures that:
+1. Test daemons never interfere with production daemons
+2. Test discovery filters don't match production watcher processes
+3. PID files are isolated and scoped by namespace
+4. Tests cannot kill or affect production locks
+
+This prevents the recurring issue where pytest runs would terminate the
+production daemon or cause status flips due to cross-namespace discovery.
+"""
+
+import json
+import os
+import sys
+import types
+from pathlib import Path
+
+from ._helpers import load_lock_client_module
+
+
+def test_namespace_filter_rejects_mismatched_watcher(monkeypatch, tmp_path):
+    """Discovery must reject watcher processes without matching PID namespace tag."""
+    mod = load_lock_client_module()
+
+    # Set up test client with isolated PID file
+    test_pid_file = str(tmp_path / "test.pid")
+    monkeypatch.setattr(mod, "PID_FILE", test_pid_file)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+
+    # Mock psutil to return a watcher WITHOUT the --pid-file tag
+    # (simulating a legacy or production watcher)
+    class FakeProc:
+        def __init__(self, pid, cmdline):
+            self.info = {"pid": pid, "cmdline": cmdline}
+
+    def fake_process_iter(attrs=("pid", "cmdline")):
+        return [
+            # Production watcher WITHOUT namespace tag - should be rejected
+            FakeProc(
+                5555,
+                [
+                    "python",
+                    ".collab/pycharm/live_locks_watcher.py",
+                    # NO --pid-file tag
+                ],
+            ),
+            # Test watcher WITH matching namespace tag - should be accepted
+            FakeProc(
+                6666,
+                [
+                    "python",
+                    ".collab/pycharm/live_locks_watcher.py",
+                    "--pid-file",
+                    test_pid_file,
+                ],
+            ),
+        ]
+
+    fake_psutil = types.SimpleNamespace(process_iter=fake_process_iter)
+    monkeypatch.setitem(sys.modules, "psutil", fake_psutil)
+
+    client = mod.LockClient(local_only=True)
+    found_pids = client._discover_running_watchers()
+
+    # Should ONLY find the namespaced test watcher (6666)
+    # Should REJECT the untagged production watcher (5555)
+    assert 6666 in found_pids, "Namespaced test watcher must be discovered"
+    assert (
+        5555 not in found_pids
+    ), "Unnamespaced production watcher must be filtered out in test mode"
+
+
+def test_pid_file_namespace_tag_round_trip(monkeypatch, tmp_path):
+    """PID file namespace tag must survive write/read cycle correctly."""
+    mod = load_lock_client_module()
+
+    test_pid_file = str(tmp_path / "roundtrip.pid")
+    test_pid = 9999
+
+    # Write with namespace metadata
+    monkeypatch.setattr(mod, "PID_FILE", test_pid_file)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+    monkeypatch.setenv("COLLAB_STATE_DIR", str(tmp_path))
+
+    # Simulate daemon writing PID with namespace tag
+    pid_meta = {
+        "pid": test_pid,
+        "started_at": "2026-05-02T10:00:00Z",
+        "entrypoint": "python lock_client.py",
+        "cmdline": (
+            f"python .collab/pycharm/live_locks_watcher.py "
+            f"--pid-file {test_pid_file}"
+        ),
+        "cwd": os.getcwd(),
+    }
+    Path(test_pid_file).write_text(json.dumps(pid_meta), encoding="utf-8")
+
+    # Read and verify namespace tag is present
+    read_data = json.loads(Path(test_pid_file).read_text(encoding="utf-8"))
+    assert "cmdline" in read_data
+    assert f"--pid-file {test_pid_file}" in read_data["cmdline"]
+    assert read_data["pid"] == test_pid
+
+
+def test_conflicting_pid_files_are_independent(monkeypatch, tmp_path):
+    """Test and prod PID files must be independent, not affected by deletion."""
+    load_lock_client_module()
+
+    test_pid_file = str(tmp_path / "test_independent.pid")
+    prod_pid_file = str(tmp_path / "prod_independent.pid")
+
+    # Create both files
+    Path(test_pid_file).write_text("1111", encoding="utf-8")
+    Path(prod_pid_file).write_text("2222", encoding="utf-8")
+
+    assert Path(test_pid_file).exists()
+    assert Path(prod_pid_file).exists()
+
+    # Delete test PID file (simulating test cleanup)
+    Path(test_pid_file).unlink()
+
+    # Production PID file must remain untouched
+    assert not Path(test_pid_file).exists()
+    assert Path(prod_pid_file).exists()
+    assert Path(prod_pid_file).read_text(encoding="utf-8") == "2222"
+
+
+def test_discover_watchers_filters_by_strict_namespace(monkeypatch, tmp_path):
+    """In test mode, discover_running_watchers uses strict namespace filtering."""
+    mod = load_lock_client_module()
+
+    test_pid_file = str(tmp_path / "strict_ns.pid")
+    monkeypatch.setattr(mod, "PID_FILE", test_pid_file)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+
+    class FakeProc:
+        def __init__(self, pid, cmdline):
+            self.info = {"pid": pid, "cmdline": cmdline}
+
+    # Multiple watchers with different or missing namespace tags
+    def fake_process_iter(attrs=("pid", "cmdline")):
+        return [
+            # No tag at all
+            FakeProc(1111, ["python", ".collab/pycharm/live_locks_watcher.py"]),
+            # Wrong namespace tag
+            FakeProc(
+                2222,
+                [
+                    "python",
+                    ".collab/pycharm/live_locks_watcher.py",
+                    "--pid-file",
+                    "/other/path.pid",
+                ],
+            ),
+            # Correct namespace tag
+            FakeProc(
+                3333,
+                [
+                    "python",
+                    ".collab/pycharm/live_locks_watcher.py",
+                    "--pid-file",
+                    test_pid_file,
+                ],
+            ),
+        ]
+
+    fake_psutil = types.SimpleNamespace(process_iter=fake_process_iter)
+    monkeypatch.setitem(sys.modules, "psutil", fake_psutil)
+
+    client = mod.LockClient(local_only=True)
+    found = client._discover_running_watchers()
+
+    # Only correct namespace should match
+    assert 3333 in found
+    assert 1111 not in found
+    assert 2222 not in found
+
+
+def test_extract_pid_file_from_cmdline_parsing(monkeypatch, tmp_path):
+    """Verify _extract_pid_file_from_cmdline correctly parses namespace tags."""
+    mod = load_lock_client_module()
+
+    client = mod.LockClient(local_only=True)
+
+    # Test various cmdline formats
+    test_path = str(tmp_path / "test.pid")
+
+    # Standard format with --pid-file flag
+    cmdline = f"python watcher.py --pid-file {test_path}"
+    extracted = client._extract_pid_file_from_cmdline(cmdline)
+    assert extracted == test_path
+
+    # Without --pid-file flag
+    cmdline_no_flag = "python watcher.py"
+    extracted_no_flag = client._extract_pid_file_from_cmdline(cmdline_no_flag)
+    assert extracted_no_flag is None
+
+    # With other flags before --pid-file
+    cmdline_multi = f"python watcher.py --verbose --pid-file {test_path} --timeout 30"
+    extracted_multi = client._extract_pid_file_from_cmdline(cmdline_multi)
+    assert extracted_multi == test_path
+
+
+def test_cmdline_matches_current_pid_namespace_validation(monkeypatch, tmp_path):
+    """Verify namespace matching only accepts properly scoped watchers."""
+    mod = load_lock_client_module()
+
+    test_pid_file = str(tmp_path / "validation.pid")
+    monkeypatch.setattr(mod, "PID_FILE", test_pid_file)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+
+    client = mod.LockClient(local_only=True)
+
+    # Matching namespace - should return True
+    matching_cmdline = f"python watcher.py --pid-file {test_pid_file}"
+    assert client._cmdline_matches_current_pid_namespace(matching_cmdline)
+
+    # Mismatched namespace - should return False
+    other_pid_file = str(tmp_path / "other.pid")
+    mismatched_cmdline = f"python watcher.py --pid-file {other_pid_file}"
+    assert not client._cmdline_matches_current_pid_namespace(mismatched_cmdline)
+
+    # No namespace tag in test mode - should return False (strict test isolation)
+    no_tag_cmdline = "python watcher.py"
+    assert not client._cmdline_matches_current_pid_namespace(no_tag_cmdline)
+
+
+def test_isolation_prevents_cross_namespace_discovery(monkeypatch, tmp_path):
+    """Ensure test discovery cannot find production processes."""
+    mod = load_lock_client_module()
+
+    test_pid_file = str(tmp_path / "test_ns.pid")
+    prod_pid_file = str(tmp_path / "prod_ns.pid")
+
+    # Simulate two independent namespaces
+    monkeypatch.setattr(mod, "PID_FILE", test_pid_file)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+
+    class FakeProc:
+        def __init__(self, pid, cmdline):
+            self.info = {"pid": pid, "cmdline": cmdline}
+
+    # One client in test mode
+    def fake_iter_test(attrs=("pid", "cmdline")):
+        return [
+            # Test watcher (namespaced)
+            FakeProc(
+                11111,
+                [
+                    "python",
+                    ".collab/pycharm/live_locks_watcher.py",
+                    "--pid-file",
+                    test_pid_file,
+                ],
+            ),
+            # Production watcher (different namespace)
+            FakeProc(
+                22222,
+                [
+                    "python",
+                    ".collab/pycharm/live_locks_watcher.py",
+                    "--pid-file",
+                    prod_pid_file,
+                ],
+            ),
+        ]
+
+    fake_psutil = types.SimpleNamespace(process_iter=fake_iter_test)
+    monkeypatch.setitem(sys.modules, "psutil", fake_psutil)
+
+    # Test discovery should only find its own namespaced process
+    client = mod.LockClient(local_only=True)
+    found = client._discover_running_watchers()
+
+    assert 11111 in found, "Test watcher in same namespace must be found"
+    assert (
+        22222 not in found
+    ), "Production watcher in different namespace must be filtered"
+
+
+def test_pid_namespace_isolation_env_override(monkeypatch, tmp_path):
+    """Verify COLLAB_PID_FILE env var creates proper isolation."""
+    load_lock_client_module()
+
+    isolated_pid = str(tmp_path / "isolated.pid")
+    monkeypatch.setenv("COLLAB_PID_FILE", isolated_pid)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+
+    # Force reload of PID_FILE from environment
+    if "COLLAB_PID_FILE" in os.environ:
+        pid_file_to_use = os.environ["COLLAB_PID_FILE"]
+        assert pid_file_to_use == isolated_pid
+
+
+def test_namespace_tag_propagation_in_watcher_spawn(monkeypatch, tmp_path):
+    """Verify daemon_start properly tags spawned watcher with --pid-file."""
+    mod = load_lock_client_module()
+
+    test_pid_file = str(tmp_path / "spawn_test.pid")
+    monkeypatch.setattr(mod, "PID_FILE", test_pid_file)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+
+    # Verify that the spawn command includes --pid-file parameter
+    mod.LockClient(local_only=True)
+
+    # The spawn logic should include --pid-file in the command
+    # (We test this indirectly by checking the module's spawn implementation
+    # includes the flag in daemon_start's subprocess call)
+    source = mod.__file__
+    with open(source, "r", encoding="utf-8") as f:
+        content = f.read()
+        # Verify daemon_start includes --pid-file when spawning watch
+        assert (
+            "--pid-file" in content
+        ), "daemon_start must include --pid-file when spawning watcher"

tests/backend/unit/lock_client/test_lock_client_pid.py

@@ -0,0 +1,75 @@
+import json
+
+from ._helpers import load_lock_client_module
+
+mod = load_lock_client_module()
+
+
+def test_read_pid_missing(tmp_path):
+    mod = load_lock_client_module()
+    # Point PID_FILE to a non-existent path
+    mod.PID_FILE = str(tmp_path / "missing.pid")
+    assert mod.LockClient._read_pid() is None
+
+
+def test_read_pid_plain_integer(tmp_path):
+    mod = load_lock_client_module()
+    p = tmp_path / "plain.pid"
+    p.write_text("12345")
+    mod.PID_FILE = str(p)
+    assert mod.LockClient._read_pid() == 12345
+
+
+def test_read_pid_json_and_invalid(tmp_path):
+    mod = load_lock_client_module()
+    p = tmp_path / "meta.pid"
+    p.write_text(json.dumps({"pid": 54321, "started": "now"}))
+    mod.PID_FILE = str(p)
+    assert mod.LockClient._read_pid() == 54321
+
+    # Invalid JSON should return None
+    p2 = tmp_path / "bad.pid"
+    p2.write_text("{not json")
+    mod.PID_FILE = str(p2)
+    assert mod.LockClient._read_pid() is None
+
+
+def test_read_pid_file_method(tmp_path):
+    mod = load_lock_client_module()
+    p = tmp_path / "meta2.pid"
+    data = {"pid": 1111, "cwd": "C:/proj"}
+    p.write_text(json.dumps(data))
+    mod.PID_FILE = str(p)
+    client = mod.LockClient(local_only=True)
+    meta = client._read_pid_file()
+    assert isinstance(meta, dict)
+    assert meta.get("pid") == 1111
+
+
+def test_write_pid_fallback_on_replace_failure(monkeypatch, tmp_path):
+    pid_file = tmp_path / "daemon.pid"
+    monkeypatch.setattr(mod, "PID_FILE", str(pid_file))
+
+    replace_called = [False]
+
+    def failing_replace(src, dst):
+        replace_called[0] = True
+        if not mod.os.path.exists(pid_file):
+            raise OSError("Access denied")
+
+    monkeypatch.setattr(mod.os, "replace", failing_replace)
+
+    mod.LockClient._write_pid(12345, parent_pid=678, token="tok123")
+    assert pid_file.exists()
+    data = json.loads(pid_file.read_text())
+    assert data["pid"] == 12345
+
+
+def test_remove_pid_notest_mode(monkeypatch, tmp_path):
+    monkeypatch.delenv("COLLAB_TEST_MODE", raising=False)
+    pid_file = tmp_path / "daemon.pid"
+    pid_file.write_text("12345")
+    monkeypatch.setattr(mod, "PID_FILE", str(pid_file))
+
+    mod.LockClient._remove_pid()
+    assert not pid_file.exists()