Reject bool for ConnectionPool / ClusterClient size knobs

``min_size``, ``max_size``, and ``max_attempts`` were
validated only with ``< 0`` / ``< 1`` comparisons.
``True == 1`` and ``False == 0`` so ``ConnectionPool
(min_size=True)`` succeeded and silently masked caller
bugs that accidentally pass a flag through.

Mirrors the int/bool reject discipline applied across
the wire validators (``encode_int64``,
``Cursor.arraysize``, ``Header.__post_init__``).

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

Author: antoineleclair

src/dqliteclient/cluster.py

@@ -546,6 +546,13 @@ async def connect(
                 SIGTERM-shutdown budgets. See
                 ``DqliteConnection.__init__`` for full rationale.
         """
+        # Reject ``bool`` before the < 1 check so ``True``/``False``
+        # don't silently coerce to 1/0. Mirrors the discipline in
+        # ``ConnectionPool.__init__``.
+        if max_attempts is not None and (
+            isinstance(max_attempts, bool) or not isinstance(max_attempts, int)
+        ):
+            raise TypeError(f"max_attempts must be int or None, got {type(max_attempts).__name__}")
         attempts_cap = max_attempts if max_attempts is not None else _DEFAULT_CONNECT_MAX_ATTEMPTS
         if attempts_cap < 1:
             # Wording mirrors ``ConnectionPool.__init__``'s validator

src/dqliteclient/pool.py

@@ -226,6 +226,19 @@ def __init__(
                 a long retry loop just delays the diagnosis. Must be
                 ``>= 1`` if not ``None``.
         """
+        # Reject ``bool`` first: ``True == 1`` and ``False == 0``
+        # would silently coerce to valid sizes and mask caller bugs
+        # that accidentally pass a flag through. Mirrors the
+        # int/bool reject discipline applied to ``encode_int64``,
+        # ``Cursor.arraysize``, and the wire validators.
+        if isinstance(min_size, bool) or not isinstance(min_size, int):
+            raise TypeError(f"min_size must be int, got {type(min_size).__name__}")
+        if isinstance(max_size, bool) or not isinstance(max_size, int):
+            raise TypeError(f"max_size must be int, got {type(max_size).__name__}")
+        if max_attempts is not None and (
+            isinstance(max_attempts, bool) or not isinstance(max_attempts, int)
+        ):
+            raise TypeError(f"max_attempts must be int or None, got {type(max_attempts).__name__}")
         if min_size < 0:
             raise ValueError(f"min_size must be non-negative, got {min_size}")
         if max_size < 1:

tests/test_pool_size_int_only.py

@@ -0,0 +1,43 @@
+"""Pin: ``ConnectionPool``'s ``min_size`` / ``max_size`` /
+``max_attempts`` and ``ClusterClient.connect``'s ``max_attempts``
+reject ``bool`` (``True`` / ``False``) — the only checks were
+``< 0`` / ``< 1`` comparisons that silently coerced ``True`` to
+``1`` and ``False`` to ``0``.
+
+Mirrors the int/bool reject discipline applied across the wire
+validators (``encode_int64``, ``Cursor.arraysize``,
+``Header.__post_init__``).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dqliteclient.cluster import ClusterClient
+from dqliteclient.node_store import MemoryNodeStore
+from dqliteclient.pool import ConnectionPool
+
+
+def test_pool_min_size_rejects_bool() -> None:
+    with pytest.raises(TypeError, match="min_size must be int"):
+        ConnectionPool(addresses=["localhost:9001"], min_size=True)
+
+
+def test_pool_max_size_rejects_bool() -> None:
+    with pytest.raises(TypeError, match="max_size must be int"):
+        ConnectionPool(addresses=["localhost:9001"], max_size=True)
+
+
+def test_pool_max_attempts_rejects_bool() -> None:
+    with pytest.raises(TypeError, match="max_attempts must be int"):
+        ConnectionPool(
+            addresses=["localhost:9001"],
+            max_attempts=True,
+        )
+
+
+@pytest.mark.asyncio
+async def test_cluster_connect_max_attempts_rejects_bool() -> None:
+    cluster = ClusterClient(MemoryNodeStore())
+    with pytest.raises(TypeError, match="max_attempts must be int"):
+        await cluster.connect(database="x", max_attempts=True)