Add RowsResponse tests for all value types and fix ISO8601 encode bug

The new tests exercise BOOLEAN, UNIXTIME, ISO8601, BLOB, and a mixed
all-types row in full RowsResponse encode/decode round-trips.

This uncovered a real bug: encode_value() with explicit
ValueType.ISO8601 and a datetime object raised EncodeError because
the datetime-to-string conversion only existed in the auto-inference
path. The fix extracts _format_datetime_iso8601() and calls it from
both the auto-inference and explicit-type paths.

Fixes #020

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

Author: antoineleclair

src/dqlitewire/types.py

@@ -147,6 +147,24 @@ def decode_blob(data: bytes) -> tuple[bytes, int]:
     return data[8 : 8 + length], total_size
 
 
+def _format_datetime_iso8601(value: datetime.datetime) -> str:
+    """Format a datetime to ISO 8601 string matching Go's time format."""
+    formatted = value.strftime("%Y-%m-%d %H:%M:%S")
+    if value.microsecond:
+        formatted += f".{value.microsecond:06d}".rstrip("0")
+    utcoffset = value.utcoffset()
+    if utcoffset is not None:
+        total_seconds = int(utcoffset.total_seconds())
+        sign = "+" if total_seconds >= 0 else "-"
+        hours, remainder = divmod(abs(total_seconds), 3600)
+        minutes = remainder // 60
+        formatted += f"{sign}{hours:02d}:{minutes:02d}"
+    else:
+        # Naive datetime: assume UTC to match Go's always-offset format
+        formatted += "+00:00"
+    return formatted
+
+
 def encode_value(value: Any, value_type: ValueType | None = None) -> tuple[bytes, ValueType]:
     """Encode a Python value to wire format.
 
@@ -165,21 +183,7 @@ def encode_value(value: Any, value_type: ValueType | None = None) -> tuple[bytes
             value_type = ValueType.FLOAT
         elif isinstance(value, datetime.datetime):
             value_type = ValueType.ISO8601
-            # Format to match Go's time format: "2006-01-02 15:04:05.999999999-07:00"
-            formatted = value.strftime("%Y-%m-%d %H:%M:%S")
-            if value.microsecond:
-                formatted += f".{value.microsecond:06d}".rstrip("0")
-            utcoffset = value.utcoffset()
-            if utcoffset is not None:
-                total_seconds = int(utcoffset.total_seconds())
-                sign = "+" if total_seconds >= 0 else "-"
-                hours, remainder = divmod(abs(total_seconds), 3600)
-                minutes = remainder // 60
-                formatted += f"{sign}{hours:02d}:{minutes:02d}"
-            else:
-                # Naive datetime: assume UTC to match Go's always-offset format
-                formatted += "+00:00"
-            value = formatted
+            value = _format_datetime_iso8601(value)
         elif isinstance(value, datetime.date):
             # Must come after datetime.datetime check (datetime is a subclass of date)
             value_type = ValueType.ISO8601
@@ -206,6 +210,13 @@ def encode_value(value: Any, value_type: ValueType | None = None) -> tuple[bytes
             raise EncodeError(f"Expected int or float for FLOAT, got {type(value).__name__}")
         return encode_double(float(value)), value_type
     elif value_type in (ValueType.TEXT, ValueType.ISO8601):
+        # ISO8601 accepts datetime objects and converts them to string.
+        # This is needed when encode_row_values passes a datetime with
+        # explicit ISO8601 type (the auto-inference path converts earlier).
+        if value_type == ValueType.ISO8601 and isinstance(value, datetime.datetime):
+            value = _format_datetime_iso8601(value)
+        elif value_type == ValueType.ISO8601 and isinstance(value, datetime.date):
+            value = value.isoformat()
         if not isinstance(value, str):
             raise EncodeError(f"Expected str for {value_type.name}, got {type(value).__name__}")
         return encode_text(value), value_type

tests/test_messages_responses.py

@@ -570,6 +570,124 @@ def test_decode_rows_continuation_rejects_excessive_column_count(self) -> None:
             )
 
 
+class TestRowsResponseValueTypes:
+    """Full RowsResponse round-trips with BOOLEAN, UNIXTIME, ISO8601, and BLOB."""
+
+    def test_boolean_column(self) -> None:
+        """BOOLEAN (code 11) uses all 4 nibble bits — catches truncation bugs."""
+        resp = RowsResponse(
+            column_names=["flag"],
+            column_types=[ValueType.BOOLEAN],
+            rows=[[True], [False]],
+        )
+        data = resp.encode()
+        decoded = RowsResponse.decode_body(data[HEADER_SIZE:])
+        assert decoded.rows == [[True], [False]]
+        assert decoded.column_types == [ValueType.BOOLEAN]
+
+    def test_unixtime_column(self) -> None:
+        """UNIXTIME (code 9) round-trips as raw int, not datetime."""
+        resp = RowsResponse(
+            column_names=["created_at"],
+            column_types=[ValueType.UNIXTIME],
+            row_types=[[ValueType.UNIXTIME], [ValueType.UNIXTIME]],
+            rows=[[1700000000], [0]],
+        )
+        data = resp.encode()
+        decoded = RowsResponse.decode_body(data[HEADER_SIZE:])
+        assert decoded.rows == [[1700000000], [0]]
+        assert decoded.column_types == [ValueType.UNIXTIME]
+
+    def test_iso8601_column(self) -> None:
+        """ISO8601 values go through _parse_iso8601 on decode."""
+        from datetime import UTC, datetime
+
+        dt = datetime(2024, 6, 15, 10, 30, 0, tzinfo=UTC)
+        resp = RowsResponse(
+            column_names=["ts"],
+            column_types=[ValueType.ISO8601],
+            rows=[[dt]],
+        )
+        data = resp.encode()
+        decoded = RowsResponse.decode_body(data[HEADER_SIZE:])
+        assert decoded.rows[0][0] == dt
+
+    def test_blob_column(self) -> None:
+        """BLOB has variable-length encoding with padding in row context."""
+        resp = RowsResponse(
+            column_names=["data"],
+            column_types=[ValueType.BLOB],
+            rows=[[b"\xde\xad\xbe\xef"], [b""]],
+        )
+        data = resp.encode()
+        decoded = RowsResponse.decode_body(data[HEADER_SIZE:])
+        assert decoded.rows == [[b"\xde\xad\xbe\xef"], [b""]]
+
+    def test_mixed_all_types(self) -> None:
+        """Every value type in a single row exercises full encoding path."""
+        from datetime import UTC, datetime
+
+        dt = datetime(2024, 1, 1, tzinfo=UTC)
+        resp = RowsResponse(
+            column_names=["i", "f", "t", "b", "n", "ut", "iso", "bo"],
+            column_types=[
+                ValueType.INTEGER,
+                ValueType.FLOAT,
+                ValueType.TEXT,
+                ValueType.BLOB,
+                ValueType.NULL,
+                ValueType.UNIXTIME,
+                ValueType.ISO8601,
+                ValueType.BOOLEAN,
+            ],
+            row_types=[
+                [
+                    ValueType.INTEGER,
+                    ValueType.FLOAT,
+                    ValueType.TEXT,
+                    ValueType.BLOB,
+                    ValueType.NULL,
+                    ValueType.UNIXTIME,
+                    ValueType.ISO8601,
+                    ValueType.BOOLEAN,
+                ]
+            ],
+            rows=[
+                [42, 3.14, "hello", b"\x00\x01", None, 1700000000, dt, True],
+            ],
+        )
+        data = resp.encode()
+        decoded = RowsResponse.decode_body(data[HEADER_SIZE:])
+        row = decoded.rows[0]
+        assert row[0] == 42
+        assert row[1] == 3.14
+        assert row[2] == "hello"
+        assert row[3] == b"\x00\x01"
+        assert row[4] is None
+        assert row[5] == 1700000000
+        assert row[6] == dt
+        assert row[7] is True
+
+    def test_blob_multiple_sizes(self) -> None:
+        """Multiple BLOB rows with different sizes verify padding/offset interplay."""
+        resp = RowsResponse(
+            column_names=["data"],
+            column_types=[ValueType.BLOB],
+            rows=[
+                [b""],  # empty
+                [b"x"],  # 1 byte, needs 7 pad
+                [b"12345678"],  # exactly 8 bytes, no pad
+                [b"123456789"],  # 9 bytes, needs 7 pad
+            ],
+        )
+        data = resp.encode()
+        decoded = RowsResponse.decode_body(data[HEADER_SIZE:])
+        assert decoded.rows[0] == [b""]
+        assert decoded.rows[1] == [b"x"]
+        assert decoded.rows[2] == [b"12345678"]
+        assert decoded.rows[3] == [b"123456789"]
+
+
 class TestEmptyResponse:
     def test_encode(self) -> None:
         msg = EmptyResponse()