Fill wire test-coverage gaps (golden bytes, frame caps, row lengths)

- Add golden-byte tests for ConnectRequest, DumpRequest,
  ClusterRequest, TransferRequest, DescribeRequest, WeightRequest,
  and a with_params variant of QueryRequest. Hand-derived expected
  bytes catch symmetric encoder/decoder drift that round-trip tests
  cannot. Mirrors the pattern established by the Heartbeat / Files
  / Interrupt goldens from prior cycles.

- Add tests for the "exceeds maximum possible in N bytes" frame-size
  cap on RowsResponse, FilesResponse, and ServersResponse. Each
  decoder already had the absolute cap tested; the secondary
  frame-size guard (count * SLOT_SIZE > remaining) was not fenced.

- Add tests for encode_row_values' row/types length-mismatch
  EncodeError — a defensive raise in public tuples helper that had
  no direct test.

Author: antoineleclair

tests/test_decoder_caps.py

@@ -0,0 +1,61 @@
+"""Fence the secondary "exceeds maximum possible in N bytes" caps.
+
+Each response decoder with a count field has a two-stage check:
+1. An absolute cap (``count > _MAX_FOO_COUNT``) — tested elsewhere.
+2. A frame-size cap (``count * SLOT_SIZE > remaining``) — rejects
+   a count that is small enough to pass stage 1 but would require
+   more bytes than the body holds (allocation-amplification attack).
+
+Stage 2's raises had no tests before ISSUE-327. A regression that
+removes the frame-size check or reorders it with the absolute cap
+would ship silently.
+
+Also fences ``encode_row_values``'s length-mismatch EncodeError
+(ISSUE-329) which had no direct test.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dqlitewire.constants import ValueType
+from dqlitewire.exceptions import DecodeError, EncodeError
+from dqlitewire.messages import FilesResponse, RowsResponse, ServersResponse
+from dqlitewire.tuples import encode_row_values
+from dqlitewire.types import encode_uint64
+
+
+class TestFrameSizeCaps:
+    def test_servers_response_count_exceeds_remaining_bytes(self) -> None:
+        """count=1000 passes the absolute cap (max 10_000) but can't
+        fit in a body of 8 bytes (just the count field itself).
+        """
+        body = encode_uint64(1000)
+        with pytest.raises(DecodeError, match="exceeds maximum possible"):
+            ServersResponse.decode_body(body)
+
+    def test_files_response_count_exceeds_remaining_bytes(self) -> None:
+        """count=50 passes the absolute cap (max 100) but can't fit in
+        a body of 8 bytes (each file requires ≥16 bytes).
+        """
+        body = encode_uint64(50)
+        with pytest.raises(DecodeError, match="exceeds maximum possible"):
+            FilesResponse.decode_body(body)
+
+    def test_rows_response_count_exceeds_remaining_bytes(self) -> None:
+        """column_count=500 passes the absolute cap but cannot fit in a
+        body smaller than column_count * 8 bytes.
+        """
+        body = encode_uint64(500)
+        with pytest.raises(DecodeError, match="exceeds maximum possible"):
+            RowsResponse.decode_body(body)
+
+
+class TestEncodeRowValuesLengthMismatch:
+    def test_more_values_than_types_rejected(self) -> None:
+        with pytest.raises(EncodeError, match="Row values count"):
+            encode_row_values([1, 2], [ValueType.INTEGER])
+
+    def test_fewer_values_than_types_rejected(self) -> None:
+        with pytest.raises(EncodeError, match="Row values count"):
+            encode_row_values([1], [ValueType.INTEGER, ValueType.INTEGER])

tests/test_golden_bytes.py

@@ -512,6 +512,114 @@ def test_remove_request(self) -> None:
         assert isinstance(msg, RemoveRequest)
         assert msg.node_id == 3
 
+    def test_connect_request(self) -> None:
+        """ConnectRequest(node_id=2, address="127.0.0.1:9001"): type=11.
+
+        Body: uint64(2) + text("127.0.0.1:9001")
+        text = 14 chars + null = 15 bytes, padded to 16
+        Total body = 8 + 16 = 24 = 3 words
+        """
+        from dqlitewire.messages import ConnectRequest
+
+        expected = _header(3, 11) + _u64(2) + _text("127.0.0.1:9001")
+        assert encode_message(ConnectRequest(node_id=2, address="127.0.0.1:9001")) == expected
+
+        msg = decode_message(expected, is_request=True)
+        assert isinstance(msg, ConnectRequest)
+        assert msg.node_id == 2
+        assert msg.address == "127.0.0.1:9001"
+
+    def test_dump_request(self) -> None:
+        """DumpRequest(name="test.db"): type=15.
+
+        Body: text("test.db") = 7 chars + null = 8 bytes (exact word).
+        Total body = 8 = 1 word
+        """
+        from dqlitewire.messages import DumpRequest
+
+        expected = _header(1, 15) + _text("test.db")
+        assert encode_message(DumpRequest(name="test.db")) == expected
+
+        msg = decode_message(expected, is_request=True)
+        assert isinstance(msg, DumpRequest)
+        assert msg.name == "test.db"
+
+    def test_cluster_request(self) -> None:
+        """ClusterRequest(format=1): type=16.
+
+        Body: uint64(1) = 8 bytes = 1 word.
+        """
+        from dqlitewire.messages import ClusterRequest
+
+        expected = _header(1, 16) + _u64(1)
+        assert encode_message(ClusterRequest(format=1)) == expected
+
+        msg = decode_message(expected, is_request=True)
+        assert isinstance(msg, ClusterRequest)
+        assert msg.format == 1
+
+    def test_transfer_request(self) -> None:
+        """TransferRequest(target_node_id=7): type=17.
+
+        Body: uint64(7) = 8 bytes = 1 word.
+        """
+        from dqlitewire.messages import TransferRequest
+
+        expected = _header(1, 17) + _u64(7)
+        assert encode_message(TransferRequest(target_node_id=7)) == expected
+
+        msg = decode_message(expected, is_request=True)
+        assert isinstance(msg, TransferRequest)
+        assert msg.target_node_id == 7
+
+    def test_describe_request(self) -> None:
+        """DescribeRequest(format=0): type=18.
+
+        Body: uint64(0) = 8 bytes = 1 word. Upstream defines only V0=0.
+        """
+        from dqlitewire.messages import DescribeRequest
+
+        expected = _header(1, 18) + _u64(0)
+        assert encode_message(DescribeRequest(format=0)) == expected
+
+        msg = decode_message(expected, is_request=True)
+        assert isinstance(msg, DescribeRequest)
+        assert msg.format == 0
+
+    def test_weight_request(self) -> None:
+        """WeightRequest(weight=5): type=19.
+
+        Body: uint64(5) = 8 bytes = 1 word.
+        """
+        from dqlitewire.messages import WeightRequest
+
+        expected = _header(1, 19) + _u64(5)
+        assert encode_message(WeightRequest(weight=5)) == expected
+
+        msg = decode_message(expected, is_request=True)
+        assert isinstance(msg, WeightRequest)
+        assert msg.weight == 5
+
+    def test_query_request_with_params(self) -> None:
+        """QueryRequest(db_id=1, stmt_id=2, params=[42, "hello"]): type=6, schema=0.
+
+        Mirror of test_exec_request_with_params but for QUERY. Pins the
+        shared tuples-layout encoding under a different MSG_TYPE so a
+        regression specific to the query path does not slip past.
+        """
+        params_header = bytes([0x02, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00])
+        expected = (
+            _header(4, 6, schema=0) + _u32(1) + _u32(2) + params_header + _i64(42) + _text("hello")
+        )
+        msg = QueryRequest(db_id=1, stmt_id=2, params=[42, "hello"])
+        assert encode_message(msg) == expected
+
+        decoded = decode_message(expected, is_request=True)
+        assert isinstance(decoded, QueryRequest)
+        assert decoded.db_id == 1
+        assert decoded.stmt_id == 2
+        assert decoded.params == [42, "hello"]
+
 
 class TestGoldenResponsesPriority1:
     """Golden byte tests for high-priority response messages."""