Collapse redundant OSError-subclass tuples to isinstance(e, OSError)

ConnectionError, BrokenPipeError, and TimeoutError are all OSError
subclasses, so listing them next to OSError in an isinstance tuple
or except clause is redundant. The single OSError check also picks
up ConnectionResetError, ConnectionAbortedError, ConnectionRefusedError,
InterruptedError, and socket.gaierror that the narrower enumeration
silently missed.

Cleans up is_disconnect and both do_ping except tuples (the inner
cursor.execute branch and the finally cursor.close branch). Adds a
defensive parametrised test plus a socket.gaierror pin so a future
regression that re-enumerates subclasses cannot silently shrink the
coverage.

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

Author: antoineleclair

src/sqlalchemydqlite/base.py

@@ -360,8 +360,13 @@ def is_disconnect(self, e: Any, connection: Any, cursor: Any) -> bool:
         if isinstance(getattr(e, "__cause__", None), _client_exc.DqliteConnectionError):
             return True
         # Underlying OS-level transport failures (socket RST, broken pipe,
-        # DNS, connect refused) surface as these stdlib types.
-        if isinstance(e, (ConnectionError, BrokenPipeError, TimeoutError, OSError)):
+        # DNS, connect refused, connection timeout). ``ConnectionError``,
+        # ``BrokenPipeError``, and ``TimeoutError`` are all ``OSError``
+        # subclasses, so a single ``OSError`` check covers every stdlib
+        # transport-error shape (including ``ConnectionResetError`` /
+        # ``ConnectionAbortedError`` / ``ConnectionRefusedError`` /
+        # ``socket.gaierror`` that a narrower enumeration would miss).
+        if isinstance(e, OSError):
             return True
         # ``dqlitedbapi.Connection`` / ``Cursor`` raise ``InterfaceError``
         # when operated on after ``close()``; match the narrow
@@ -404,7 +409,6 @@ def do_ping(self, dbapi_connection: Any) -> bool:
                 _dbapi_exc.InterfaceError,
                 _client_exc.DqliteConnectionError,
                 OSError,
-                TimeoutError,
             ):
                 return False
         finally:
@@ -422,7 +426,6 @@ def do_ping(self, dbapi_connection: Any) -> bool:
                 _dbapi_exc.InterfaceError,
                 _client_exc.DqliteConnectionError,
                 OSError,
-                TimeoutError,
             ) as exc:
                 logger.debug(
                     "do_ping: cursor.close failed (%s); proceeding",

tests/test_dialect_dialect_config.py

@@ -348,6 +348,42 @@ def test_is_disconnect_false_for_non_leader_codes(self, code: int) -> None:
         e = dqliteclient.exceptions.OperationalError(code, "application error")
         assert dialect.is_disconnect(e, None, None) is False
 
+    @pytest.mark.parametrize(
+        "exc_cls",
+        [
+            OSError,
+            ConnectionError,
+            BrokenPipeError,
+            TimeoutError,
+            ConnectionResetError,
+            ConnectionAbortedError,
+            ConnectionRefusedError,
+            InterruptedError,
+        ],
+    )
+    def test_every_oserror_subclass_is_disconnect(self, exc_cls: type[BaseException]) -> None:
+        """Every stdlib OSError subclass classifies as a disconnect.
+
+        Guards against a future regression that replaces the single
+        ``isinstance(e, OSError)`` check with an explicit subclass
+        enumeration — which would silently miss ``ConnectionResetError``
+        / ``ConnectionAbortedError`` / ``ConnectionRefusedError`` /
+        ``InterruptedError`` and the ``socket.gaierror`` /
+        ``socket.herror`` DNS-failure shapes.
+        """
+        dialect = DqliteDialect()
+        assert dialect.is_disconnect(exc_cls("x"), None, None) is True
+
+    def test_socket_gaierror_is_disconnect(self) -> None:
+        """``socket.gaierror`` is an OSError subclass used for DNS
+        resolution failures — exactly the "DNS" case the branch
+        comment promises to cover.
+        """
+        import socket
+
+        dialect = DqliteDialect()
+        assert dialect.is_disconnect(socket.gaierror("name or service"), None, None) is True
+
 
 class TestSupportsSaneRowcountFlags:
     """Pin the ``supports_sane_rowcount`` quartet on the dialect class