fix: make DqliteConnection.close() safely idempotent

close() previously called _check_in_use() up front, which raised
InterfaceError for pool-released connections — breaking __aexit__ and
try/finally cleanup patterns that hold the connection across release.
A concurrent second close could also race on nulling _protocol after
wait_closed().

Short-circuit when _pool_released or _protocol is already None. Null
_protocol before awaiting wait_closed so a concurrent second call
sees already-closed state.

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -156,13 +156,21 @@ async def connect(self) -> None:
             self._in_use = False
 
     async def close(self) -> None:
-        """Close the connection."""
+        """Close the connection.
+
+        Idempotent: safe to call on an already-closed or pool-released
+        connection. Null ``_protocol`` before awaiting ``wait_closed`` so
+        a concurrent second close cannot re-enter the socket-close path.
+        """
+        # Pool-released or already-closed: nothing to do.
+        if self._pool_released or self._protocol is None:
+            return
         self._check_in_use()
-        if self._protocol is not None:
-            self._protocol.close()
-            await self._protocol.wait_closed()
-            self._protocol = None
-            self._db_id = None
+        protocol = self._protocol
+        self._protocol = None
+        self._db_id = None
+        protocol.close()
+        await protocol.wait_closed()
 
     async def __aenter__(self) -> "DqliteConnection":
         await self.connect()

tests/test_connection.py

@@ -801,6 +801,26 @@ async def test_not_connected_after_invalidation_chains_cause(
         assert exc_info.value.__cause__ is not None
         assert isinstance(exc_info.value.__cause__, OperationalError)
 
+    async def test_close_is_idempotent_on_second_call(self, connected_connection) -> None:
+        """close() must be safe to call twice; a second call must no-op
+        rather than re-enter _check_in_use and raise.
+        """
+        conn, _, _ = connected_connection
+        await conn.close()
+        # Second close should not raise.
+        await conn.close()
+        assert not conn.is_connected
+
+    async def test_close_on_pool_released_connection_is_noop(self, connected_connection) -> None:
+        """A pool-released connection's close() must no-op rather than raise
+        InterfaceError. __aexit__ and try/finally cleanup patterns rely on
+        this.
+        """
+        conn, _, _ = connected_connection
+        conn._pool_released = True
+        # Would previously raise InterfaceError("returned to the pool").
+        await conn.close()
+
     async def test_cross_event_loop_raises_interface_error(self) -> None:
         """Using a connection from a different event loop must raise InterfaceError."""
         import asyncio