Pin is_disconnect OS-level branches

DqliteDialect.is_disconnect classifies OSError, ConnectionError,
BrokenPipeError, and TimeoutError alongside the dbapi-level
OperationalError / InterfaceError taxonomy so SA's pool can
invalidate slot on transport failures. Tests only pinned the
dbapi-level paths and the wrapped DqliteConnectionError __cause__
chain; the three OS-level types had no direct assertion, leaving
a refactor that narrows the tuple (e.g. "OSError covers Linux,
drop ConnectionError") to silently break pool recycling.

Parametrize across OSError, BrokenPipeError, ConnectionError,
ConnectionResetError, and TimeoutError. Add an inverse pin that
ProgrammingError is not classified as a disconnect — guarding
against the symmetric widening regression.

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

Author: antoineleclair

tests/test_dialect.py

@@ -381,6 +381,39 @@ def test_does_not_flag_other_interface_errors(self) -> None:
         e = dqlitedbapi.exceptions.InterfaceError("arraysize must be positive")
         assert dialect.is_disconnect(e, None, None) is False
 
+    @pytest.mark.parametrize(
+        "exc",
+        [
+            OSError(32, "broken pipe"),
+            BrokenPipeError(32, "broken pipe"),
+            ConnectionError("peer went away"),
+            ConnectionResetError(104, "connection reset by peer"),
+            TimeoutError("read timed out"),
+        ],
+    )
+    def test_recognizes_os_level_disconnect_branches(self, exc: BaseException) -> None:
+        """The ``is_disconnect`` tuple includes OSError, ConnectionError,
+        BrokenPipeError, and TimeoutError. ``ConnectionError`` and
+        ``TimeoutError`` are semantically distinct from OSError on
+        Python 3.11+ — pin each branch so a refactor narrowing the
+        tuple (e.g. dropping ConnectionError because "OSError covers
+        it on Linux") would fail loudly and not silently break
+        pool invalidation on transport failures.
+        """
+        dialect = DqliteDialect()
+        assert dialect.is_disconnect(exc, None, None) is True
+
+    def test_does_not_flag_programming_error(self) -> None:
+        """Inverse pin: ProgrammingError is not a transport failure
+        and must not route through the disconnect path — otherwise SA
+        would invalidate a healthy connection on e.g. a syntax error.
+        """
+        import dqlitedbapi.exceptions
+
+        dialect = DqliteDialect()
+        e = dqlitedbapi.exceptions.ProgrammingError("no such function: foo")
+        assert dialect.is_disconnect(e, None, None) is False
+
     def test_recognizes_wrapped_dqlite_connection_error_via_cause(self) -> None:
         """The dbapi ``_call_client`` handler wraps a client-level
         ``DqliteConnectionError`` into a bare ``OperationalError`` (no