code-coordinator 0.5.489__tar.gz → 0.5.490__tar.gz

{code_coordinator-0.5.489 → code_coordinator-0.5.490}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.489
+Version: 0.5.490
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.489 → code_coordinator-0.5.490}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.489
+Version: 0.5.490
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.489 → code_coordinator-0.5.490}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.489",
+  "tag": "0.5.490",
   "distance": 0,
-  "node": "g70de5f163979948f291485eda2a8ac9db8f4d439",
+  "node": "gfb5dc047d0e9acfa22f379bebb343d14c749080c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-18"

{code_coordinator-0.5.489 → code_coordinator-0.5.490}/coord/db.py

@@ -470,6 +470,92 @@ def _is_release_build(version: str) -> bool:
     return _RELEASE_VERSION_RE.fullmatch(version) is not None
 
 
+class _NoActiveTestConnectionSentinel:
+    """Installed as the ``_conn`` singleton whenever pytest is running but no
+    test's ``coord_db`` fixture currently holds an active override (#3385).
+
+    ``tests/conftest.py``'s autouse ``coord_db`` fixture is function-scoped:
+    it only guarantees an isolated in-memory connection while ONE test's
+    setup/call/teardown phases are running. Before this sentinel existed,
+    that fixture's teardown called :func:`close`, which resets the module
+    singleton to plain ``None`` -- reopening the exact gap #1960's guard was
+    built to close, just one layer up: ANY caller of :func:`get_connection`
+    during that gap (between one test's teardown finishing and the next
+    test's setup starting, or before the very first test's setup has run at
+    all) fell through :func:`get_connection` into :func:`_open`, which
+    resolves the REAL ``~/.coord/coord.db`` (#1960, #3385). #1960's own guard
+    inside :func:`_open` only fires while ``PYTEST_CURRENT_TEST`` happens to
+    be set, which is not guaranteed across that specific gap -- exactly the
+    seam #3385 was filed to close after #3380's daemon-lifespan-shutdown fix
+    left the reported failure count unchanged.
+
+    Installed once at ``pytest_configure`` (before collection even starts,
+    closing the pre-first-test window) and reinstalled by ``coord_db``'s own
+    teardown after every test (closing the inter-test window), so ``_conn``
+    is never plain ``None`` for the life of a pytest process:
+    :func:`get_connection` always hands back either a real per-test override
+    or this sentinel -- it can no longer fall through to :func:`_open` while
+    pytest is running, regardless of what races ahead of the next test's
+    setup or what runs before the first one.
+
+    Any attempt to use it -- ``.execute()``, ``.cursor()``, ``.commit()``,
+    even the ``.closed`` probe :func:`_connection_is_closed` runs on every
+    cached connection -- raises :class:`ProductionDatabaseGuardError`
+    immediately via ``__getattr__``, so a caller that reaches this gets a
+    clear, correctly-attributed error instead of a real database file
+    quietly being opened (or silently reused) underneath it.
+
+    **Scope, stated plainly (#3385 review).** This closes exactly one seam:
+    the ``coord.db._conn`` singleton that :func:`get_connection` reads. It
+    is a real, previously-unguarded gap, but it is not asserted here to be
+    the sole or even primary source of the ~3700
+    ``ProductionDatabaseGuardError`` failures the issue reports on ``main``
+    -- that would require the actual CI failure log, which this fix was not
+    verified against (see the commit message for what evidence is, and is
+    not, available). One other unguarded route was found by inspection
+    while investigating this and is flagged rather than silently left for
+    someone else to rediscover: ``coord.dao.SqliteStore._connect()``'s
+    SQLite branch opens ``self._path`` (``DB_PATH`` by default,
+    resolved once at ``__init__``) with no pytest/non-release guard at all
+    -- unlike its Postgres branch, which calls
+    ``refuse_postgres_under_pytest`` first. ``SqliteStore()`` with no
+    explicit ``db_path`` (e.g. ``coord/reports.py``'s
+    ``_default_usage_rows``) would reach that unguarded path. Left
+    unmodified here: it is outside this fix's file scope
+    (``tests/conftest.py`` / ``coord/db.py``) and there is no confirmed
+    evidence it contributes to the reported count -- but if a post-merge
+    ``main`` ``Tests`` run still shows a nonzero
+    ``ProductionDatabaseGuardError`` count after this change, that is the
+    next place to look.
+    """
+
+    def __getattr__(self, name: str) -> Any:
+        raise ProductionDatabaseGuardError(
+            "coord.db.get_connection() was reached while no test's `coord_db` "
+            "fixture held an active override (#3385) -- this is the gap "
+            "between one test's teardown and the next test's setup, or "
+            "before the very first test's setup has run at all. A caller "
+            f"tried to access {name!r} on the connection singleton in that "
+            "gap. Likely causes: a background thread a prior test spawned "
+            "and never joined, or a fixture that reaches coord.db before "
+            "the autouse `coord_db` fixture has installed its override. See "
+            "#1960 (the guard this generalizes) and #3385 (this sentinel)."
+        )
+
+
+def _pytest_gap_sentinel() -> Any:
+    """Factory for :class:`_NoActiveTestConnectionSentinel` (#3385).
+
+    A function rather than a bare module-level instance so every install
+    site (``tests/conftest.py``'s ``pytest_configure`` and ``coord_db``
+    teardown) gets its own object -- cheap, and it means a traceback's
+    ``id()`` never accidentally suggests two installs shared state they
+    don't (the sentinel is stateless, but nothing here should rely on that
+    by sharing one instance).
+    """
+    return _NoActiveTestConnectionSentinel()
+
+
 def override_connection(conn: Any) -> None:
     """Replace the singleton connection.  Used in tests to inject :memory: DBs.
 

{code_coordinator-0.5.489 → code_coordinator-0.5.490}/tests/conftest.py

@@ -87,11 +87,27 @@ def pytest_configure(config):
 
     A no-op on the default SQLite path: it neither imports a driver nor opens
     a socket, so a plain ``pytest`` is unaffected.
+
+    #3385: also installs ``coord.db``'s pytest-gap sentinel as the initial
+    connection singleton, before collection (and therefore every test
+    module's import-time code) ever runs. See
+    :func:`coord.db._pytest_gap_sentinel` for what this closes: without it,
+    ``coord.db._conn`` starts life as plain ``None`` and stays that way until
+    the FIRST test's autouse ``coord_db`` fixture installs its override --
+    anything that calls ``coord.db.get_connection()`` before that point (e.g.
+    module-level code a test file runs at import/collection time) could fall
+    through to the real ``~/.coord/coord.db``. Installing the sentinel here
+    closes that window the same way ``coord_db``'s own teardown closes the
+    inter-test one.
     """
     from tests.backends import preflight
 
     preflight()
 
