Merge pull request #53 from n0nSmoker/fix/serializer_fork_callable

Fix serializer fork on callable

Author: n0nSmoker

sqlalchemy_serializer/serializer.py

@@ -191,7 +191,7 @@ def is_forkable(self, value):
     def fork(self, key: str) -> "Serializer":
         """
         Return new serializer for a key
-        :return: serialized value
+        :return: serializer
         """
         serializer = Serializer(**self.opts._asdict())
         serializer.set_serialization_depth(self.serialization_depth + 1)
@@ -200,23 +200,47 @@ def fork(self, key: str) -> "Serializer":
         logger.debug("Fork serializer for key:%s", key)
         return serializer
 
-    def serialize(self, value):
+    def serialize(self, value, **kwargs):
+        """
+        Orchestrates the serialization process.
+
+        Args:
+            value: The value to be serialized.
+            **kwargs: Only to ensure that no key is passed
+                        since None and Ellipsis are valid keys.
+
+        Returns:
+            The serialized value.
+        """
         if self.is_valid_callable(value):
             value = value()
+            logger.debug("Process callable resulting type:%s", get_type(value))
 
+        if kwargs:
+            if "key" in kwargs:
+                # since None and ... are valid keys
+                return self.serialize_with_fork(value=value, key=kwargs["key"])
+            raise ValueError("Malformed structure of kwargs. Only `key` accepted")
+
+        return self.apply_callback(value=value)
+
+    def apply_callback(self, value):
+        """
+        Apply a proper callback to serialize the value
+        :return: serialized value
+        :raises: IsNotSerializable
+        """
         for types, callback in self.serialize_types:
             if isinstance(value, types):
                 return callback(value)
-        raise IsNotSerializable(f"Unserializable type:{type(value)} value:{value}")
+        raise IsNotSerializable(f"Unserializable type:{get_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)
+        return serializer.apply_callback(value)
 
     def serialize_iter(self, value: Iterable) -> list:
         res = []
@@ -238,7 +262,7 @@ def serialize_dict(self, value: dict) -> dict:
             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))
 
-                res[k] = self.serialize_with_fork(value=v, key=k)
+                res[k] = self.serialize(value=v, key=k)
             else:
                 logger.debug("Skip key:%s of dict", k)
         return res
@@ -255,9 +279,12 @@ def serialize_model(self, value) -> dict:
             if self.schema.is_included(key=k):  # TODO: Skip check if is NOT greedy
                 v = getattr(value, k)
                 logger.debug(
-                    "Serialize key:%s type:%s model:%s", k, get_type(v), get_type(value)
+                    "Serialize key:%s type:%s of model:%s",
+                    k,
+                    get_type(v),
+                    get_type(value),
                 )
-                res[k] = self.serialize_with_fork(value=v, key=k)
+                res[k] = self.serialize(value=v, key=k)
 
             else:
                 logger.debug("Skip key:%s of model:%s", k, get_type(value))

tests/test_serializer_serialize_dict__function.py

@@ -0,0 +1,54 @@
+from decimal import Decimal
+import pytest
+
+
+@pytest.fixture
+def test_dict():
+    return {
+        "int": 123,
+        "float": 12.3,
+        "decimal": Decimal("12.3"),
+        "str": "!@#$%^",
+        "callable": lambda: {"str": "value", "int": 1234},
+        "list_of_dicts": [
+            {
+                "str": "string",
+                "int": 1235,
+            }
+        ],
+    }
+
+
+def test_serializer_serialize_dict__success(get_serializer, test_dict):
+    serializer = get_serializer()
+    result = serializer.serialize_dict(test_dict)
+    assert result == {
+        "int": 123,
+        "float": 12.3,
+        "decimal": "12.3",
+        "str": "!@#$%^",
+        "callable": {"str": "value", "int": 1234},
+        "list_of_dicts": [
+            {
+                "str": "string",
+                "int": 1235,
+            }
+        ],
+    }
+
+
+@pytest.mark.parametrize(
+    "only, expected",
+    [
+        (("int",), {"int": 123}),
+        (("callable.int",), {"callable": {"int": 1234}}),
+        (("list_of_dicts.int",), {"list_of_dicts": [{"int": 1235}]}),
+    ],
+)
+def test_serializer_serialize_dict__fork_success(
+    get_serializer, test_dict, only, expected
+):
+    serializer = get_serializer()
+    serializer.schema.update(only=only)
+    result = serializer.serialize_dict(test_dict)
+    assert result == expected