Reset the asyncio connect lock when the background event loop is torn down

Connection.close() nulled the loop and thread but left _connect_lock
pointing at an asyncio.Lock bound to the loop that had just been closed.
The lazy-create branch in _get_async_connection only rebuilds the lock
when it finds None, so a future path that re-enters after close() would
reuse a primitive attached to a dead loop.

Set _connect_lock back to None alongside _loop/_thread inside the same
critical section so the invariant "asyncio primitive is either None or
attached to the live loop" holds uniformly with the async connection's
lazy-init contract. The public API still guards against use-after-close
via the _closed flag; this is the defensive half of the same contract.

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

Author: antoineleclair

src/dqlitedbapi/connection.py

@@ -282,6 +282,11 @@ def close(self) -> None:
                     self._loop.close()
                     self._loop = None
                     self._thread = None
+                # Drop the asyncio.Lock bound to the loop we just closed;
+                # the lazy-create branch in _get_async_connection rebuilds it
+                # against the next loop so the primitive never outlives its
+                # owning event loop.
+                self._connect_lock = None
 
     async def _close_async(self) -> None:
         """Async implementation of close -- runs on event loop thread."""

tests/test_cursor.py

@@ -130,3 +130,24 @@ def test_scroll_raises_not_supported(self) -> None:
         cursor = Cursor(conn)
         with pytest.raises(NotSupportedError):
             cursor.scroll(0)
+
+
+class TestConnectionCloseResetsLock:
+    def test_close_nulls_connect_lock(self) -> None:
+        """After close(), the asyncio connect lock must be reset so it
+        doesn't outlive its owning loop (symmetry with the async side)."""
+        import asyncio
+
+        conn = Connection("localhost:9001")
+        # Simulate the state a lazy _get_async_connection would have left:
+        # a background loop running and an asyncio.Lock created on it.
+        loop = conn._ensure_loop()
+
+        async def _make_lock() -> asyncio.Lock:
+            return asyncio.Lock()
+
+        conn._connect_lock = asyncio.run_coroutine_threadsafe(_make_lock(), loop).result(timeout=5)
+        assert conn._connect_lock is not None
+
+        conn.close()
+        assert conn._connect_lock is None