fix: bind event loop lazily in _check_in_use, not only in connect

Previously _bound_loop was set only inside connect(). Tests/subclasses
that construct a bare DqliteConnection and swap in a mocked _protocol
bypassed the loop-mismatch guard entirely — _check_in_use returned early
when _bound_loop was None. Bind the loop on first _check_in_use so the
guard is always active.

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -172,18 +172,22 @@ def _check_in_use(self) -> None:
                 "This connection has been returned to the pool and can no longer "
                 "be used directly. Acquire a new connection from the pool."
             )
-        if self._bound_loop is not None:
-            try:
-                current_loop = asyncio.get_running_loop()
-            except RuntimeError:
-                raise InterfaceError(
-                    "DqliteConnection must be used from within an async context."
-                ) from None
-            if current_loop is not self._bound_loop:
-                raise InterfaceError(
-                    "DqliteConnection is bound to a different event loop. "
-                    "Do not share connections across event loops or OS threads."
-                )
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            raise InterfaceError(
+                "DqliteConnection must be used from within an async context."
+            ) from None
+        if self._bound_loop is None:
+            # Lazily bind on first use so the guard is always active, even
+            # for bare-instantiation / mocked-protocol patterns that skip
+            # connect().
+            self._bound_loop = current_loop
+        elif current_loop is not self._bound_loop:
+            raise InterfaceError(
+                "DqliteConnection is bound to a different event loop. "
+                "Do not share connections across event loops or OS threads."
+            )
         if self._in_use:
             raise InterfaceError(
                 "Cannot perform operation: another operation is in progress on this "

tests/test_connection.py

@@ -684,6 +684,49 @@ async def tx_b():
         )
         assert "Nested" in str(errors[0]) or "nested" in str(errors[0])
 
+    async def test_loop_guard_active_even_without_connect(self) -> None:
+        """The loop-mismatch guard must bind on first _check_in_use, not only
+        inside connect(). Otherwise bare-instantiation + mocked _protocol
+        patterns (common in tests) bypass the guard.
+        """
+        import asyncio
+        import threading
+
+        from dqliteclient.exceptions import InterfaceError
+
+        conn = DqliteConnection("localhost:9001")
+        # Simulate a test that mocks the protocol without calling connect().
+        conn._protocol = MagicMock()
+        conn._db_id = 1
+
+        # First operation in this loop should bind the loop implicitly.
+        conn._check_in_use()
+        first_loop = conn._bound_loop
+        assert first_loop is asyncio.get_running_loop(), (
+            "first _check_in_use should bind the current event loop"
+        )
+
+        # Crossing into a new loop from another thread should raise.
+        error_from_thread: Exception | None = None
+
+        def run_in_other_loop() -> None:
+            nonlocal error_from_thread
+
+            async def use_conn() -> None:
+                conn._check_in_use()
+
+            try:
+                asyncio.run(use_conn())
+            except Exception as e:
+                error_from_thread = e
+
+        thread = threading.Thread(target=run_in_other_loop)
+        thread.start()
+        thread.join(timeout=5)
+
+        assert isinstance(error_from_thread, InterfaceError)
+        assert "event loop" in str(error_from_thread).lower()
+
     async def test_cross_event_loop_raises_interface_error(self) -> None:
         """Using a connection from a different event loop must raise InterfaceError."""
         import asyncio