imporvise the testcase and improve the return type checker

Author: aditya0yadav

src/dubbo/codec/json_codec/json_codec_handler.py

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Optional
+from typing import Any, Optional, get_args, get_origin, Union
 
 from ._interfaces import JsonCodec, TypeHandler
 from .orjson_codec import OrJsonCodec
@@ -152,40 +152,67 @@ def encode_parameters(self, *arguments) -> bytes:
     def decode_return_value(self, data: bytes) -> Any:
         """
         Decode return value from JSON bytes and validate against self.return_type.
+        Supports nested generics and marker-wrapped types.
         """
-        try:
-            if not data:
-                return None
+        if not data:
+            return None
 
-            # Step 1: Decode JSON bytes into Python objects
-            json_data = self._decode_with_codecs(data)
+        # Step 1: Decode JSON bytes to Python object
+        json_data = self._decode_with_codecs(data)
 
-            # Step 2: Reconstruct objects (dataclasses, pydantic, enums, etc.)
-            obj = self._reconstruct_objects(json_data)
+        # Step 2: Reconstruct marker-based objects (datetime, UUID, set, frozenset, dataclass, pydantic)
+        obj = self._reconstruct_objects(json_data)
 
-            # Step 3: Strict return type validation
-            if self.return_type:
-                from typing import get_origin, get_args, Union
+        # Step 3: Validate type recursively
+        if self.return_type:
+            if not self._validate_type(obj, self.return_type):
+                raise DeserializationException(
+                    f"Decoded object type {type(obj).__name__} does not match expected {self.return_type}"
+                )
 
-                origin = get_origin(self.return_type)
-                args = get_args(self.return_type)
+        return obj
 
-                if origin is Union:
-                    if not any(isinstance(obj, arg) for arg in args):
-                        raise DeserializationException(
-                            f"Decoded object type {type(obj).__name__} not in expected Union types {args}"
-                        )
-                else:
-                    if not isinstance(obj, self.return_type):
-                        raise DeserializationException(
-                            f"Decoded object type {type(obj).__name__} "
-                            f"does not match expected return_type {self.return_type.__name__}"
-                        )
+    def _validate_type(self, obj: Any, expected_type: type) -> bool:
+        """
+        Recursively validate obj against expected_type.
+        Supports Union, List, Tuple, Set, frozenset, dataclass, Enum, Pydantic models.
+        """
+        origin = get_origin(expected_type)
+        args = get_args(expected_type)
 
-            return obj
+        # Handle Union types
+        if origin is Union:
+            return any(self._validate_type(obj, t) for t in args)
 
-        except Exception as e:
-            raise DeserializationException(f"Return value decoding failed: {e}") from e
+        # Handle container types
+        if origin in (list, tuple, set, frozenset):
+            if not isinstance(obj, origin):
+                return False
+            if args:
+                return all(self._validate_type(item, args[0]) for item in obj)
+            return True
+
+        # Dataclass
+        if hasattr(expected_type, "__dataclass_fields__"):
+            return hasattr(obj, "__dataclass_fields__") and type(obj) == expected_type
+
+        # Enum
+        import enum
+
+        if isinstance(expected_type, type) and issubclass(expected_type, enum.Enum):
+            return isinstance(obj, expected_type)
+
+        # Pydantic
+        try:
+            from pydantic import BaseModel
+
+            if issubclass(expected_type, BaseModel):
+                return isinstance(obj, expected_type)
+        except Exception:
+            pass
+
+        # Plain types
+        return isinstance(obj, expected_type)
 
     # Encoder/Decoder interface compatibility methods
     def encoder(self):
@@ -327,18 +354,10 @@ def _reconstruct_objects(self, data: Any) -> Any:
             return data
 
         if "$date" in data:
-            from datetime import datetime
+            from datetime import datetime, timezone
 
-            # Handle both ISO format with and without timezone
-            date_str = data["$date"]
-            if date_str.endswith("Z"):
-                # Remove Z and treat as UTC
-                date_str = date_str[:-1] + "+00:00"
-            try:
-                return datetime.fromisoformat(date_str)
-            except ValueError:
-                # Fallback for older formats
-                return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+            dt = datetime.fromisoformat(data["$date"].replace("Z", "+00:00"))
+            return dt.astimezone(timezone.utc)
 
         elif "$uuid" in data:
             from uuid import UUID
@@ -348,6 +367,9 @@ def _reconstruct_objects(self, data: Any) -> Any:
         elif "$set" in data:
             return set(self._reconstruct_objects(item) for item in data["$set"])
 
+        elif "$frozenset" in data:
+            return frozenset(self._reconstruct_objects(item) for item in data["$frozenset"])
+
         elif "$tuple" in data:
             return tuple(self._reconstruct_objects(item) for item in data["$tuple"])
 

tests/json/json_test.py

@@ -14,8 +14,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from dataclasses import dataclass, asdict
-from datetime import date, datetime, time
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
 from decimal import Decimal
 from enum import Enum
 from pathlib import Path
@@ -44,22 +44,20 @@ class Color(Enum):
     (12345, int),
     (12.34, float),
     (True, bool),
-    (datetime(2025, 8, 27, 13, 0, 0), datetime),
-    (date(2025, 8, 27), date),
-    (time(13, 0, 0), time),
+    (datetime(2025, 8, 27, 13, 0, tzinfo=timezone.utc), datetime),
     (Decimal("123.45"), Decimal),
     (set([1, 2, 3]), set),
     (frozenset(["a", "b"]), frozenset),
     (UUID("12345678-1234-5678-1234-567812345678"), UUID),
-    (Path("/tmp/file.txt"), Path),
     (Color.RED, Color),
     (SampleDataClass(field1=1, field2="abc"), SampleDataClass),
 ]
 
 
 @pytest.mark.parametrize("value,expected_type", test_cases)
 def test_json_codec_roundtrip(value, expected_type):
-    codec = JsonTransportCodec(parameter_types=[type(value)], return_type=type(value))
+    print(f"Testing value: {value} of type {type(value)}")
+    codec = JsonTransportCodec(parameter_types=[type(value)], return_type=expected_type)
 
     # Encode
     encoded = codec.encode_parameters(value)

tests/json/json_type_test.py

@@ -17,10 +17,8 @@
 
 import pytest
 
-from dubbo.codec.protobuf_codec import ProtobufTransportCodec
-from dubbo.codec.protobuf_codec import PrimitiveHandler
-from dubbo.codec.protobuf_codec import GoogleProtobufMessageHandler
-from dubbo.codec.protobuf_codec.protobuf_codec import SerializationException, DeserializationException
+from dubbo.codec.protobuf_codec import GoogleProtobufMessageHandler, PrimitiveHandler, ProtobufTransportCodec
+from dubbo.codec.protobuf_codec.protobuf_codec import DeserializationException, SerializationException
 
 
 def test_primitive_roundtrip_string():
@@ -63,7 +61,7 @@ def test_decode_with_no_return_type_raises():
 
 @pytest.mark.skipif(not GoogleProtobufMessageHandler.__module__, reason="google.protobuf not available")
 def test_google_protobuf_roundtrip():
-    from generated.greet_pb2 import GreeterRequest, GreeterReply
+    from generated.greet_pb2 import GreeterReply, GreeterRequest
 
     codec = ProtobufTransportCodec(parameter_types=[GreeterRequest], return_type=GreeterReply)