collab-runtime 0.2.9__py3-none-any.whl

tests/backend/unit/test_main_watch_pid_file.py

@@ -0,0 +1,278 @@
+"""Targeted tests for watch command branches in src/main.py."""
+
+from __future__ import annotations
+
+import sys
+from contextlib import nullcontext
+
+
+def test_run_cli_watch_pid_file_sets_namespace(monkeypatch):
+    import src.lock_client as lc
+    import src.main as main_mod
+
+    class _Client:
+        def __init__(self, local_only=False):
+            self.local_only = local_only
+
+        def watch(self, **kwargs):
+            called["kwargs"] = kwargs
+
+    called = {"kwargs": None}
+
+    monkeypatch.setattr(
+        main_mod,
+        "setup_collab_logging",
+        lambda **_k: None,
+        raising=False,
+    )
+    monkeypatch.setattr(main_mod, "_quiet_console_loggers", lambda: None, raising=False)
+    monkeypatch.setattr(main_mod, "LockClient", _Client, raising=False)
+
+    # _run_cli lazily imports these symbols from lock_client each invocation.
+    monkeypatch.setattr(lc, "LockClient", _Client)
+    monkeypatch.setattr(lc, "_quiet_console_loggers", lambda: None)
+    monkeypatch.setattr(lc, "_COLLAB_ROOT", ".collab")
+
+    import src.logging_config as logging_config
+
+    monkeypatch.setattr(logging_config, "setup_collab_logging", lambda **_k: None)
+
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        [
+            "collab",
+            "watch",
+            "--pid-file",
+            "tmp.daemon.pid",
+            "--interval",
+            "2",
+            "--timeout",
+            "1",
+        ],
+    )
+
+    main_mod._run_cli()
+    assert lc.PID_FILE == "tmp.daemon.pid"
+    assert called["kwargs"] is not None
+    assert called["kwargs"]["interval"] == 2
+
+
+def test_run_cli_active_auto_starts_and_reconciles(monkeypatch, capsys):
+    import src.lock_client as lc
+    import src.main as main_mod
+
+    called = {"status": 0, "start": 0, "reconcile": 0}
+
+    class _Client:
+        def __init__(self, local_only=False):
+            self.local_only = local_only
+
+        def daemon_status(self):
+            called["status"] += 1
+            return False
+
+        def daemon_start(self):
+            called["start"] += 1
+
+        def _reconcile(self):
+            called["reconcile"] += 1
+
+        def active(self):
+            return []
+
+    monkeypatch.setattr(
+        main_mod,
+        "setup_collab_logging",
+        lambda **_k: None,
+        raising=False,
+    )
+    monkeypatch.setattr(
+        main_mod,
+        "_quiet_console_loggers",
+        lambda: nullcontext(),
+        raising=False,
+    )
+    monkeypatch.setattr(main_mod, "LockClient", _Client, raising=False)
+
+    monkeypatch.setattr(lc, "LockClient", _Client)
+    monkeypatch.setattr(lc, "_quiet_console_loggers", lambda: nullcontext())
+    monkeypatch.setattr(lc, "_COLLAB_ROOT", ".collab")
+
+    import src.logging_config as logging_config
+
+    monkeypatch.setattr(logging_config, "setup_collab_logging", lambda **_k: None)
+
+    monkeypatch.delenv("PYTEST_CURRENT_TEST", raising=False)
+    monkeypatch.setenv("COLLAB_AUTO_START_WATCHER", "1")
+    monkeypatch.setattr(sys, "argv", ["collab", "active"])
+
+    main_mod._run_cli()
+    out = capsys.readouterr().out
+
+    assert called["status"] == 1
+    assert called["start"] == 1
+    assert called["reconcile"] == 1
+    assert "No active locks." in out
+
+
+def test_run_cli_active_auto_start_can_be_disabled(monkeypatch, capsys):
+    import src.lock_client as lc
+    import src.main as main_mod
+
+    called = {"status": 0, "start": 0, "reconcile": 0}
+
+    class _Client:
+        def __init__(self, local_only=False):
+            self.local_only = local_only
+
+        def daemon_status(self):
+            called["status"] += 1
+            return False
+
+        def daemon_start(self):
+            called["start"] += 1
+
+        def _reconcile(self):
+            called["reconcile"] += 1
+
+        def active(self):
+            return []
+
+    monkeypatch.setattr(
+        main_mod,
+        "setup_collab_logging",
+        lambda **_k: None,
+        raising=False,
+    )
+    monkeypatch.setattr(
+        main_mod,
+        "_quiet_console_loggers",
+        lambda: nullcontext(),
+        raising=False,
+    )
+    monkeypatch.setattr(main_mod, "LockClient", _Client, raising=False)
+
+    monkeypatch.setattr(lc, "LockClient", _Client)
+    monkeypatch.setattr(lc, "_quiet_console_loggers", lambda: nullcontext())
+    monkeypatch.setattr(lc, "_COLLAB_ROOT", ".collab")
+
+    import src.logging_config as logging_config
+
+    monkeypatch.setattr(logging_config, "setup_collab_logging", lambda **_k: None)
+
+    monkeypatch.delenv("PYTEST_CURRENT_TEST", raising=False)
+    monkeypatch.setenv("COLLAB_AUTO_START_WATCHER", "0")
+    monkeypatch.setattr(sys, "argv", ["collab", "active"])
+
+    main_mod._run_cli()
+    out = capsys.readouterr().out
+
+    assert called["status"] == 0
+    assert called["start"] == 0
+    assert called["reconcile"] == 0
+    assert "No active locks." in out
+
+
+def test_is_truthy_env_uses_default_when_missing(monkeypatch):
+    import src.main as main_mod
+
+    monkeypatch.delenv("COLLAB_TEST_BOOL", raising=False)
+    assert main_mod._is_truthy_env("COLLAB_TEST_BOOL", default=True) is True
+    assert main_mod._is_truthy_env("COLLAB_TEST_BOOL", default=False) is False
+
+
+def test_ensure_watcher_running_non_target_command(monkeypatch):
+    import src.main as main_mod
+
+    class _Client:
+        pass
+
+    monkeypatch.delenv("PYTEST_CURRENT_TEST", raising=False)
+    monkeypatch.setenv("COLLAB_AUTO_START_WATCHER", "1")
+    assert main_mod._ensure_watcher_running(_Client(), "release") is False
+
+
+def test_ensure_watcher_running_skips_when_daemon_alive(monkeypatch):
+    import src.main as main_mod
+
+    class _Client:
+        def daemon_status(self):
+            return True
+
+        def daemon_start(self):
+            raise AssertionError("daemon_start should not be called")
+
+    monkeypatch.delenv("PYTEST_CURRENT_TEST", raising=False)
+    monkeypatch.setenv("COLLAB_AUTO_START_WATCHER", "1")
+    assert main_mod._ensure_watcher_running(_Client(), "active") is False
+
+
+def test_ensure_watcher_running_start_failure(monkeypatch):
+    import src.main as main_mod
+
+    class _Client:
+        def daemon_status(self):
+            raise RuntimeError("status failed")
+
+        def daemon_start(self):
+            raise RuntimeError("start failed")
+
+    monkeypatch.delenv("PYTEST_CURRENT_TEST", raising=False)
+    monkeypatch.setenv("COLLAB_AUTO_START_WATCHER", "1")
+    assert main_mod._ensure_watcher_running(_Client(), "status") is False
+
+
+def test_run_cli_active_reconcile_exception_is_non_fatal(monkeypatch, capsys):
+    import src.lock_client as lc
+    import src.main as main_mod
+
+    called = {"start": 0}
+
+    class _Client:
+        def __init__(self, local_only=False):
+            self.local_only = local_only
+
+        def daemon_status(self):
+            return False
+
+        def daemon_start(self):
+            called["start"] += 1
+
+        def _reconcile(self):
+            raise RuntimeError("reconcile boom")
+
+        def active(self):
+            return []
+
+    monkeypatch.setattr(
+        main_mod,
+        "setup_collab_logging",
+        lambda **_k: None,
+        raising=False,
+    )
+    monkeypatch.setattr(
+        main_mod,
+        "_quiet_console_loggers",
+        lambda: nullcontext(),
+        raising=False,
+    )
+    monkeypatch.setattr(main_mod, "LockClient", _Client, raising=False)
+
+    monkeypatch.setattr(lc, "LockClient", _Client)
+    monkeypatch.setattr(lc, "_quiet_console_loggers", lambda: nullcontext())
+    monkeypatch.setattr(lc, "_COLLAB_ROOT", ".collab")
+
+    import src.logging_config as logging_config
+
+    monkeypatch.setattr(logging_config, "setup_collab_logging", lambda **_k: None)
+
+    monkeypatch.delenv("PYTEST_CURRENT_TEST", raising=False)
+    monkeypatch.setenv("COLLAB_AUTO_START_WATCHER", "1")
+    monkeypatch.setattr(sys, "argv", ["collab", "active"])
+
+    main_mod._run_cli()
+    out = capsys.readouterr().out
+
+    assert called["start"] == 1
+    assert "No active locks." in out