+    from coord import db as db_mod
+
+    db_mod.override_connection(db_mod._pytest_gap_sentinel())
+
 
 @pytest.fixture(autouse=True)
 def _non_terminal_work(monkeypatch):
@@ -1111,6 +1127,18 @@ def coord_db():
         # already-closed connection is a no-op on both drivers).
         session.close()
         db.close()
+        # #3385: `db.close()` just reset the singleton to plain `None` --
+        # reopening the gap #1960's guard exists to close, one layer up.
+        # Anything that calls `coord.db.get_connection()` between THIS
+        # test's teardown finishing and the NEXT test's `coord_db` setup
+        # installing its own override (a background thread a prior test
+        # spawned and never joined, a fixture that reaches coord.db before
+        # this one runs) would otherwise fall through to `_open()` and could
+        # reach the real `~/.coord/coord.db`. Installing the sentinel here
+        # closes that window; the next test's `coord_db` setup overwrites it
+        # with a fresh real override before that test's body ever runs, same
+        # as always.
+        db.override_connection(db._pytest_gap_sentinel())
 
 
 # Every module-attribute name that coord.db / coord.state / coord.config /

{code_coordinator-0.5.489 → code_coordinator-0.5.490}/tests/test_db.py

@@ -1100,6 +1100,77 @@ class TestOverrideConnection:
         _ensure_schema(sqlite3.connect(":memory:"))
 
 
