Add unit tests for the macOS fallback guard and the cli pre-spawn helper

Covers the load-bearing behaviors introduced by the prior commits:

- _maybe_fallback_start re-raises on darwin (commit 1)
- _maybe_fallback_start still re-raises non-fds_to_keep errors verbatim
- _open_worker_log honors $SQLIT_WORKER_LOG and survives an unwritable path
- _prewarm_process_worker respects runtime.process_worker, runtime.mock,
  and swallows spawn exceptions so startup never crashes (commit 3)
- SSMSTUI(process_worker_client=client) stashes the client on
  self._process_worker_client, which is what ProcessWorkerLifecycleMixin
  consults first

Author: brentrager

tests/unit/test_cli_prewarm.py

@@ -0,0 +1,64 @@
+"""Tests for the pre-spawn helper in cli.py and the SSMSTUI kwarg plumbing."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from sqlit.cli import _prewarm_process_worker
+from sqlit.shared.app.runtime import MockConfig, RuntimeConfig
+
+
+def test_prewarm_skipped_when_worker_disabled() -> None:
+    runtime = RuntimeConfig(process_worker=False)
+    with patch("sqlit.domains.process_worker.app.process_worker_client.ProcessWorkerClient") as klass:
+        result = _prewarm_process_worker(runtime)
+    assert result is None
+    klass.assert_not_called()
+
+
+def test_prewarm_skipped_when_mock_enabled() -> None:
+    runtime = RuntimeConfig(process_worker=True, mock=MockConfig(enabled=True))
+    with patch("sqlit.domains.process_worker.app.process_worker_client.ProcessWorkerClient") as klass:
+        result = _prewarm_process_worker(runtime)
+    assert result is None
+    klass.assert_not_called()
+
+
+def test_prewarm_returns_client_when_enabled() -> None:
+    runtime = RuntimeConfig(process_worker=True)
+    sentinel = MagicMock(name="process-worker-client")
+    with patch(
+        "sqlit.domains.process_worker.app.process_worker_client.ProcessWorkerClient",
+        return_value=sentinel,
+    ):
+        result = _prewarm_process_worker(runtime)
+    assert result is sentinel
+
+
+def test_prewarm_swallows_spawn_errors() -> None:
+    """A failing pre-spawn must not break startup; lazy path handles fallback."""
+    runtime = RuntimeConfig(process_worker=True)
+    with patch(
+        "sqlit.domains.process_worker.app.process_worker_client.ProcessWorkerClient",
+        side_effect=ValueError("bad value(s) in fds_to_keep"),
+    ):
+        result = _prewarm_process_worker(runtime)
+    assert result is None
+
+
+def test_ssmstui_stashes_prewarmed_worker() -> None:
+    """A client passed via the kwarg should land on self._process_worker_client.
+
+    ProcessWorkerLifecycleMixin returns that attribute first, so this is
+    what makes the pre-spawn actually short-circuit the lazy path.
+    """
+    from sqlit.domains.shell.app.main import SSMSTUI
+    from tests.ui.mocks import MockConnectionStore, MockSettingsStore, build_test_services, create_test_connection
+
+    services = build_test_services(
+        connection_store=MockConnectionStore([create_test_connection("test-db", "sqlite")]),
+        settings_store=MockSettingsStore({}),
+    )
+    sentinel = MagicMock(name="process-worker-client")
+    app = SSMSTUI(services=services, process_worker_client=sentinel)
+    assert app._process_worker_client is sentinel

tests/unit/test_process_worker_fallback.py

@@ -0,0 +1,68 @@
+"""Tests for the macOS fork-fallback guard and the worker log redirect."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from sqlit.domains.process_worker.app.process_worker import _open_worker_log
+from sqlit.domains.process_worker.app.process_worker_client import ProcessWorkerClient
+
+
+def _make_client_without_init() -> ProcessWorkerClient:
+    """Build a bare ProcessWorkerClient instance without running __init__.
+
+    __init__ spawns a real subprocess; we only want to exercise the
+    in-process branching logic in _maybe_fallback_start.
+    """
+    return ProcessWorkerClient.__new__(ProcessWorkerClient)
+
+
+def test_fork_fallback_disabled_on_darwin(monkeypatch: pytest.MonkeyPatch) -> None:
+    """On macOS the fallback path must re-raise instead of forking."""
+    monkeypatch.setattr("sys.platform", "darwin")
+    client = _make_client_without_init()
+
+    error = ValueError("bad value(s) in fds_to_keep")
+    with pytest.raises(ValueError, match="fds_to_keep"):
+        client._maybe_fallback_start(error)
+
+
+def test_fork_fallback_skips_non_fds_errors(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Errors unrelated to fds_to_keep should always re-raise verbatim."""
+    monkeypatch.setattr("sys.platform", "linux")
+    client = _make_client_without_init()
+
+    error = ValueError("totally unrelated message")
+    with pytest.raises(ValueError, match="totally unrelated"):
+        client._maybe_fallback_start(error)
+
+
+def test_worker_log_honors_env_override(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """SQLIT_WORKER_LOG should redirect the worker log to a custom path."""
+    target = tmp_path / "subdir" / "worker.log"
+    monkeypatch.setenv("SQLIT_WORKER_LOG", str(target))
+
+    log_file = _open_worker_log()
+    assert log_file is not None
+    try:
+        log_file.write("hello\n")
+    finally:
+        log_file.close()
+
+    assert target.exists()
+    assert "hello" in target.read_text()
+
+
+def test_worker_log_returns_none_on_unwritable_path(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """If the log path can't be opened, the worker should still boot."""
+    # A path whose parent can't be created (root-owned, non-existent).
+    monkeypatch.setenv("SQLIT_WORKER_LOG", "/proc/definitely/not/writable/here.log")
+
+    log_file = _open_worker_log()
+    assert log_file is None