tests/conftest.py

@@ -0,0 +1,167 @@
+import atexit
+import importlib.util
+import os
+import re
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+# ============================================================================
+# EARLY ISOLATION (MUST HAPPEN BEFORE TEST COLLECTION)
+# ============================================================================
+# Pytest imports test modules during the test collection phase, which happens
+# *before* session-scoped fixtures execute. Since lock_client and watcher
+# modules eagerly evaluate os.getenv("COLLAB_PID_FILE") at module load time,
+# we MUST set test isolation variables at the top level of this file.
+
+_session_temp_dir = tempfile.mkdtemp(prefix="collab_test_")
+
+os.environ["COLLAB_STATE_DIR"] = _session_temp_dir
+os.environ["COLLAB_PID_FILE"] = os.path.join(_session_temp_dir, "daemon.pid")
+os.environ["COLLAB_TEST_MODE"] = "1"
+
+# We forcibly mock these for ALL tests to prevent accidental production leakage.
+# Individual tests can still use monkeypatch if they need specific dummy values.
+os.environ["SUPABASE_URL"] = "http://localhost:54321"
+os.environ["SUPABASE_ANON_KEY"] = "test-anon-key-session"
+
+
+def _cleanup_session_temp():
+    try:
+        shutil.rmtree(_session_temp_dir)
+    except Exception:
+        pass
+
+
+def _is_test_watcher_cmdline(cmdline: str) -> bool:
+    """Return True for watcher processes started by test runs only."""
+    text = (cmdline or "").lower().replace('"', "")
+    if "lock_client.py watch" not in text:
+        return False
+    if "--daemon" not in text:
+        return False
+    if "--pid-file" not in text:
+        return False
+    # Strictly match temp test namespaces; never touch production .collab/.daemon.pid.
+    return (
+        "pytest-of-" in text
+        or "collab_test_" in text
+        or "mockcmms_pytest_collab_" in text
+    )
+
+
+def _terminate_orphan_test_watchers() -> None:
+    """Best-effort kill for orphaned test watcher daemons.
+
+    Keeps scope narrow to test-mode watcher cmdlines so production daemons are never
+    affected.
+    """
+    try:
+        if os.name == "nt":
+            proc = subprocess.run(
+                [
+                    "powershell",
+                    "-NoProfile",
+                    "-Command",
+                    (
+                        "Get-CimInstance Win32_Process | "
+                        "Where-Object { $_.Name -eq 'pythonw.exe' "
+                        "-or $_.Name -eq 'python.exe' } | "
+                        "Select-Object ProcessId,CommandLine | "
+                        "ConvertTo-Json -Compress"
+                    ),
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            raw = (proc.stdout or "").strip()
+            if not raw:
+                return
+            import json
+
+            rows = json.loads(raw)
+            if isinstance(rows, dict):
+                rows = [rows]
+            for row in rows:
+                pid = int(row.get("ProcessId", 0) or 0)
+                cmdline = row.get("CommandLine") or ""
+                if pid > 0 and _is_test_watcher_cmdline(cmdline):
+                    try:
+                        os.kill(pid, signal.SIGTERM)
+                    except Exception:
+                        pass
+        else:
+            proc = subprocess.run(
+                ["ps", "-eo", "pid,args"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            for line in (proc.stdout or "").splitlines():
+                m = re.match(r"^\s*(\d+)\s+(.*)$", line)
+                if not m:
+                    continue
+                pid = int(m.group(1))
+                cmdline = m.group(2)
+                if _is_test_watcher_cmdline(cmdline):
+                    try:
+                        os.kill(pid, signal.SIGTERM)
+                    except Exception:
+                        pass
+    except Exception:
+        pass
+
+
+# Ensure test mode is explicitly kept, do not clear it, so late-firing
+# atexit hooks attached to test processes still skip network calls.
+atexit.register(_cleanup_session_temp)
+atexit.register(_terminate_orphan_test_watchers)
+
+
+def pytest_sessionfinish(session, exitstatus):
+    """Cleanup any orphaned test watcher daemons at end of a pytest session."""
+    _terminate_orphan_test_watchers()
+
+
+def _load_logging_config_module():
+    collab_root = Path(__file__).resolve().parents[2]
+    logging_config_path = collab_root / "logging_config.py"
+    spec = importlib.util.spec_from_file_location(
+        "collab.logging_config_test_cleanup", str(logging_config_path)
+    )
+    assert spec and spec.loader
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)  # type: ignore[arg-type]
+    return module
+
+
+@pytest.fixture(autouse=True)
+def _close_collab_logging_after_each_test():
+    yield
+    try:
+        _load_logging_config_module().close_collab_logging()
+    except Exception:
+        pass
+
+
+# ============================================================================
+# MOCKS & FIXTURES
+# ============================================================================
+
+
+class FakeNotification:
+    def notify(self, **kwargs):
+        pass
+
+
+class FakePlyer:
+    notification = FakeNotification()
+
+
+sys.modules["plyer"] = FakePlyer()  # type: ignore[assignment]

tests/packaging/test_smoke_install.py

@@ -0,0 +1,76 @@
+"""CI-only packaging smoke test.
+
+Builds an sdist+wheel and verifies the produced wheel can be installed into an ephemeral
+venv and that the installed package exposes the `collab` import surface and a non-empty
+`__version__` string.
+
+This test is intentionally marked `packaging` and should only run in CI.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+def _find_repo_root(start: Path) -> Path:
+    cur = start.resolve()
+    for p in [cur] + list(cur.parents):
+        if (p / "pyproject.toml").exists() or (p / "setup.py").exists():
+            return p
+    raise RuntimeError("Could not find project root (pyproject.toml or setup.py)")
+
+
+@pytest.mark.packaging
+def test_smoke_install_build_and_import(tmp_path: Path) -> None:
+    repo_root = _find_repo_root(Path(__file__))
+    dist_dir = tmp_path / "dist"
+    dist_dir.mkdir(parents=True, exist_ok=True)
+
+    # Build sdist+wheel
+    subprocess.check_call(
+        [
+            sys.executable,
+            "-m",
+            "build",
+            "--sdist",
+            "--wheel",
+            "--outdir",
+            str(dist_dir),
+        ],
+        cwd=str(repo_root),
+    )
+
+    # Create ephemeral venv
+    venv_dir = tmp_path / "venv"
+    subprocess.check_call([sys.executable, "-m", "venv", str(venv_dir)])
+    if os.name == "nt":
+        venv_dir / "Scripts" / "pip.exe"
+        py = venv_dir / "Scripts" / "python.exe"
+    else:
+        venv_dir / "bin" / "pip"
+        py = venv_dir / "bin" / "python"
+
+    # Install wheel (use `python -m pip` which is more reliable across platforms)
+    wheels = list(dist_dir.glob("*.whl"))
+    assert wheels, "no wheel produced"
+    subprocess.check_call(
+        [str(py), "-m", "pip", "install", "--upgrade", "pip"]
+    )  # ensure modern pip
+    subprocess.check_call([str(py), "-m", "pip", "install", str(wheels[0])])
+
+    # Validate import surface
+    subprocess.check_call(
+        [
+            str(py),
+            "-c",
+            "import importlib;print(importlib.import_module('collab').__version__)",
+        ]
+    )
+
+    # Validate CLI surface via module execution (portable across platforms)
+    subprocess.check_call([str(py), "-m", "collab", "--help"])