Drop implementation-pinning tests and collapse redundant matrices

Remove tests that asserted on source shape (inspect.getsource / ast /
__doc__) rather than behavior — each either pinned an implementation
detail with no observable contract or duplicated an existing behavioral
test. Collapse enum-constant and flag matrices that expanded one
property into many near-identical cases into single parametrized loops.
Structure pins guarding genuine invariants with no behavioral equivalent
(cancel-path ordering, KeyboardInterrupt/SystemExit propagation,
cross-package provenance) are kept. No behavioral coverage is removed.

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

Author: antoineleclair

tests/test_clusterrequest_decode_no_new_bypass.py

@@ -1,24 +1,12 @@
-"""``ClusterRequest.decode_body`` must construct via the dataclass __init__
-(``_decoded=True`` kwarg), not ``cls.__new__`` — the bypass is fragile under
-frozen/slots/new-field changes and breaks the sibling sentinel-pattern parity.
+"""``ClusterRequest.decode_body`` constructs via the dataclass __init__
+(``_decoded=True`` kwarg); a V0 request round-trips through that path.
 """
 
 from __future__ import annotations
 
-import inspect
-
 from dqlitewire.messages.requests import ClusterRequest
 
 
-def test_cluster_request_decode_does_not_use_cls_new_bypass() -> None:
-    source = inspect.getsource(ClusterRequest)
-    assert "cls.__new__" not in source, (
-        "ClusterRequest.decode_body must construct via cls(format=..., _decoded=True) — "
-        "the cls.__new__ bypass is fragile under frozen=True / slots=True / new-field "
-        "additions and inconsistent with the sibling _decoded_schema pattern."
-    )
-
-
 def test_cluster_request_decode_v0_constructor_kwarg_path() -> None:
     """A V0 request constructs directly via ``_decoded=True`` — the decoder's path."""
     req = ClusterRequest(format=0, _decoded=True)

tests/test_codec_legacy_leader_direction_guard.py

@@ -6,13 +6,10 @@
 
 from __future__ import annotations
 
-import inspect
-
 import pytest
 
 from dqlitewire import PROTOCOL_VERSION_LEGACY
 from dqlitewire.codec import (
-    MessageDecoder,
     decode_message,
 )
 from dqlitewire.constants import RequestType, ResponseType
@@ -21,15 +18,6 @@
 from dqlitewire.messages.responses import LeaderResponse
 
 
-def test_legacy_leader_dispatch_gates_on_direction_not_identity() -> None:
-    src = inspect.getsource(MessageDecoder.decode_bytes)
-    assert "not self._is_request" in src, (
-        "Legacy LeaderResponse dispatch must gate on the direction "
-        "guard ``not self._is_request``, not solely on the identity "
-        "coincidence ``msg_class is LeaderResponse``."
-    )
-
-
 def _build_legacy_leader_response_bytes(address: str) -> bytes:
     """Legacy LEADER response bytes: header + padded NUL-terminated address, with no
     node_id prefix (that field was added in V1)."""

tests/test_codec_uses_header_body_size_property.py

@@ -11,40 +11,24 @@ class TestResponseTypeValues:
     Reference: github.com/canonical/go-dqlite internal/protocol/constants.go
     """
 
-    def test_failure_is_0(self) -> None:
-        assert ResponseType.FAILURE == 0
-
-    def test_node_is_1(self) -> None:
-        assert ResponseType.LEADER == 1
-
-    def test_welcome_is_2(self) -> None:
-        assert ResponseType.WELCOME == 2
-
-    def test_nodes_is_3(self) -> None:
-        """Go: ResponseNodes = 3 (cluster server listing)."""
-        assert ResponseType.SERVERS == 3
-
-    def test_db_is_4(self) -> None:
-        assert ResponseType.DB == 4
-
-    def test_stmt_is_5(self) -> None:
-        assert ResponseType.STMT == 5
-
-    def test_result_is_6(self) -> None:
-        assert ResponseType.RESULT == 6
-
-    def test_rows_is_7(self) -> None:
-        assert ResponseType.ROWS == 7
-
-    def test_empty_is_8(self) -> None:
-        assert ResponseType.EMPTY == 8
-
-    def test_files_is_9(self) -> None:
-        assert ResponseType.FILES == 9
-
-    def test_metadata_is_10(self) -> None:
-        """Go: ResponseMetadata = 10."""
-        assert ResponseType.METADATA == 10
+    @pytest.mark.parametrize(
+        ("name", "value"),
+        [
+            ("FAILURE", 0),
+            ("LEADER", 1),
+            ("WELCOME", 2),
+            ("SERVERS", 3),  # Go: ResponseNodes = 3 (cluster server listing)
+            ("DB", 4),
+            ("STMT", 5),
+            ("RESULT", 6),
+            ("ROWS", 7),
+            ("EMPTY", 8),
+            ("FILES", 9),
+            ("METADATA", 10),  # Go: ResponseMetadata = 10
+        ],
+    )
+    def test_response_type_value(self, name: str, value: int) -> None:
+        assert getattr(ResponseType, name) == value
 
     def test_no_node_legacy_as_separate_type(self) -> None:
         """NODE_LEGACY should not exist as a separate type code.
