Run underlying close() even if rollback raises outside narrow tuple

AsyncAdaptedConnection.close() did rollback then close as sequential
awaits without a try/finally. If rollback raised CancelledError (a
BaseException, common during async pool dispose) or a programming
bug (AttributeError, RuntimeError), control skipped the underlying
close() and the AsyncConnection leaked. SQLAlchemy's pool does not
re-call close() after a raise, so the leak was permanent.

Wrap the rollback + narrow-catch block in try/finally so close()
runs on any rollback outcome. The narrow-catch path from ISSUE-135
is preserved for the in-scope transport errors; the finally ensures
close runs when the catch does not match. Mirror of ISSUE-224 which
addressed the inverse leak in connect().

Author: antoineleclair

src/sqlalchemydqlite/aio.py

@@ -231,31 +231,40 @@ def close(self) -> None:
         # so programming bugs (AttributeError, TypeError, bare RuntimeError,
         # etc.) still propagate. The tuple mirrors the client layer's own
         # is_disconnect classification in base.py.
+        #
+        # Wrap in ``try/finally`` so close() runs regardless of how
+        # rollback() exits — narrow-caught, programming bug, or
+        # ``BaseException`` like ``CancelledError`` during pool dispose.
+        # SA's pool does not re-call close() on failure, so skipping
+        # close would leak the underlying AsyncConnection. Mirror of the
+        # inverse leak fixed in DqliteDialect_aio.connect().
         try:
-            await_only(self._connection.rollback())
-        except (
-            OperationalError,
-            InterfaceError,
-            DqliteConnectionError,
-            OSError,
-            TimeoutError,
-            ConnectionError,
-        ) as exc:
-            # Silent suppression used to hide e.g. "leader flip
-            # mid-rollback" from operators — a DEBUG line preserves the
-            # diagnostic without masking or propagating. Include both
-            # id(self) and the peer address so a noisy pool can be
-            # correlated to specific adapter instances and nodes.
-            peer = getattr(self._connection, "address", None)
-            logger.debug(
-                "AsyncAdaptedConnection.close (id=%s, peer=%s): "
-                "rollback failed (%s); proceeding to close",
-                id(self),
-                peer,
-                type(exc).__name__,
-                exc_info=True,
-            )
-        await_only(self._connection.close())
+            try:
+                await_only(self._connection.rollback())
+            except (
+                OperationalError,
+                InterfaceError,
+                DqliteConnectionError,
+                OSError,
+                TimeoutError,
+                ConnectionError,
+            ) as exc:
+                # Silent suppression used to hide e.g. "leader flip
+                # mid-rollback" from operators — a DEBUG line preserves
+                # the diagnostic without masking or propagating. Include
+                # both id(self) and the peer address so a noisy pool can
+                # be correlated to specific adapter instances and nodes.
+                peer = getattr(self._connection, "address", None)
+                logger.debug(
+                    "AsyncAdaptedConnection.close (id=%s, peer=%s): "
+                    "rollback failed (%s); proceeding to close",
+                    id(self),
+                    peer,
+                    type(exc).__name__,
+                    exc_info=True,
+                )
+        finally:
+            await_only(self._connection.close())
 
 
 class DqliteDialect_aio(DqliteDialect):  # noqa: N801

tests/test_close_runs_close_after_rollback_raise.py

@@ -0,0 +1,87 @@
+"""AsyncAdaptedConnection.close() must run the underlying close() even if
+rollback() raises outside the narrow suppression tuple.
+
+SQLAlchemy's async pool calls close() during dispose / teardown. If
+rollback() raises an exception not in the narrow catch tuple
+(``BaseException`` like ``CancelledError``, programming bugs, etc.),
+control previously skipped the final ``await_only(self._connection.close())``
+line and the underlying AsyncConnection leaked. SA's pool does NOT
+re-call close() on failure, so the leak is permanent.
+
+Wrap rollback in ``try/finally`` so close() runs on any rollback
+outcome. Mirror of ISSUE-224 which fixed the inverse leak in connect().
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from sqlalchemydqlite.aio import AsyncAdaptedConnection
+
+
+class _FakeAsyncConn:
+    def __init__(self, rollback_exc: BaseException | None) -> None:
+        self._rollback_exc = rollback_exc
+        self.close_calls = 0
+
+    async def rollback(self) -> None:
+        if self._rollback_exc is not None:
+            raise self._rollback_exc
+
+    async def close(self) -> None:
+        self.close_calls += 1
+
+
+def _install_fake_await_only() -> tuple[object, object]:
+    """Replace await_only in the aio module with a sync driver so tests
+    don't need a live SA engine / greenlet context.
+    """
+    from sqlalchemydqlite import aio as aio_module
+
+    def _fake_await_only(coro: object) -> object:
+        return asyncio.new_event_loop().run_until_complete(coro)  # type: ignore[arg-type]
+
+    orig = aio_module.await_only
+    aio_module.await_only = _fake_await_only  # type: ignore[assignment]
+    return aio_module, orig
+
+
+def _restore_await_only(aio_module: object, orig: object) -> None:
+    aio_module.await_only = orig  # type: ignore[attr-defined]
+
+
+def test_close_runs_after_rollback_raises_cancelled_error() -> None:
+    """CancelledError is a BaseException and not in the narrow catch
+    tuple. The underlying close() must still run — and then the
+    CancelledError propagates as the active exception.
+    """
+    fake = _FakeAsyncConn(asyncio.CancelledError())
+    adapter = AsyncAdaptedConnection(fake)  # type: ignore[arg-type]
+
+    aio_module, orig = _install_fake_await_only()
+    try:
+        with pytest.raises(asyncio.CancelledError):
+            adapter.close()
+    finally:
+        _restore_await_only(aio_module, orig)
+
+    assert fake.close_calls == 1
+
+
+def test_close_runs_after_rollback_raises_attribute_error() -> None:
+    """A programming bug in rollback (AttributeError) still must not
+    prevent close() from running, even though the bug propagates.
+    """
+    fake = _FakeAsyncConn(AttributeError("bug"))
+    adapter = AsyncAdaptedConnection(fake)  # type: ignore[arg-type]
+
+    aio_module, orig = _install_fake_await_only()
+    try:
+        with pytest.raises(AttributeError, match="bug"):
+            adapter.close()
+    finally:
+        _restore_await_only(aio_module, orig)
+
+    assert fake.close_calls == 1