Merge pull request #52 from n0nSmoker/feature/serialization.depth.limit

Preparations for such an impactfull limitation

simplify methods for clear testing and understanding
more tests to cover edge cases

Author: n0nSmoker

sqlalchemy_serializer/serializer.py

@@ -52,7 +52,7 @@ def get_tzinfo(self):
         """
         Callback to make serializer aware of user's timezone. Should be redefined if needed
         Example:
-            return pytz.timezone('Asia/Krasnoyarsk')
+            return pytz.timezone('Africa/Abidjan')
 
         :return: datetime.tzinfo
         """
@@ -114,10 +114,33 @@ class Serializer:
     )
 
     def __init__(self, **kwargs):
-        self.serialization_depth = 0
-        self.opts = Options(**kwargs)
+        self.set_serialization_depth(0)
+        self.set_options(Options(**kwargs))
+        self.init_callbacks()
+
         self.schema = Schema()
 
+    def __call__(self, value, only=(), extend=()):
+        """
+        Serialization starts here
+        :param value: Value to serialize
+        :param only: Exclusive schema of serialization
+        :param extend: Rules that extend default schema
+        :return: object: JSON-compatible object
+        """
+        self.schema.update(only=only, extend=extend)
+
+        logger.debug("Call serializer for type:%s", get_type(value))
+        return self.serialize(value)
+
+    def set_serialization_depth(self, value: int):
+        self.serialization_depth = value
+
+    def set_options(self, opts: Options):
+        self.opts = opts
+
+    def init_callbacks(self):
+        """Initialize callbacks"""
         self.serialize_types = (
             *(self.opts.serialize_types or ()),
             (self.atomic_types, lambda x: x),  # Should be checked before any other type
@@ -141,22 +164,6 @@ def __init__(self, **kwargs):
             (SerializerMixin, self.serialize_model),
         )
 
-    def __call__(self, value, only=(), extend=()):
-        """
-        Serialization starts here
-        :param value: Value to serialize
-        :param only: Exclusive schema of serialization
-        :param extend: Rules that extend default schema
-        :return: object: JSON-compatible object
-        """
-        self.schema.update(only=only, extend=extend)
-
-        logger.debug("Call serializer for type:%s", get_type(value))
-        return self.serialize(value)
-
-    def set_serialization_depth(self, value: int):
-        self.serialization_depth = value
-
     @staticmethod
     def is_valid_callable(func) -> bool:
         """
@@ -181,17 +188,17 @@ def is_forkable(self, value):
             value, (Iterable, dict, SerializerMixin)
         )
 
-    def fork(self, value, key: str):
+    def fork(self, key: str) -> "Serializer":
         """
-        Process data in a separate serializer
+        Return new serializer for a key
         :return: serialized value
         """
         serializer = Serializer(**self.opts._asdict())
         serializer.set_serialization_depth(self.serialization_depth + 1)
         serializer.schema = self.schema.fork(key=key)
 
-        logger.debug("Fork serializer for type:%s key:%s", get_type(value), key)
-        return serializer(value)
+        logger.debug("Fork serializer for key:%s", key)
+        return serializer
 
     def serialize(self, value):
         if self.is_valid_callable(value):
@@ -202,12 +209,23 @@ def serialize(self, value):
                 return callback(value)
         raise IsNotSerializable(f"Unserializable type:{type(value)} value:{value}")
 
+    def serialize_with_fork(self, value, key):
+        # TODO: merge  this  function with the serialize function
+        # TODO: this should be performed after is_valid_callable check
+        serializer = self
+        if self.is_forkable(value):
+            serializer = self.fork(key=key)
+
+        return serializer.serialize(value)
+
     def serialize_iter(self, value: Iterable) -> list:
         res = []
         for v in value:
             try:
                 r = self.serialize(v)
-            except IsNotSerializable:
+            except (
+                IsNotSerializable
+            ):  # FIXME: Why we swallow exception only in iterable?
                 logger.warning("Can not serialize type:%s", get_type(v))
                 continue
 
@@ -219,10 +237,8 @@ def serialize_dict(self, value: dict) -> dict:
         for k, v in value.items():
             if self.schema.is_included(k):  # TODO: Skip check if is NOT greedy
                 logger.debug("Serialize key:%s type:%s of dict", k, get_type(v))
-                if self.is_forkable(v):
-                    res[k] = self.fork(key=k, value=v)
-                else:
-                    res[k] = self.serialize(v)
+
+                res[k] = self.serialize_with_fork(value=v, key=k)
             else:
                 logger.debug("Skip key:%s of dict", k)
         return res
@@ -241,10 +257,7 @@ def serialize_model(self, value) -> dict:
                 logger.debug(
                     "Serialize key:%s type:%s model:%s", k, get_type(v), get_type(value)
                 )
-                if self.is_forkable(v):
-                    res[k] = self.fork(key=k, value=v)
-                else:
-                    res[k] = self.serialize(v)
+                res[k] = self.serialize_with_fork(value=v, key=k)
 
             else:
                 logger.debug("Skip key:%s of model:%s", k, get_type(value))

tests/test_serializer_fork_function.py

@@ -1,28 +1,26 @@
+from sqlalchemy_serializer.serializer import Serializer
+
+
 def test_fork_with_key(mocker, get_serializer):
-    value, key, expected = "test_value", "test_key", "serialized"
+    key = "test_value"
     schema = mocker.MagicMock()
     serializer = get_serializer()
 
-    mocker.patch(
-        "sqlalchemy_serializer.serializer.Serializer.__call__", return_value=expected
-    )
-
     mocker.patch.object(serializer, "schema", schema)
-    result = serializer.fork(value=value, key=key)
+    result = serializer.fork(key=key)
 
-    assert result == expected
+    assert isinstance(result, Serializer)
+    assert result.opts == serializer.opts
     schema.fork.assert_called_once_with(key=key)
 
 
 def test_fork_logger(mocker, get_serializer):
-    value, key = "test_value", "test_key"
+    key = "test_key"
     mocked_logger = mocker.patch("sqlalchemy_serializer.serializer.logger")
     mocker.patch("sqlalchemy_serializer.serializer.Serializer.__call__")
     serializer = get_serializer()
 
     mocker.patch.object(serializer, "schema", mocker.MagicMock())
-    serializer.fork(value, key=key)
+    serializer.fork(key=key)
 
-    mocked_logger.debug.assert_called_once_with(
-        "Fork serializer for type:%s key:%s", "str", key
-    )
+    mocked_logger.debug.assert_called_once_with("Fork serializer for key:%s", key)