Fix resource leak when async connection close fails

Wrap close() in try/finally to ensure the event loop and thread are
always cleaned up, even if closing the async connection raises.

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

Author: antoineleclair

src/dqlitedbapi/connection.py

@@ -1,6 +1,7 @@
 """PEP 249 Connection implementation for dqlite."""
 
 import asyncio
+import contextlib
 import threading
 from typing import Any
 
@@ -85,17 +86,20 @@ async def _get_async_connection(self) -> DqliteConnection:
 
     def close(self) -> None:
         """Close the connection."""
-        if self._async_conn is not None:
-            self._run_sync(self._async_conn.close())
-            self._async_conn = None
-        if self._loop is not None and not self._loop.is_closed():
-            self._loop.call_soon_threadsafe(self._loop.stop)
-            if self._thread is not None:
-                self._thread.join(timeout=5)
-            self._loop.close()
-            self._loop = None
-            self._thread = None
-        self._closed = True
+        try:
+            if self._async_conn is not None:
+                with contextlib.suppress(Exception):
+                    self._run_sync(self._async_conn.close())
+                self._async_conn = None
+        finally:
+            if self._loop is not None and not self._loop.is_closed():
+                self._loop.call_soon_threadsafe(self._loop.stop)
+                if self._thread is not None:
+                    self._thread.join(timeout=5)
+                self._loop.close()
+                self._loop = None
+                self._thread = None
+            self._closed = True
 
     def commit(self) -> None:
         """Commit any pending transaction."""

tests/test_close_resource_leak.py

@@ -0,0 +1,35 @@
+"""Tests that close() cleans up resources even if async close fails."""
+
+from unittest.mock import AsyncMock, patch
+
+from dqlitedbapi.connection import Connection
+
+
+class TestCloseResourceLeak:
+    def test_close_cleans_up_loop_even_if_async_close_fails(self) -> None:
+        """Event loop and thread must be cleaned up even if async close raises."""
+        conn = Connection("localhost:9001")
+
+        # Force the connection to create a loop and async connection
+        with patch("dqlitedbapi.connection.DqliteConnection") as MockDqliteConn:
+            mock_instance = AsyncMock()
+            mock_instance.connect = AsyncMock()
+            mock_instance._protocol = AsyncMock()
+            mock_instance._db_id = 0
+            # Make close() raise
+            mock_instance.close = AsyncMock(side_effect=RuntimeError("close failed"))
+            MockDqliteConn.return_value = mock_instance
+
+            # Establish connection
+            conn._run_sync(conn._get_async_connection())
+            assert conn._loop is not None
+            assert conn._thread is not None
+            assert conn._thread.is_alive()
+
+            # close() should not raise, and should clean up the loop
+            conn.close()
+
+            assert conn._closed
+            assert conn._loop is None
+            assert conn._thread is None
+            assert conn._async_conn is None