require explicit serializable type registration by default for Object…

…Mapper

jivago/serialization/deserialization/named_tuple_deserialization_strategy.py

@@ -37,7 +37,7 @@ def deserialize(self, obj, declared_type: Type[NamedTuple]) -> NamedTuple:
             attributes = declared_type.__annotations__
             parameters = Stream(attributes.items()) \
                 .map(lambda name, attribute_type:
-                     (name, self.deserializer.deserialize(obj.get(name), attribute_type))) \
+                     self.deserializer.deserialize(obj.get(name), attribute_type)) \
                 .toList()
         elif isinstance(obj, list):
             parameters = obj

jivago/serialization/deserializer.py

@@ -17,7 +17,8 @@
     TypedDictionaryDeserializationStrategy
 from jivago.serialization.deserialization.typed_list_deserialization_strategy import TypedListDeserializationStrategy
 from jivago.serialization.deserialization.typed_tuple_deserialization_strategy import TypedTupleDeserializationStrategy
-from jivago.serialization.serialization_exception import SerializationException
+from jivago.serialization.serialization_exception import SerializationException, \
+    NoMatchingDeserializationStrategyException
 from jivago.wsgi.invocation.incorrect_attribute_type_exception import IncorrectAttributeTypeException
 
 T = TypeVar('T')
@@ -48,7 +49,7 @@ def deserialize(self, obj: dict, object_clazz: Type[T]) -> T:
         try:
             return Stream(self.deserialization_strategies). \
                 firstMatch(lambda s: s.can_handle_deserialization(object_clazz)) \
-                .orElseThrow(SerializationException) \
+                .orElseThrow(lambda: NoMatchingDeserializationStrategyException(object_clazz)) \
                 .deserialize(obj, object_clazz)
         except (AttributeError, TypeError):
             raise IncorrectAttributeTypeException()

jivago/serialization/object_mapper.py

@@ -13,8 +13,9 @@
 
 class ObjectMapper(object):
 
-    def __init__(self):
-        self.deserializer = Deserializer(ObjectMapper.__RegistryStub())
+    def __init__(self, allow_unregistered_types: bool = False):
+        self.deserializer = Deserializer(
+            ObjectMapper.__RegistryStub() if allow_unregistered_types else Registry.INSTANCE)
         self.serializer = Serializer()
 
     def deserialize(self, json_str: str, clazz: Type[T]) -> T:
@@ -29,4 +30,4 @@ class __RegistryStub(Registry):
 
         @Override
         def is_annotated(self, object: object, annotation: "Annotation"):
-            return annotation == Serializable and object not in BUILTIN_TYPES + (dict,)
+            return annotation == Serializable and object not in BUILTIN_TYPES + (dict, list, tuple)

jivago/serialization/serialization_exception.py

@@ -1,2 +1,8 @@
 class SerializationException(Exception):
     pass
+
+
+class NoMatchingDeserializationStrategyException(SerializationException):
+    def __init__(self, clazz: type):
+        super().__init__(self,
+                         f"Could not find an appropriate deserialization strategy for type {clazz}. Are you missing the '@Serializable' annotation?")

test/serialization/test_dto_serialization_handler.py

@@ -5,7 +5,8 @@
 from jivago.lang.annotations import Serializable
 from jivago.lang.registry import Registry
 from jivago.serialization.deserializer import Deserializer
-from jivago.serialization.serialization_exception import SerializationException
+from jivago.serialization.serialization_exception import SerializationException, \
+    NoMatchingDeserializationStrategyException
 from jivago.serialization.serializer import Serializer
 from jivago.wsgi.invocation.incorrect_attribute_type_exception import IncorrectAttributeTypeException
 
@@ -181,6 +182,8 @@ def test_givenNamedTuple_whenDeserializing_thenDeserializeFromDictionary(self):
         result = self.serialization_handler.deserialize(serialized, ANamedTuple)
 
         self.assertIsInstance(result, ANamedTuple)
