Pin encode_value rejection of Decimal / Fraction / complex / custom

The wire codec accepts only bool / int / float / str / bytes / None.
Anything else hits the ``Cannot infer wire type`` branch in
``encode_value``. That rejection path was only exercised
incidentally, so a future refactor that added implicit Decimal or
numpy support (or accidentally accepted an object with __index__)
would slip through.

Add rejection tests for Decimal, Fraction, complex, plain object(),
and a class defining only __index__ (which is not an int subclass).
Tests intentionally do NOT include numpy — numpy is not a declared
dependency, and adding optional coverage risks flaky CI signal.
Integration-side tests in the dbapi package cover the corresponding
DataError bubbling.

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

Author: antoineleclair

tests/test_types.py

@@ -686,3 +686,47 @@ def test_encode_value_false_as_explicit_integer(self) -> None:
         encoded, vtype = encode_value(False, ValueType.INTEGER)
         assert vtype == ValueType.INTEGER
         assert decode_int64(encoded) == 0
+
+
+class TestEncodeValueUnsupportedTypes:
+    """Pin the rejection contract for Python types the wire codec does
+    not natively understand. The codec accepts only bool / int / float /
+    str / bytes / None; anything else must surface as ``EncodeError`` so
+    callers see a clear driver-level error rather than a nonsense wire
+    frame. These tests lock the current behaviour so a future refactor
+    that adds implicit Decimal / numpy support is an intentional
+    change — not a silent one.
+    """
+
+    def test_decimal_rejected(self) -> None:
+        from decimal import Decimal
+
+        with pytest.raises(EncodeError, match="Cannot infer wire type"):
+            encode_value(Decimal("3.14"))
+
+    def test_fraction_rejected(self) -> None:
+        from fractions import Fraction
+
+        with pytest.raises(EncodeError, match="Cannot infer wire type"):
+            encode_value(Fraction(1, 3))
+
+    def test_complex_rejected(self) -> None:
+        with pytest.raises(EncodeError, match="Cannot infer wire type"):
+            encode_value(complex(1, 2))
+
+    def test_plain_object_rejected(self) -> None:
+        with pytest.raises(EncodeError, match="Cannot infer wire type"):
+            encode_value(object())
+
+    def test_index_only_class_rejected(self) -> None:
+        """An object with ``__index__`` but no ``__int__`` or bool-ness
+        is NOT treated as int by ``isinstance(value, int)``; confirm
+        rejection so the contract stays tight.
+        """
+
+        class OnlyIndex:
+            def __index__(self) -> int:
+                return 42
+
+        with pytest.raises(EncodeError, match="Cannot infer wire type"):
+            encode_value(OnlyIndex())