+# ── pytest-gap sentinel (#3385) ──────────────────────────────────────────────
+#
+# #3385: `main`'s `Tests` workflow was red for 33 days with thousands of
+# `ProductionDatabaseGuardError`s, and #3380's daemon-lifespan-shutdown fix
+# left the count unchanged -- because the actual gap is in `coord.db`'s
+# connection singleton itself, not the daemon: `tests/conftest.py`'s autouse
+# `coord_db` fixture only guarantees an isolated override while ONE test's
+# own setup/call/teardown phases are running. Its teardown used to call
+# `close()`, which resets `_conn` to plain `None` -- reopening the #1960 gap
+# one layer up for anything that calls `get_connection()` in the window
+# between one test's teardown and the next test's setup, or before the very
+# first test's setup has run at all. #1960's own `PYTEST_CURRENT_TEST` guard
+# inside `_open()` only protects that window if the env var happens to still
+# be set at that exact moment, which is not guaranteed. `_pytest_gap_
+# sentinel()` (installed by both `pytest_configure` and `coord_db`'s
+# teardown in `tests/conftest.py`) closes it unconditionally: `_conn` is
+# never plain `None` for the life of a pytest process, so `get_connection()`
+# can no longer fall through to `_open()` -- and therefore the real
+# `~/.coord/coord.db` -- while pytest is running, regardless of timing.
+class TestPytestGapSentinel:
+    def test_any_attribute_access_raises_the_guard(self) -> None:
+        sentinel = db_mod._pytest_gap_sentinel()
+        with pytest.raises(db_mod.ProductionDatabaseGuardError, match="coord_db"):
+            sentinel.execute("SELECT 1")
+
+    def test_probing_closed_also_raises(self) -> None:
+        """`_connection_is_closed` -- the first thing `get_connection()` does
+        with a cached connection -- reads `.closed` via
+        `getattr(conn, "closed", False)`. The sentinel must not silently
+        answer "not closed" here: that would let `get_connection()` hand the
+        sentinel back as if it were a usable connection, deferring the
+        failure to whatever statement runs next instead of raising at the
+        point the gap was actually reached."""
+        sentinel = db_mod._pytest_gap_sentinel()
+        with pytest.raises(db_mod.ProductionDatabaseGuardError):
+            db_mod._connection_is_closed(sentinel)
+
+    def test_get_connection_raises_instead_of_opening_the_real_path(self) -> None:
+        """Simulates the exact gap #3385 closes: `_conn` holding the
+        sentinel, as `coord_db`'s teardown (and `pytest_configure`, before
+        the first test) now leave it, instead of plain `None`.
+
+        RED against the pre-#3385 shape (installing plain `None` here
+        instead): `get_connection()` would fall through to `_open()`, whose
+        only protection is whether `PYTEST_CURRENT_TEST` happens to be set at
+        that exact moment -- true during this test's own body, so it would
+        incidentally still raise here, just via a DIFFERENT code path (and
+        not at all in the actual gap this issue is about, between two tests,
+        which this single-test assertion cannot reach). GREEN here
+        demonstrates the sentinel raises unconditionally, before `_open()`
+        -- and therefore the real `~/.coord/coord.db` -- is ever reached,
+        which is what actually closes the inter-test gap.
+
+        Restores the real per-test connection in a ``finally`` rather than
+        via ``monkeypatch``: an earlier autouse fixture in
+        ``tests/conftest.py`` already pulls the shared ``monkeypatch``
+        instance's setup forward ahead of ``coord_db`` (see
+        ``_no_frozen_coord_dir_constants``'s docstring), which pushes
+        ``monkeypatch``'s own undo to AFTER ``coord_db``'s teardown -- so a
+        ``monkeypatch.setattr`` here would leave the sentinel installed when
+        ``coord_db``'s teardown tries to ``close()`` it.
+        """
+        original_conn = db_mod._conn
+        db_mod.override_connection(db_mod._pytest_gap_sentinel())
+        try:
+            with pytest.raises(db_mod.ProductionDatabaseGuardError, match="coord_db"):
+                db_mod.get_connection()
+        finally:
+            db_mod.override_connection(original_conn)
+
+
 # ── _resolve_store_target (#827) ─────────────────────────────────────────────
 
 _VALID_REPOS_MACHINES_YAML = (