Add negative test cases for non-serializable types

This commit addresses the issue where test cases were pre-serializing
values (datetime, UUID, bytes, etc.) to strings, rather than testing
how stores handle these types.

Changes:
- Add test_put_nonserializable_types parametrized test to base.py
  that verifies stores reject non-JSON-serializable Python types
  (datetime, date, time, UUID, bytes, tuple, set, function, type)
  by raising SerializationError
- Update comments in cases.py to clarify that datetime/UUID/bytes
  test cases are testing string handling, not object handling
- Reference negative tests in base.py where actual objects are tested

This fulfills the requirement from issue #96 to include negative test
cases that assert certain types should fail.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: William Easton <[email protected]>

Author: github-actions[bot]

key-value/key-value-aio/tests/stores/base.py

@@ -46,10 +46,30 @@ async def test_empty_ttl(self, store: BaseStore):
         assert ttl == (None, None)
 
     async def test_put_serialization_errors(self, store: BaseStore):
-        """Tests that the put method does not raise an exception when called on a new store."""
+        """Tests that the put method raises SerializationError for non-JSON-serializable Pydantic types."""
         with pytest.raises(SerializationError):
             await store.put(collection="test", key="test", value={"test": AnyHttpUrl("https://test.com")})
 
+    @pytest.mark.parametrize(
+        "name,value",
+        [
+            ("datetime", __import__("datetime").datetime.now(__import__("datetime").timezone.utc)),
+            ("date", __import__("datetime").date(2025, 1, 1)),
+            ("time", __import__("datetime").time(12, 0, 0)),
+            ("uuid", __import__("uuid").UUID("12345678-1234-5678-1234-567812345678")),
+            ("bytes", b"hello world"),
+            ("tuple", (1, 2, 3)),
+            ("set", {1, 2, 3}),
+            ("function", lambda x: x),
+            ("type", type("TestClass", (), {})),
+        ],
+        ids=["datetime", "date", "time", "uuid", "bytes", "tuple", "set", "function", "type"],
+    )
+    async def test_put_nonserializable_types(self, store: BaseStore, name: str, value: Any):  # pyright: ignore[reportUnusedParameter] # noqa: ARG002
+        """Tests that non-JSON-serializable Python types raise SerializationError."""
+        with pytest.raises(SerializationError):
+            await store.put(collection="test", key="test", value={"test": value})
+
     async def test_get_put_get(self, store: BaseStore):
         assert await store.get(collection="test", key="test") is None
         await store.put(collection="test", key="test", value={"test": "test"})

key-value/key-value-shared-test/src/key_value/shared_test/cases.py

@@ -51,7 +51,8 @@ class Case:
     name="list-three", data={"list_key_1": [1, True, 3.0, "string"]}, json='{"list_key_1": [1, true, 3.0, "string"]}'
 )
 
-# Datetime cases (serialized as ISO format strings)
+# ISO format string cases (these test string handling, not datetime object handling)
+# Note: Actual datetime/date/time objects are tested in negative test cases (base.py)
 DATETIME_CASE: Case = Case(
     name="datetime",
     data={"datetime_key": FIXED_DATETIME.isoformat()},
@@ -68,29 +69,33 @@ class Case:
     json='{"time_key": "00:00:00"}',
 )
 
-# UUID case (serialized as string)
+# UUID string case (tests string handling, not UUID object handling)
+# Note: Actual UUID objects are tested in negative test cases (base.py)
 UUID_CASE: Case = Case(
     name="uuid",
     data={"uuid_key": str(FIXED_UUID)},
     json='{"uuid_key": "12345678-1234-5678-1234-567812345678"}',
 )
 
-# Bytes case (base64 encoded)
+# Base64-encoded string case (tests string handling, not bytes object handling)
+# Note: Actual bytes objects are tested in negative test cases (base.py)
 BYTES_VALUE = b"hello world"
 BYTES_CASE: Case = Case(
     name="bytes",
     data={"bytes_key": base64.b64encode(BYTES_VALUE).decode("ascii")},
     json=f'{{"bytes_key": "{base64.b64encode(BYTES_VALUE).decode("ascii")}"}}',
 )
 
-# Tuple case (serializes as list in JSON)
+# List case (tests list handling, not tuple object handling)
+# Note: Actual tuple objects are tested in negative test cases (base.py)
 TUPLE_CASE: Case = Case(
     name="tuple",
     data={"tuple_key": [1, "two", 3.0]},
     json='{"tuple_key": [1, "two", 3.0]}',
 )
 
-# Set case (serializes as sorted list in JSON)
+# List case (tests list handling, not set object handling)
+# Note: Actual set objects are tested in negative test cases (base.py)
 SET_CASE: Case = Case(
     name="set",
     data={"set_key": [1, 2, 3]},