Narrow AsyncAdaptedConnection.close rollback suppression

The close path wrapped the pre-close rollback in
contextlib.suppress(Exception), which swallowed every non-BaseException
error — including AttributeError, TypeError, and bare RuntimeError that
signal programming bugs. A bad refactor to the underlying async
connection would silently disappear at close time. Narrow the
suppression to the categories a rollback can legitimately raise
(OperationalError, InterfaceError, DqliteConnectionError, OSError,
TimeoutError, ConnectionError) so programming bugs still propagate,
mirroring the client dialect's own is_disconnect classification. Move
the `import contextlib` to the top of the module as part of the same
cleanup and tighten the existing regression test so it exercises a
genuine connection-level failure; add a companion test that programmer
errors propagate.

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

Author: antoineleclair

src/sqlalchemydqlite/aio.py

@@ -1,5 +1,6 @@
 """Async dqlite dialect for SQLAlchemy."""
 
+import contextlib
 from collections import deque
 from collections.abc import Sequence
 from typing import Any
@@ -9,6 +10,8 @@
 from sqlalchemy.pool import AsyncAdaptedQueuePool
 from sqlalchemy.util import await_only
 
+from dqliteclient.exceptions import DqliteConnectionError
+from dqlitedbapi.exceptions import InterfaceError, OperationalError
 from sqlalchemydqlite.base import DqliteDialect
 
 __all__ = ["DqliteDialect_aio"]
@@ -136,14 +139,23 @@ def rollback(self) -> None:
     def close(self) -> None:
         # Attempt rollback before close so a caller that exits without
         # committing does not leave a dangling server-side transaction.
-        # The underlying async connection's rollback is a
-        # silent no-op when no transaction is active and when the
-        # connection has never been used, so the double-call is safe.
-        # Suppress rollback failures — the close is more important and
-        # happens unconditionally below.
-        import contextlib
-
-        with contextlib.suppress(Exception):
+        # The underlying async connection's rollback is a silent no-op when
+        # no transaction is active and when the connection has never been
+        # used, so the double-call is safe.
+        #
+        # Narrow the suppression to the categories a best-effort rollback
+        # can legitimately raise — connection-level / transport errors —
+        # so programming bugs (AttributeError, TypeError, bare RuntimeError,
+        # etc.) still propagate. The tuple mirrors the client layer's own
+        # is_disconnect classification in base.py.
+        with contextlib.suppress(
+            OperationalError,
+            InterfaceError,
+            DqliteConnectionError,
+            OSError,
+            TimeoutError,
+            ConnectionError,
+        ):
             await_only(self._connection.rollback())
         await_only(self._connection.close())
 

tests/test_async_adapter.py

@@ -126,15 +126,18 @@ def test_close_attempts_rollback_first(self) -> None:
 
         assert calls == ["rollback", "close"], f"Expected rollback then close, got {calls}"
 
-    def test_close_proceeds_when_rollback_raises(self) -> None:
-        """A failing rollback (e.g. connection already in a bad state)
+    def test_close_proceeds_when_rollback_raises_connection_error(self) -> None:
+        """A failing rollback caused by a connection-level error (e.g.
+        broken transport, OS-level disconnect, server already closed)
         must not block close — resource cleanup is more important."""
+        from dqlitedbapi.exceptions import OperationalError
+
         mock_conn = MagicMock()
         calls: list[str] = []
 
         def failing_rollback() -> None:
             calls.append("rollback-attempt")
-            raise RuntimeError("simulated rollback failure")
+            raise OperationalError("simulated rollback failure")
 
         mock_conn.rollback.side_effect = failing_rollback
         mock_conn.close.side_effect = lambda: calls.append("close") or object()
@@ -146,3 +149,22 @@ def failing_rollback() -> None:
             adapted.close()  # must not raise
 
         assert "close" in calls, "close() must run even if rollback raised"
+
+    def test_close_propagates_programming_error_from_rollback(self) -> None:
+        """A failing rollback that looks like a programming bug
+        (AttributeError / TypeError / bare RuntimeError) must propagate
+        so refactor regressions don't get swallowed silently."""
+        import pytest
+
+        mock_conn = MagicMock()
+        mock_conn.rollback.side_effect = AttributeError("refactor bug")
+        mock_conn.close.return_value = object()
+
+        adapted = AsyncAdaptedConnection.__new__(AsyncAdaptedConnection)
+        adapted._connection = mock_conn
+
+        with (
+            patch("sqlalchemydqlite.aio.await_only", side_effect=_run_sync),
+            pytest.raises(AttributeError),
+        ):
+            adapted.close()