+        self.assertEqual("paul atreides", result.name)
+        self.assertEqual(17, result.age)
 
     def test_givenJsonList_whenDeserializingAsNamedTuple_thenDeserializeFromList(self):
         serialized = ["paul atreides", 17]
@@ -227,6 +230,31 @@ def test_givenATypeDerivedFromABuiltInType_whenDeserializing_thenDeserializesAsB
         self.assertEqual("my-name", result.name)
         self.assertIsInstance(result.name, DerivedString)
 
+    def test_givenUntypedList_whenDeserializing_thenInstantiateBasicList(self):
+        given = [1, 2, 3]
+
+        result = self.serialization_handler.deserialize(given, list)
+
+        self.assertEqual(given, result)
+
+    def test_givenUntypedTuple_whenDeserializing_thenInstantiateBasicTuple(self):
+        given = [1, 2, 3]
+
+        result = self.serialization_handler.deserialize(given, tuple)
+
+        self.assertEqual((1, 2, 3), result)
+
+    def test_givenUntypedDictionary_whenDeserializing_thenInstantiateBasicDict(self):
+        given = {"key": "value"}
+
+        result = self.serialization_handler.deserialize(given, dict)
+
+        self.assertEqual(given, result)
+
+    def test_givenUnknownDeserializationStrategy_whenDeserializing_thenThrowExceptionWithHelpfulMessage(self):
+        with self.assertRaisesRegexp(NoMatchingDeserializationStrategyException, "UnknownType.*@Serializable"):
+            self.serialization_handler.deserialize({}, UnknownType)
+
 
 @Serializable
 class ADto(object):
@@ -292,6 +320,10 @@ class DtoWithDerivedStringMember(object):
     name: DerivedString
 
 
+class UnknownType(object):
+    pass
+
+
 A_NESTED_DTO = ANestedDto()
 A_NESTED_DTO.child_dto = ChildDto()
 A_NESTED_DTO.child_dto.name = "a name"

test/serialization/test_object_mapper.py

@@ -1,19 +1,33 @@
 import unittest
 
+from jivago.lang.annotations import Serializable
 from jivago.serialization.object_mapper import ObjectMapper
+from jivago.serialization.serialization_exception import SerializationException
 
 
 class ObjectMapperTest(unittest.TestCase):
 
     def setUp(self):
         self.object_mapper = ObjectMapper()
 
-    def test_givenUnregisteredDtoClass_whenDeserializing_thenIgnoreClassRegistrationStatus(self):
+    def test_givenUnregisteredType_whenDeserializing_thenThrowException(self):
+        with self.assertRaises(SerializationException):
+            self.object_mapper.deserialize('{ "name": "foo" }', A_Dto)
+
+    def test_givenRegisteredType_whenSerializing_thenDeserializeCorrectly(self):
+        dto = self.object_mapper.deserialize('{ "name": "foo" }', A_RegisteredDto)
+
+        self.assertEqual("foo", dto.name)
+
+    def test_givenAllowUnregisteredTypes_whenDeserializing_thenIgnoreClassRegistrationStatus(self):
+        self.object_mapper = ObjectMapper(allow_unregistered_types=True)
+
         dto = self.object_mapper.deserialize('{ "name": "foo" }', A_Dto)
 
         self.assertEqual("foo", dto.name)
 
-    def test_givenUnregisteredDtoClass_whenSerializing_thenIgnoreClassRegistrationStatus(self):
+    def test_givenAllowUnregisteredTypes_whenSerializing_thenIgnoreClassRegistrationStatus(self):
+        self.object_mapper = ObjectMapper(allow_unregistered_types=True)
         dto = A_Dto()
         dto.name = "foo"
 
@@ -24,3 +38,8 @@ def test_givenUnregisteredDtoClass_whenSerializing_thenIgnoreClassRegistrationSt
 
 class A_Dto(object):
     name: str
+
+
+@Serializable
+class A_RegisteredDto(object):
+    name: str