Make AsyncCursor.callproc sync like its siblings

AsyncCursor exposed three PEP 249 optional extensions that all raise
NotSupportedError unconditionally: ``callproc``, ``nextset``,
``scroll``. Two were plain methods and one (``callproc``) was
``async def``, so ``cursor.callproc("x")`` returned a coroutine
instead of raising. A caller wrapping the call in a bare ``try ...
except NotSupportedError`` would silently see the try block pass and
then leak a never-awaited coroutine.

The method only ever raises; wrapping in a coroutine provided no
value and diverged from the two sibling raisers on the same class
plus ``AsyncAdaptedCursor.callproc`` in the SQLAlchemy dialect. Drop
``async``.

Update the existing raise test to drop the ``await`` and the stale
``@pytest.mark.asyncio`` marker, and add a guardrail test that
inspects all three methods with ``inspect.iscoroutinefunction`` so
future drift is caught.

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

Author: antoineleclair

src/dqlitedbapi/aio/cursor.py

@@ -251,10 +251,17 @@ def setoutputsize(self, size: int, column: int | None = None) -> None:
         """Set output size (no-op for dqlite)."""
         pass
 
-    async def callproc(
+    def callproc(
         self, procname: str, parameters: Sequence[Any] | None = None
     ) -> Sequence[Any] | None:
-        """PEP 249 optional extension — not supported."""
+        """PEP 249 optional extension — not supported.
+
+        Sync despite the cursor being async: the method raises
+        unconditionally, so wrapping it in a coroutine has no value and
+        would diverge from the sync siblings (``nextset`` / ``scroll``)
+        and from the SQLAlchemy adapter (``sqlalchemy-dqlite``), which
+        both expose these as plain methods.
+        """
         raise NotSupportedError("dqlite does not support stored procedures")
 
     def nextset(self) -> bool | None:

tests/test_async_cursor.py

@@ -111,14 +111,26 @@ def test_setoutputsize_noop(self) -> None:
 
 
 class TestOptionalAsyncCursorMethodsRaise:
-    @pytest.mark.asyncio
-    async def test_callproc_raises_not_supported(self) -> None:
+    def test_callproc_raises_not_supported(self) -> None:
         from dqlitedbapi.exceptions import NotSupportedError
 
         conn = AsyncConnection("localhost:9001")
         cursor = AsyncCursor(conn)
         with pytest.raises(NotSupportedError):
-            await cursor.callproc("some_proc")
+            cursor.callproc("some_proc")
+
+    def test_callproc_nextset_scroll_are_sync(self) -> None:
+        """These three PEP 249 optional extensions all unconditionally raise
+        ``NotSupportedError``. They must stay sync so callers can catch the
+        error with a bare ``try: cursor.callproc(...) except ...`` rather
+        than accidentally returning a coroutine object that is never awaited.
+        The adapter in ``sqlalchemy-dqlite`` exposes the same three as sync.
+        """
+        import inspect
+
+        assert not inspect.iscoroutinefunction(AsyncCursor.callproc)
+        assert not inspect.iscoroutinefunction(AsyncCursor.nextset)
+        assert not inspect.iscoroutinefunction(AsyncCursor.scroll)
 
     def test_nextset_raises_not_supported(self) -> None:
         from dqlitedbapi.exceptions import NotSupportedError