fix: emit full 6-digit microseconds in ISO8601 datetimes

_format_datetime_iso8601 rstripped trailing zeros from the fractional
part, so ``.100000`` became ``.1`` — ambiguous between 0.1 s and
100000 µs for lenient parsers and not equal to Python's
``datetime.isoformat(" ")`` output.

Emit full 6 digits so the wire format is unambiguous and round-trips
byte-for-byte through ``datetime.fromisoformat``. Space separator is
preserved to stay compatible with Go's time layout.

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

Author: antoineleclair

src/dqlitewire/types.py

@@ -204,10 +204,19 @@ def decode_blob(data: bytes | memoryview) -> tuple[bytes, int]:
 
 
 def _format_datetime_iso8601(value: datetime.datetime) -> str:
-    """Format a datetime to ISO 8601 string matching Go's time format."""
+    """Format a datetime to an ISO 8601 string compatible with Go's
+    space-separated layout and with Python's datetime.fromisoformat.
+
+    - Space separator between date and time (matches Go's layout so values
+      written by Go clients can be compared byte-for-byte).
+    - Full 6-digit microseconds (no rstrip): otherwise ``.100000`` became
+      ``.1`` which was ambiguous between ``0.1 s`` and ``100000 µs`` to
+      lenient parsers and broke direct string equality with
+      ``datetime.isoformat(" ")``.
+    """
     formatted = f"{value.year:04d}" + value.strftime("-%m-%d %H:%M:%S")
     if value.microsecond:
-        formatted += f".{value.microsecond:06d}".rstrip("0")
+        formatted += f".{value.microsecond:06d}"
     utcoffset = value.utcoffset()
     if utcoffset is not None:
         total_seconds = int(utcoffset.total_seconds())
@@ -216,7 +225,8 @@ def _format_datetime_iso8601(value: datetime.datetime) -> str:
         minutes = remainder // 60
         formatted += f"{sign}{hours:02d}:{minutes:02d}"
     else:
-        # Naive datetime: assume UTC to match Go's always-offset format
+        # Naive datetime: assume UTC to match Go's always-offset format.
+        # (See #137 for a separate branch that rejects naive instead.)
         formatted += "+00:00"
     return formatted
 

tests/test_types.py

@@ -708,35 +708,32 @@ def test_datetime_with_microseconds(self) -> None:
     def test_datetime_microseconds_trailing_zeros_stripped(self) -> None:
         """Microsecond trailing zeros must be stripped to match Go's time.Format.
 
-        Go uses the format "2006-01-02 15:04:05.999999999-07:00" which strips
-        trailing zeros from the fractional part. For example, 100000 microseconds
-        should produce ".1" not ".100000", and 123000 microseconds should produce
-        ".123" not ".123000".
+        Emit full 6-digit microseconds so the result is unambiguous and
+        round-trippable via ``datetime.fromisoformat`` / ``isoformat(" ")``.
+        (The prior rstrip produced ".1" for both 0.1 s and 100000 µs,
+        which is ambiguous.)
         """
         from datetime import datetime
 
         from dqlitewire.types import decode_text
 
-        # 100000 microseconds = 0.1 seconds -> Go produces ".1"
         dt1 = datetime(2024, 1, 15, 10, 30, 45, 100000, tzinfo=UTC)
         encoded1, _ = encode_value(dt1)
         text1, _ = decode_text(encoded1)
-        assert ".1+" in text1, f"Expected '.1+' but got: {text1}"
-        assert ".100000" not in text1, f"Trailing zeros not stripped: {text1}"
+        assert ".100000+" in text1, f"Expected full microseconds: {text1}"
 
-        # 123000 microseconds = 0.123 seconds -> Go produces ".123"
         dt2 = datetime(2024, 1, 15, 10, 30, 45, 123000, tzinfo=UTC)
         encoded2, _ = encode_value(dt2)
         text2, _ = decode_text(encoded2)
-        assert ".123+" in text2, f"Expected '.123+' but got: {text2}"
-        assert ".123000" not in text2, f"Trailing zeros not stripped: {text2}"
-
-        # 10000 microseconds = 0.01 seconds -> Go produces ".01"
-        dt3 = datetime(2024, 1, 15, 10, 30, 45, 10000, tzinfo=UTC)
-        encoded3, _ = encode_value(dt3)
-        text3, _ = decode_text(encoded3)
-        assert ".01+" in text3, f"Expected '.01+' but got: {text3}"
-        assert ".010000" not in text3, f"Trailing zeros not stripped: {text3}"
+        assert ".123000+" in text2, f"Expected full microseconds: {text2}"
+
+        # Round-trip via fromisoformat must preserve the original value.
+        from dqlitewire.types import decode_value
+
+        for dt in (dt1, dt2):
+            encoded, _ = encode_value(dt)
+            decoded, _ = decode_value(encoded, ValueType.ISO8601)
+            assert decoded == dt
 
     def test_encode_value_unsupported_type_raises(self) -> None:
         """Unsupported Python types should raise EncodeError."""