Pin is_disconnect leader-code matrix and do_ping error propagation

Two regression fences on the sync dialect:

1. is_disconnect: existing coverage tested only NOT_LEADER (10250);
   LEADERSHIP_LOST (10506) was in the LEADER_ERROR_CODES tuple but
   untested. Iterate the full tuple and assert each member is
   classified as a disconnect. Add a negative parametrised test
   across common non-leader SQLite codes (1 / 5 / 14 / 19) to guard
   against a broadened check misclassifying them.

2. do_ping: the narrow except tuple was tested for RuntimeError only;
   programming-error categories (AttributeError, TypeError,
   AssertionError) that signal real refactor bugs should propagate
   too, not silently return False. Parametrised test fences each.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

tests/test_dialect_dialect_config.py

@@ -250,6 +250,28 @@ def test_propagates_unexpected_exception(self) -> None:
         with pytest.raises(RuntimeError, match="bug"):
             dialect.do_ping(conn)
 
+    @pytest.mark.parametrize(
+        "exc_cls,msg",
+        [
+            (AttributeError, "stale attribute"),
+            (TypeError, "bad signature"),
+            (AssertionError, "invariant violated"),
+        ],
+    )
+    def test_propagates_programming_errors(self, exc_cls: type[Exception], msg: str) -> None:
+        """A broadened except in do_ping would swallow refactor bugs
+        (AttributeError from a renamed attribute, TypeError from a
+        stale signature, AssertionError from a violated invariant) and
+        silently return False — pool health checks would pass while
+        the real fault rotted. Pin propagation for each category."""
+        dialect = DqliteDialect()
+        conn = MagicMock()
+        cursor = MagicMock()
+        conn.cursor.return_value = cursor
+        cursor.execute.side_effect = exc_cls(msg)
+        with pytest.raises(exc_cls, match=msg):
+            dialect.do_ping(conn)
+
 
 class TestIsDisconnectTypeDispatch:
     def test_dqlite_connection_error_is_disconnect(self) -> None:
@@ -275,3 +297,31 @@ def test_unrelated_operational_error_is_not_disconnect(self) -> None:
         dialect = DqliteDialect()
         e = dqlitedbapi.exceptions.OperationalError("no such table")
         assert dialect.is_disconnect(e, None, None) is False
+
+    def test_is_disconnect_true_for_every_leader_error_code(self) -> None:
+        """Pin the full LEADER_ERROR_CODES tuple — if a future refactor
+        drops SQLITE_IOERR_LEADERSHIP_LOST from the constant, a real
+        leadership transfer stops triggering the reconnect path and the
+        only signal is application latency, not a test failure."""
+        from dqlitewire import LEADER_ERROR_CODES
+
+        dialect = DqliteDialect()
+        for code in LEADER_ERROR_CODES:
+            e = dqliteclient.exceptions.OperationalError(code, "leader gone")
+            assert dialect.is_disconnect(e, None, None) is True, (
+                f"LEADER_ERROR_CODES member {code} must be classified "
+                f"as a disconnect — is_disconnect returned False."
+            )
+
+    @pytest.mark.parametrize("code", [1, 5, 19, 14])
+    def test_is_disconnect_false_for_non_leader_codes(self, code: int) -> None:
+        """Defensive fence against future reclassification drift: a stray
+        OperationalError carrying a common SQLite code (generic error,
+        SQLITE_BUSY, SQLITE_CONSTRAINT, SQLITE_CANTOPEN) must not be
+        misread as a disconnect. Constraint codes in particular now
+        surface as IntegrityError after ISSUE-209, but this test pins
+        the fallback behaviour for any stray OperationalError that
+        slips through."""
+        dialect = DqliteDialect()
+        e = dqliteclient.exceptions.OperationalError(code, "application error")
+        assert dialect.is_disconnect(e, None, None) is False