@@ -57,64 +41,34 @@ def test_no_node_legacy_as_separate_type(self) -> None:
 class TestRequestTypeValues:
     """Verify RequestType enum matches go-dqlite constants.go."""
 
-    def test_leader_is_0(self) -> None:
-        assert RequestType.LEADER == 0
-
-    def test_client_is_1(self) -> None:
-        assert RequestType.CLIENT == 1
-
-    def test_open_is_3(self) -> None:
-        assert RequestType.OPEN == 3
-
-    def test_prepare_is_4(self) -> None:
-        assert RequestType.PREPARE == 4
-
-    def test_exec_is_5(self) -> None:
-        assert RequestType.EXEC == 5
-
-    def test_query_is_6(self) -> None:
-        assert RequestType.QUERY == 6
-
-    def test_finalize_is_7(self) -> None:
-        assert RequestType.FINALIZE == 7
-
-    def test_exec_sql_is_8(self) -> None:
-        assert RequestType.EXEC_SQL == 8
-
-    def test_query_sql_is_9(self) -> None:
-        assert RequestType.QUERY_SQL == 9
-
-    def test_interrupt_is_10(self) -> None:
-        assert RequestType.INTERRUPT == 10
-
-    def test_add_is_12(self) -> None:
-        assert RequestType.ADD == 12
-
-    def test_assign_is_13(self) -> None:
-        assert RequestType.ASSIGN == 13
-
-    def test_remove_is_14(self) -> None:
-        assert RequestType.REMOVE == 14
-
-    def test_dump_is_15(self) -> None:
-        assert RequestType.DUMP == 15
-
-    def test_cluster_is_16(self) -> None:
-        assert RequestType.CLUSTER == 16
-
-    def test_transfer_is_17(self) -> None:
-        assert RequestType.TRANSFER == 17
-
-    def test_describe_is_18(self) -> None:
-        assert RequestType.DESCRIBE == 18
-
-    def test_weight_is_19(self) -> None:
-        assert RequestType.WEIGHT == 19
-
-    def test_connect_is_11(self) -> None:
-        """C defines DQLITE_REQUEST_CONNECT = 11 for Raft transport; the Go client omits
-        it (client-only), but a complete implementation includes it."""
-        assert RequestType.CONNECT == 11
+    @pytest.mark.parametrize(
+        ("name", "value"),
+        [
+            ("LEADER", 0),
+            ("CLIENT", 1),
+            ("OPEN", 3),
+            ("PREPARE", 4),
+            ("EXEC", 5),
+            ("QUERY", 6),
+            ("FINALIZE", 7),
+            ("EXEC_SQL", 8),
+            ("QUERY_SQL", 9),
+            ("INTERRUPT", 10),
+            # C defines DQLITE_REQUEST_CONNECT = 11 for Raft transport; the Go
+            # client omits it (client-only), but a complete implementation includes it.
+            ("CONNECT", 11),
+            ("ADD", 12),
+            ("ASSIGN", 13),
+            ("REMOVE", 14),
+            ("DUMP", 15),
+            ("CLUSTER", 16),
+            ("TRANSFER", 17),
+            ("DESCRIBE", 18),
+            ("WEIGHT", 19),
+        ],
+    )
+    def test_request_type_value(self, name: str, value: int) -> None:
+        assert getattr(RequestType, name) == value
 
 
 class TestPublicExports:

tests/test_constants.py

@@ -1,13 +1,9 @@
-"""``decode_message`` routes its handshake bypass through the named
-``MessageDecoder._force_handshake_for_stateless`` rather than writing
-``_handshake_done`` / ``_version`` directly, so a future property setter
-or observability hook isn't silently bypassed.
+"""``decode_message``'s stateless handshake bypass re-validates the version
+and leaves a normal request round-trip unchanged.
 """
 
 from __future__ import annotations
 
-import inspect
-
 import pytest
 
 from dqlitewire.codec import MessageDecoder, decode_message, encode_message
@@ -16,13 +12,6 @@
 from dqlitewire.messages.requests import LeaderRequest
 
 
-def test_decode_message_does_not_write_handshake_done_directly() -> None:
-    src = inspect.getsource(decode_message)
-    assert "decoder._handshake_done = True" not in src
-    assert "decoder._version = version" not in src
-    assert "_force_handshake_for_stateless" in src
-
-
 def test_force_handshake_for_stateless_rejects_unsupported_version() -> None:
     """The bypass helper re-validates the version even if the constructor's
     check is later dropped."""

tests/test_decode_message_bypass_via_named_helper.py

@@ -1,68 +1,10 @@
 """``decode_row_header`` and the zero-column fast-path in
