fix: check _in_use guard in close() to prevent closing during in-flight operations

close() was the only public method on DqliteConnection that did not call
_check_in_use(). This allowed a concurrent coroutine to close the connection
while another coroutine was mid-operation, producing a misleading
DqliteConnectionError("Connection closed by server") instead of a clear
InterfaceError.

Fixes #095

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -117,6 +117,7 @@ async def connect(self) -> None:
 
     async def close(self) -> None:
         """Close the connection."""
+        self._check_in_use()
         if self._protocol is not None:
             self._protocol.close()
             await self._protocol.wait_closed()

tests/test_connection.py

@@ -726,3 +726,52 @@ async def second_connect():
 
         assert len(errors) == 1
         assert "another operation is in progress" in str(errors[0])
+
+    async def test_close_while_in_use_raises_interface_error(self) -> None:
+        """close() must raise InterfaceError if an operation is in progress."""
+        import asyncio
+
+        from dqliteclient.exceptions import InterfaceError
+
+        conn = DqliteConnection("localhost:9001")
+
+        mock_reader = AsyncMock()
+        mock_writer = MagicMock()
+        mock_writer.drain = AsyncMock()
+        mock_writer.close = MagicMock()
+        mock_writer.wait_closed = AsyncMock()
+
+        from dqlitewire.messages import DbResponse, WelcomeResponse
+
+        responses = [
+            WelcomeResponse(heartbeat_timeout=15000).encode(),
+            DbResponse(db_id=1).encode(),
+        ]
+        mock_reader.read.side_effect = responses
+
+        with patch("asyncio.open_connection", return_value=(mock_reader, mock_writer)):
+            await conn.connect()
+
+        # Make execute hang so close() runs while execute is in progress
+        execute_entered = asyncio.Event()
+
+        async def slow_exec_sql(db_id, sql, params=None):
+            execute_entered.set()
+            await asyncio.sleep(10)
+            return (0, 1)
+
+        conn._protocol.exec_sql = AsyncMock(side_effect=slow_exec_sql)  # type: ignore[union-attr]
+
+        async def do_execute():
+            await conn.execute("INSERT INTO t VALUES (1)")
+
+        task = asyncio.create_task(do_execute())
+        await execute_entered.wait()
+
+        # close() should raise because execute is in progress
+        with pytest.raises(InterfaceError, match="another operation is in progress"):
+            await conn.close()
+
+        task.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await task