Forward governors and validate timeout in the async PEP 249 factories

aio.connect() / aio.aconnect() accepted only address / database / timeout
and silently dropped the three DoS-governor parameters that
AsyncConnection already supports: max_total_rows, max_continuation_frames,
and trust_server_heartbeat. This mirrored the sync-side gap already
closed earlier, but the async side was missed. Worse, the SQLAlchemy
async dialect forwards URL query parameters straight into aio.connect()
via loaded_dbapi.connect(**kwargs), so a URL like
dqlite+aio://host/db?max_total_rows=500 raised
TypeError: unexpected keyword argument 'max_total_rows' at engine-connect
time rather than applying the cap.

Add the three kwargs to both factories with the same defaults as the
sync side, plus a math.isfinite timeout check at the public boundary so
errors surface at call-site in both sync and async APIs. Regression
tests cover: all governors forwarded, defaults, None caps, and invalid
timeout values.

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

Author: antoineleclair

src/dqlitedbapi/aio/__init__.py

@@ -1,5 +1,7 @@
 """Async PEP 249-style interface for dqlite."""
 
+import math
+
 from dqlitedbapi import __version__
 from dqlitedbapi.aio.connection import AsyncConnection
 from dqlitedbapi.aio.cursor import AsyncCursor
@@ -91,6 +93,9 @@ def connect(
     *,
     database: str = "default",
     timeout: float = 10.0,
+    max_total_rows: int | None = 10_000_000,
+    max_continuation_frames: int | None = 100_000,
+    trust_server_heartbeat: bool = False,
 ) -> AsyncConnection:
     """Create a dqlite connection (connects lazily on first use).
 
@@ -101,19 +106,40 @@ def connect(
     Args:
         address: Node address in "host:port" format
         database: Database name to open
-        timeout: Connection timeout in seconds
+        timeout: Connection timeout in seconds — must be a positive
+            finite number. 0, negatives, and non-finite values are
+            rejected here rather than silently passed through.
+        max_total_rows: Cumulative row cap across continuation frames
+            for a single query. Forwarded to the underlying
+            AsyncConnection. None disables the cap.
+        max_continuation_frames: Per-query continuation-frame cap.
+            Forwarded to the underlying AsyncConnection.
+        trust_server_heartbeat: Let the server-advertised heartbeat
+            widen the per-read deadline. Default False.
 
     Returns:
         An AsyncConnection object
     """
-    return AsyncConnection(address, database=database, timeout=timeout)
+    if not math.isfinite(timeout) or timeout <= 0:
+        raise ProgrammingError(f"timeout must be a positive finite number, got {timeout}")
+    return AsyncConnection(
+        address,
+        database=database,
+        timeout=timeout,
+        max_total_rows=max_total_rows,
+        max_continuation_frames=max_continuation_frames,
+        trust_server_heartbeat=trust_server_heartbeat,
+    )
 
 
 async def aconnect(
     address: str,
     *,
     database: str = "default",
     timeout: float = 10.0,
+    max_total_rows: int | None = 10_000_000,
+    max_continuation_frames: int | None = 100_000,
+    trust_server_heartbeat: bool = False,
 ) -> AsyncConnection:
     """Connect to a dqlite database asynchronously.
 
@@ -122,11 +148,24 @@ async def aconnect(
     Args:
         address: Node address in "host:port" format
         database: Database name to open
-        timeout: Connection timeout in seconds
+        timeout: Connection timeout in seconds — must be positive and finite.
+        max_total_rows: Cumulative row cap across continuation frames.
+        max_continuation_frames: Per-query continuation-frame cap.
+        trust_server_heartbeat: Let the server-advertised heartbeat
+            widen the per-read deadline.
 
     Returns:
         A connected AsyncConnection object
     """
-    conn = AsyncConnection(address, database=database, timeout=timeout)
+    if not math.isfinite(timeout) or timeout <= 0:
+        raise ProgrammingError(f"timeout must be a positive finite number, got {timeout}")
+    conn = AsyncConnection(
+        address,
+        database=database,
+        timeout=timeout,
+        max_total_rows=max_total_rows,
+        max_continuation_frames=max_continuation_frames,
+        trust_server_heartbeat=trust_server_heartbeat,
+    )
     await conn.connect()
     return conn

tests/test_aio_module_attributes.py

@@ -1,6 +1,9 @@
 """Tests for async module PEP 249 attributes and exports."""
 
+import pytest
+
 from dqlitedbapi import aio
+from dqlitedbapi.exceptions import ProgrammingError
 
 
 class TestAioModuleAttributes:
@@ -30,3 +33,48 @@ def test_type_objects_exported(self) -> None:
         assert aio.NUMBER == "INTEGER"
         assert aio.DATETIME == "DATE"
         assert aio.ROWID == "ROWID"
+
+
+class TestAioConnectForwardsGovernors:
+    def test_aio_connect_forwards_all_governors(self) -> None:
+        conn = aio.connect(
+            "localhost:19001",
+            max_total_rows=500,
+            max_continuation_frames=7,
+            trust_server_heartbeat=True,
+        )
+        assert conn._max_total_rows == 500
+        assert conn._max_continuation_frames == 7
+        assert conn._trust_server_heartbeat is True
+
+    def test_aio_connect_uses_default_governors(self) -> None:
+        conn = aio.connect("localhost:19001")
+        assert conn._max_total_rows == 10_000_000
+        assert conn._max_continuation_frames == 100_000
+        assert conn._trust_server_heartbeat is False
+
+    def test_aio_connect_accepts_none_caps(self) -> None:
+        conn = aio.connect(
+            "localhost:19001",
+            max_total_rows=None,
+            max_continuation_frames=None,
+        )
+        assert conn._max_total_rows is None
+        assert conn._max_continuation_frames is None
+
+
+class TestAioConnectTimeoutValidation:
+    @pytest.mark.parametrize("bad", [0, -1, float("nan"), float("inf"), float("-inf")])
+    def test_connect_rejects_non_positive_or_non_finite(self, bad: float) -> None:
+        with pytest.raises(ProgrammingError, match="timeout must be a positive finite number"):
+            aio.connect("localhost:19001", timeout=bad)
+
+    @pytest.mark.parametrize("bad", [0, -1, float("nan"), float("inf"), float("-inf")])
+    def test_aconnect_rejects_non_positive_or_non_finite(self, bad: float) -> None:
+        import asyncio
+
+        async def run() -> None:
+            with pytest.raises(ProgrammingError, match="timeout must be a positive finite number"):
+                await aio.aconnect("localhost:19001", timeout=bad)
+
+        asyncio.run(run())