Reset async connection locks on close

AsyncConnection.close() sets _closed and drops the underlying
DqliteConnection but leaves _connect_lock / _op_lock bound to the loop
they were first touched on. A subsequent fixture or SQLAlchemy glue
path that re-uses the object across loops would observe stale
primitives. Null both attributes in close() so the invariant "an
asyncio primitive is None or bound to the live loop" holds across both
sync and async Connection classes.

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

Author: antoineleclair

src/dqlitedbapi/aio/connection.py

@@ -123,12 +123,24 @@ async def close(self) -> None:
         # in-flight op (if any) under the lock.
         self._closed = True
         if self._async_conn is None:
+            # Null the lazy locks so a subsequent fixture or
+            # SQLAlchemy-glue reuse of the object in a different event
+            # loop cannot observe a primitive bound to the dead loop.
+            # Parity with the sync close() reset established for
+            # connect_lock.
+            self._connect_lock = None
+            self._op_lock = None
             return
         _, op_lock = self._ensure_locks()
         async with op_lock:
             if self._async_conn is not None:
                 await self._async_conn.close()
                 self._async_conn = None
+        # Reset the locks *after* closing so any task that was parked on
+        # ``op_lock`` observes the "_closed -> raise InterfaceError"
+        # re-check before it touches the now-None primitive.
+        self._connect_lock = None
+        self._op_lock = None
 
     async def commit(self) -> None:
         """Commit any pending transaction.

tests/test_async_lock_binding.py

@@ -46,3 +46,22 @@ async def touch_locks() -> None:
         conn._connect_lock = None
         conn._op_lock = None
         asyncio.run(touch_locks())
+
+
+class TestAsyncCloseResetsLocks:
+    """close() nulls the lazily-created locks so a subsequent re-use
+    from a new event loop cannot observe primitives bound to the dead
+    loop. Parity with the sync close() connect_lock reset.
+    """
+
+    def test_close_without_ever_connecting_nulls_locks(self) -> None:
+        async def scenario() -> None:
+            conn = AsyncConnection("localhost:19001", database="x")
+            # No cursor/execute has run; _async_conn is None but the
+            # caller calls close() anyway (matches the docstring
+            # promise that close is safe even on unused connections).
+            await conn.close()
+            assert conn._connect_lock is None
+            assert conn._op_lock is None
+
+        asyncio.run(scenario())