Strip internal issue-tracker references from tests and comments

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

Author: antoineleclair

src/dqliteclient/cluster.py

@@ -25,7 +25,7 @@
 # Default attempt count for connect(). Three attempts cover one leader
 # change plus one transport hiccup; substantially higher counts risk
 # hiding genuine cluster instability under what looks like "a slow
-# connect" (ISSUE-109). Operators can override via ClusterClient.connect(
+# connect". Operators can override via ClusterClient.connect(
 # max_attempts=...).
 _DEFAULT_CONNECT_MAX_ATTEMPTS = 3
 
@@ -180,12 +180,12 @@ async def connect(
         governors from one place.
 
         ``max_attempts`` overrides the default
-        :data:`_DEFAULT_CONNECT_MAX_ATTEMPTS` (ISSUE-109).
+        :data:`_DEFAULT_CONNECT_MAX_ATTEMPTS`.
 
         Each attempt's failure is logged at DEBUG level with the
         attempted leader address and the error, so operators can
         enable debug logging to diagnose cluster churn instead of
-        seeing only the final exception (ISSUE-78).
+        seeing only the final exception.
         """
         attempts_cap = max_attempts if max_attempts is not None else _DEFAULT_CONNECT_MAX_ATTEMPTS
         if attempts_cap < 1:

src/dqliteclient/connection.py

@@ -96,13 +96,12 @@ def __init__(
             max_continuation_frames: Maximum number of continuation
                 frames in a single query result. Caps the per-query
                 Python-side decode work a hostile server can inflict
-                by sending many 1-row frames (ISSUE-98). Set to
+                by sending many 1-row frames. Set to
                 ``None`` to disable.
             trust_server_heartbeat: When True, widen the per-read
                 deadline to the server-advertised heartbeat (subject
                 to a 300 s hard cap). When False (default), ``timeout``
-                is authoritative — the server value cannot amplify it
-                (ISSUE-101).
+                is authoritative — the server value cannot amplify it.
         """
         if not math.isfinite(timeout) or timeout <= 0:
             raise ValueError(f"timeout must be a positive finite number, got {timeout}")
@@ -213,11 +212,11 @@ async def _abort_protocol(self) -> None:
 
         Close the writer, then give ``wait_closed`` a bounded budget so
         the transport drains under normal conditions but never hangs on
-        an unresponsive peer (ISSUE-72). Cycle-2 ISSUE-38 rejected an
-        unbounded ``wait_closed`` in the leader-query finally block
-        because leader-query is a discovery path that runs against
-        arbitrary nodes; connect is a retry-loop path that benefits
-        from draining, so the two sites take different decisions.
+        an unresponsive peer. The leader-query finally block rejects an
+        unbounded ``wait_closed`` because leader-query is a discovery
+        path that runs against arbitrary nodes; connect is a retry-loop
+        path that benefits from draining, so the two sites take
+        different decisions.
         """
         protocol = self._protocol
         if protocol is None:
@@ -402,7 +401,7 @@ async def fetchval(self, sql: str, params: Sequence[Any] | None = None) -> Any:
     async def transaction(self) -> AsyncIterator[None]:
         """Context manager for transactions.
 
-        Cancellation contract (ISSUE-75 / ISSUE-79):
+        Cancellation contract:
         - Cancellation during BEGIN: state cleared, CancelledError
           propagates.
         - Cancellation during the body: ROLLBACK is attempted. If
@@ -415,7 +414,7 @@ async def transaction(self) -> AsyncIterator[None]:
           invalidated, CancelledError propagates and supersedes the
           body exception (Python chains it via ``__context__``).
 
-        Non-cancellation ROLLBACK failure (ISSUE-73): connection is
+        Non-cancellation ROLLBACK failure: connection is
         invalidated so the pool discards it instead of reusing a
         Python-side "_in_transaction=False" connection with live
         server-side transaction state.
@@ -451,13 +450,13 @@ async def transaction(self) -> AsyncIterator[None]:
                 # CancelledError / KeyboardInterrupt / SystemExit must
                 # propagate. Previously ``suppress(BaseException)``
                 # swallowed cancellation, breaking structured-concurrency
-                # contracts (ISSUE-75).
+                # contracts.
                 #
                 # If ROLLBACK fails for any reason (including the narrow
                 # cancellation catch below), the connection's transaction
                 # state is unknowable from our side and the connection
                 # must be invalidated so the pool discards it on return
-                # (ISSUE-73). The original body exception is still the
+                # from our side. The original body exception is still the
                 # one that propagates, except for cancellation which
                 # takes precedence.
                 try:

src/dqliteclient/pool.py

@@ -101,16 +101,16 @@ def __init__(
                 connection inherits the same governor. ``None`` disables
                 the cap entirely (not recommended in production —
                 bounds memory against slow-drip attacks).
-            max_continuation_frames: Per-query continuation-frame cap
-                (ISSUE-98). Complements ``max_total_rows``: a server
+            max_continuation_frames: Per-query continuation-frame cap.
+                Complements ``max_total_rows``: a server
                 sending 1-row-per-frame can inflict O(n) Python decode
                 work where n is the row cap; the frame cap bounds that.
                 Forwarded to every :class:`DqliteConnection`.
             trust_server_heartbeat: When True, the per-read deadline on
                 every connection widens to the server-advertised
                 heartbeat (up to a 300 s hard cap). Default False —
                 operator-configured ``timeout`` is authoritative and
-                the server cannot amplify it (ISSUE-101).
+                the server cannot amplify it.
         """
         if min_size < 0:
             raise ValueError(f"min_size must be non-negative, got {min_size}")
@@ -155,7 +155,7 @@ async def initialize(self) -> None:
         Idempotent: concurrent callers share the same initialization —
         only one performs the TCP work, the others await its result.
 
-        Partial-failure behavior (ISSUE-77): ``asyncio.gather`` with the
+        Partial-failure behavior: ``asyncio.gather`` with the
         default ``return_exceptions=False`` cancels sibling tasks on
         first failure but does NOT close connections that already
         succeeded — they leak as orphaned transports. Use
@@ -315,7 +315,7 @@ async def acquire(self) -> AsyncIterator[DqliteConnection]:
             # state change (close, size decrement, drain) wakes waiters
             # promptly. The check-_closed-then-clear pair runs under
             # the lock so a concurrent close() can't set() the event
-            # between our read and our clear (ISSUE-74).
+            # between our read and our clear.
             async with self._lock:
                 closed_event = self._get_closed_event()
                 if self._closed:
@@ -362,7 +362,7 @@ async def acquire(self) -> AsyncIterator[DqliteConnection]:
             yield conn
         except BaseException:
             # Cleanup must complete even if a second cancellation lands
-            # mid-await (ISSUE-76). ``returned_to_queue`` tracks whether
+            # mid-await. ``returned_to_queue`` tracks whether
             # the reservation was transferred to an in-queue connection;
             # if not, the ``finally`` below releases it. ``asyncio.shield``
             # around ``_release_reservation`` makes the decrement itself
@@ -452,9 +452,8 @@ async def _release(self, conn: DqliteConnection) -> None:
 
         ``conn.close()`` has an early-return guard against
         ``_pool_released=True``, so close MUST run before the flag is
-        set — otherwise the transport leaks (ISSUE-76 review found
-        this bug across every branch that closes a pool-owned
-        connection).
+        set — otherwise the transport leaks (a bug that affects every
+        branch that closes a pool-owned connection).
         """
         if self._closed:
             await conn.close()

src/dqliteclient/protocol.py

@@ -35,8 +35,8 @@
 def _validate_positive_int_or_none(value: int | None, name: str) -> int | None:
     """Shared validation for positive-int-or-None parameters.
 
-    Used for both ``max_total_rows`` and ``max_continuation_frames``
-    (ISSUE-98). None disables the cap; any int value must be > 0.
+    Used for both ``max_total_rows`` and ``max_continuation_frames``.
+    None disables the cap; any int value must be > 0.
     """
     if value is None:
         return None
@@ -89,7 +89,7 @@ def __init__(
         # Per-query frame cap. Complements max_total_rows: a server
         # sending 10M 1-row frames to reach the row cap would still
         # burn 10M × decode-cost of Python work; the frame cap bounds
-        # that at ~100k iterations (ISSUE-98).
+        # that at ~100k iterations.
         self._max_continuation_frames = _validate_positive_int_or_none(
             max_continuation_frames, "max_continuation_frames"
         )
@@ -98,8 +98,7 @@ def __init__(
         # hard cap). When False (default), the server value is recorded
         # for diagnostics only and the operator-configured ``timeout``
         # is authoritative. Opt-in protects operators whose timeout is
-        # a latency-SLO boundary from server-induced amplification
-        # (ISSUE-101).
+        # a latency-SLO boundary from server-induced amplification.
         self._trust_server_heartbeat = trust_server_heartbeat
 
     async def handshake(self, client_id: int | None = None) -> int:
@@ -137,8 +136,8 @@ async def handshake(self, client_id: int | None = None) -> int:
         # Use the server-advertised heartbeat only when explicitly
         # trusted. Previously we always widened ``self._timeout`` up
         # to 300 s based on the server value, which let a hostile
-        # server amplify the operator's configured timeout up to 30×
-        # (ISSUE-101). Default is now opt-out: the server value is
+        # server amplify the operator's configured timeout up to 30×.
+        # Default is now opt-out: the server value is
         # recorded for diagnostics but does not change the per-read
         # deadline.
         if self._trust_server_heartbeat and response.heartbeat_timeout > 0:
@@ -283,7 +282,7 @@ async def _drain_continuations(
                     "ROWS continuation made no progress: frame had 0 rows and has_more=True"
                 )
             if self._max_continuation_frames is not None and frames > self._max_continuation_frames:
-                # Per-frame cap complements max_total_rows (ISSUE-98): a
+                # Per-frame cap complements max_total_rows: a
                 # slow-drip server sending 1-row-per-frame would
                 # otherwise pin a client CPU with O(n) iterations of
                 # decode work, where n is max_total_rows.

tests/integration/test_continuation_frames.py

@@ -1,4 +1,4 @@
-"""Integration test for multi-frame rows continuation (ISSUE-66).
+"""Integration test for multi-frame rows continuation.
 
 The dqlite server batches query results into frames that fit in its
 per-response buffer. For result sets larger than one frame's worth of

tests/test_cluster.py

@@ -371,7 +371,7 @@ async def test_update_nodes(self) -> None:
 
 
 class TestConnectMaxAttempts:
-    """ISSUE-109: connect() exposes a max_attempts parameter.
+    """connect() exposes a max_attempts parameter.
 
     The previous hardcoded ``max_attempts=3`` forced operators to patch
     the library to tune retry behavior. The default is unchanged; the
@@ -407,7 +407,7 @@ async def test_max_attempts_zero_rejected(self) -> None:
 
 
 class TestConnectObservability:
-    """ISSUE-78: per-attempt failures are logged at DEBUG for diagnosis."""
+    """Per-attempt failures are logged at DEBUG for diagnosis."""
 
     async def test_failed_attempts_logged(self, caplog: pytest.LogCaptureFixture) -> None:
         import logging

tests/test_max_total_rows_cap.py

@@ -1,8 +1,8 @@
 """max_total_rows cap actually fires in the continuation-drain loop.
 
-Cycle 9 wired the cap through the layers; cycle 16 adds the missing
-test that exercises the enforcement itself. Uses a mocked protocol
-response stream so we don't need a cluster to deliver millions of rows.
+The cap is wired through every layer; this test exercises the
+enforcement itself. Uses a mocked protocol response stream so we
+don't need a cluster to deliver millions of rows.
 """
 
 import asyncio
@@ -72,7 +72,7 @@ def test_none_disables_cap(self) -> None:
 
 
 class TestMaxContinuationFramesEnforcement:
-    """ISSUE-98: per-frame cap complements max_total_rows.
+    """Per-frame cap complements max_total_rows.
 
     A slow-drip server sending many 1-row frames could pin a client CPU
     with ~max_total_rows iterations of Python-level decode work. The
@@ -139,7 +139,7 @@ def test_none_disables_frame_cap(self) -> None:
 
 
 class TestTrustServerHeartbeat:
-    """ISSUE-101: server heartbeat no longer widens client timeout by default."""
+    """Server heartbeat no longer widens client timeout by default."""
 
     def test_default_does_not_amplify_timeout(self) -> None:
         reader = MagicMock()
@@ -163,7 +163,7 @@ def test_opt_in_amplifies_timeout_via_handshake(self) -> None:
         """With trust_server_heartbeat=True, a handshake reply with a
         larger-than-local heartbeat widens the per-read deadline (up to
         the 300 s hard cap). Exercises the actual handshake code path
-        rather than just checking the flag is set (ISSUE-101 review)."""
+        rather than just checking the flag is set."""
         from dqlitewire.messages import WelcomeResponse
 
         reader = AsyncMock()

tests/test_pool.py

@@ -302,7 +302,7 @@ async def waiter():
     async def test_dead_conn_replacement_respects_max_size(self) -> None:
         """Dead-connection replacement must not allow _size to exceed max_size.
 
-        ISSUE-34/58 changed the pool to a reservation pattern: the
+        An earlier change introduced the reservation pattern: the
         lock is released before the TCP handshake. The invariant we
         assert here is the one that actually matters — that
         ``_size`` never exceeds ``_max_size`` at any observation

tests/test_pool_cancellation.py

@@ -3,21 +3,21 @@
 Pins the ``ConnectionPool`` lifecycle guarantees against cancellation
 and partial failures:
 
-- Cancelling a parked ``acquire()`` caller must not leak ``_size``
-  (ISSUE-71 + ISSUE-76). ``_size`` must reflect reality at all times.
+- Cancelling a parked ``acquire()`` caller must not leak ``_size``.
+  ``_size`` must reflect reality at all times.
 - ``pool.close()`` must wake every parked acquirer via the close
-  signal, not via the per-poll timeout (ISSUE-74). Waking via timeout
-  would produce "Timed out waiting for a connection" instead of
+  signal, not via the per-poll timeout. Waking via timeout would
+  produce "Timed out waiting for a connection" instead of
   "Pool is closed" — the message is the observable signal.
 - ``_reset_connection`` failure during cleanup must release the
-  reservation and effectively close the connection (ISSUE-76).
-  ``_FakeConn`` replicates the real ``DqliteConnection.close``
-  early-return guard on ``_pool_released``, so any regression that
-  flips the flag before calling close() surfaces as a failed
-  ``close_effective`` assertion.
+  reservation and effectively close the connection. ``_FakeConn``
+  replicates the real ``DqliteConnection.close`` early-return guard
+  on ``_pool_released``, so any regression that flips the flag
+  before calling close() surfaces as a failed ``close_effective``
+  assertion.
 - ``initialize()`` partial failure: sibling connections that already
   succeeded must be effectively closed before ``gather()`` propagates
-  the first failure (ISSUE-77). The previous default
+  the first failure. The previous default
   ``return_exceptions=False`` cancelled siblings but did NOT close
   them, leaking transports.
 
@@ -120,10 +120,10 @@ async def _default_connect(**kwargs: Any) -> _FakeConn:
 
 
 class TestInitializePartialFailureClosesSurvivors:
-    """ISSUE-77: if a single _create_connection fails in initialize's
-    gather, the connections that already succeeded must be closed.
-    Currently they leak (asyncio.gather cancels siblings but does not
-    await their .close()).
+    """If a single _create_connection fails in initialize's gather,
+    the connections that already succeeded must be closed. Previously
+    they leaked (asyncio.gather cancels siblings but does not await
+    their .close()).
     """
 
     async def test_survivors_closed_on_partial_init_failure(self) -> None:
@@ -170,10 +170,10 @@ async def _flaky_connect(**kwargs: Any) -> _FakeConn:
 
 
 class TestAcquireCancellationRestoresSize:
-    """ISSUE-71 + ISSUE-76: a caller cancelled while parked in acquire()
-    must not leak the pool reservation. If a connection was pulled off
-    the queue and handed to the cancelled task's get_task, it must either
-    be returned to the pool or closed with _size decremented. Likewise
+    """A caller cancelled while parked in acquire() must not leak the
+    pool reservation. If a connection was pulled off the queue and
+    handed to the cancelled task's get_task, it must either be
+    returned to the pool or closed with _size decremented. Likewise
     for body-raised cancellation during yield cleanup.
     """
 
@@ -215,9 +215,9 @@ async def waiter() -> None:
         await pool.close()
 
     async def test_reset_connection_failure_releases_reservation(self) -> None:
-        """ISSUE-76: when the pool's cleanup path runs _reset_connection
-        and it fails (e.g. ROLLBACK raises), the reservation must be
-        released and the connection closed — never leaked.
+        """When the pool's cleanup path runs _reset_connection and it
+        fails (e.g. ROLLBACK raises), the reservation must be released
+        and the connection closed — never leaked.
         """
 
         class _RollbackFailingConn(_FakeConn):
@@ -271,8 +271,8 @@ class _BodyError(Exception):
 
 
 class TestCloseWakesAllWaiters:
-    """ISSUE-74: when pool.close() runs, every parked acquire() must
-    return DqliteConnectionError promptly. The current clear()-then-wait
+    """When pool.close() runs, every parked acquire() must return
+    DqliteConnectionError promptly. The current clear()-then-wait
     pattern has a tiny window where close()'s set() can be erased,
     leaving waiters stalled until timeout.
     """

tests/test_pool_size_invariants.py

@@ -1,4 +1,4 @@
-"""ISSUE-34 / ISSUE-58: concurrent-access invariants of ConnectionPool.
+"""Concurrent-access invariants of ConnectionPool.
 
 Verifies that _size never exceeds max_size under concurrent acquires,
 even when _create_connection is slow (simulating TCP handshake