-``RowsResponse.decode_body`` detect DONE / PART markers via direct
-``memoryview[:8] == _ROW_*_MARKER`` equality (buffer-protocol __eq__),
-without a per-row ``bytes(data[:8])`` copy.
+``RowsResponse.decode_body`` detect DONE / PART markers correctly from both
+memoryview- and bytes-backed input, and reject torn markers.
 """
 
 from __future__ import annotations
 
-import ast
-import inspect
-import textwrap
-
-from dqlitewire import tuples as tuples_mod
-from dqlitewire.messages import responses as responses_mod
-
-
-def _decode_row_header_source() -> str:
-    return textwrap.dedent(inspect.getsource(tuples_mod.decode_row_header))
-
-
-def _rows_response_decode_body_source() -> str:
-    return textwrap.dedent(inspect.getsource(responses_mod.RowsResponse.decode_body))
-
-
-def _has_bytes_call_on_view_prefix(src: str) -> bool:
-    """True if the source contains any ``bytes(<expr>[...])`` call."""
-    tree = ast.parse(src)
-    for node in ast.walk(tree):
-        if not isinstance(node, ast.Call):
-            continue
-        func = node.func
-        if isinstance(func, ast.Name) and func.id == "bytes" and node.args:
-            arg = node.args[0]
-            if isinstance(arg, ast.Subscript):
-                return True
-            if isinstance(arg, ast.Subscript) and isinstance(arg.slice, ast.Slice):
-                return True
-    return False
-
-
-def test_decode_row_header_marker_check_does_not_materialise_per_row_bytes() -> None:
-    """The marker-detection arm of ``decode_row_header`` must NOT contain
-    ``bytes(<slice>)``."""
-    src = _decode_row_header_source()
-    # Scan only the marker-check arm at the top; tolerate bytes(...) later.
-    head = "\n".join(src.splitlines()[:25])
-    assert not _has_bytes_call_on_view_prefix(head), (
-        "decode_row_header's marker arm allocates bytes(data[:8]) per "
-        "row; replace with direct ``data[:WORD_SIZE] == _ROW_*_MARKER`` "
-        "equality (memoryview supports buffer-protocol __eq__ against "
-        "bytes-like constants without copying)"
-    )
-
-
-def test_rows_response_decode_body_zero_column_marker_does_not_materialise_bytes() -> None:
-    """The zero-column fast-path in ``RowsResponse.decode_body`` must NOT
-    call ``bytes(view[...])`` to feed the marker comparison."""
-    src = _rows_response_decode_body_source()
-    assert "marker = bytes(" not in src, (
-        "RowsResponse.decode_body's zero-column marker check still uses "
-        "bytes(view[offset : offset + WORD_SIZE]); replace with direct "
-        "``view[offset : offset + WORD_SIZE] == _ROW_*_MARKER`` (memoryview "
-        "buffer-protocol equality avoids the per-frame copy)"
-    )
-
 
 def test_decode_row_header_marker_detection_works_with_memoryview_input() -> None:
     """DONE and PART markers are identified from memoryview-backed bytes."""

tests/test_decode_row_header_marker_no_per_row_bytes_alloc.py

@@ -1,52 +1,14 @@
-"""decode_value dispatches each ValueType via an O(1) lookup keyed by type code, not if/elif."""
+"""decode_value dispatches each ValueType to the correct decoder."""
 
 from __future__ import annotations
 
-import ast
-import inspect
-import textwrap
-
 import pytest
 
 from dqlitewire import types as types_mod
 from dqlitewire.constants import ValueType
 from dqlitewire.exceptions import DecodeError
 
 
-def _decode_value_source() -> str:
-    return textwrap.dedent(inspect.getsource(types_mod.decode_value))
-
-
-def test_decode_value_does_not_use_elif_chain_against_value_type() -> None:
-    src = _decode_value_source()
-    tree = ast.parse(src)
-
-    elif_compare_chain_arms = 0
-    for node in ast.walk(tree):
-        if not isinstance(node, ast.Compare):
-            continue
-        # Look for ``value_type == ValueType.X`` shape.
-        if (
-            isinstance(node.left, ast.Name)
-            and node.left.id == "value_type"
-            and len(node.ops) == 1
-            and isinstance(node.ops[0], ast.Eq)
-            and len(node.comparators) == 1
-            and isinstance(node.comparators[0], ast.Attribute)
-            and isinstance(node.comparators[0].value, ast.Name)
-            and node.comparators[0].value.id == "ValueType"
-        ):
-            elif_compare_chain_arms += 1
-
-    assert elif_compare_chain_arms <= 1, (
-        f"decode_value still contains {elif_compare_chain_arms} "
-        "``value_type == ValueType.X`` comparisons; the dispatch table "
-        "rewrite should collapse all of them into a single lookup. "
-        "Up to 1 comparison is tolerated for an explicit fallback arm "
-        "(e.g. fast-path for the most common type)."
-    )
-
-
 @pytest.mark.parametrize(
     "value_type, payload, expected_value, expected_consumed",
     [