Merge pull request #48 from n0nSmoker/refactor/fork-function

Refactor fork function

Makefile

@@ -4,3 +4,5 @@ FILE = $(file)
 test:
 	TEST_FILE=$(FILE) docker-compose up --build --abort-on-container-exit
 
+format:
+	black .

docker-compose.yml

@@ -14,6 +14,7 @@ services:
         "poetry",
         "run",
         "pytest",
+        "-vv",
         "--pylama",
         "--cov=sqlalchemy_serializer",
         "--cov-report",

pyproject.toml

@@ -31,6 +31,7 @@ pytest-cov = "5.0.0"
 pylama = "8.4.1"
 requests = "2.32.3"
 black = "^24.4.2"
+pytest-mock = "^3.14.0"
 
 [build-system]
 requires = ["poetry-core"]

sqlalchemy_serializer/serializer.py

@@ -181,9 +181,6 @@ def fork(self, value, key: t.Optional[str] = None):
         Process data in a separate serializer
         :return: serialized value
         """
-        if not self.is_forkable(value):
-            return self.serialize(value)
-
         serializer = Serializer(**self.opts._asdict())
         if key is None:
             serializer.schema = self.schema
@@ -206,18 +203,26 @@ def serialize_iter(self, value: Iterable) -> list:
         res = []
         for v in value:
             try:
-                res.append(self.fork(value=v))
+                if self.is_forkable(v):
+                    r = self.fork(value=v)
+                else:
+                    r = self.serialize(v)
             except IsNotSerializable:
                 logger.warning("Can not serialize type:%s", get_type(v))
                 continue
+
+            res.append(r)
         return res
 
     def serialize_dict(self, value: dict) -> dict:
         res = {}
         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))
-                res[k] = self.fork(key=k, value=v)
+                if self.is_forkable(v):
+                    res[k] = self.fork(key=k, value=v)
+                else:
+                    res[k] = self.serialize(v)
             else:
                 logger.debug("Skip key:%s of dict", k)
         return res
@@ -236,7 +241,11 @@ def serialize_model(self, value) -> dict:
                 logger.debug(
                     "Serialize key:%s type:%s model:%s", k, get_type(v), get_type(value)
                 )
-                res[k] = self.fork(key=k, value=v)
+                if self.is_forkable(v):
+                    res[k] = self.fork(key=k, value=v)
+                else:
+                    res[k] = self.serialize(v)
+
             else:
                 logger.debug("Skip key:%s of model:%s", k, get_type(value))
         return res

tests/test_serializer_fork_function.py

@@ -0,0 +1,58 @@
+import pytest
+
+from sqlalchemy_serializer.serializer import Serializer
+
+
+@pytest.fixture
+def test_class():
+    serializer = Serializer(
+        date_format="%Y-%m-%d",
+        datetime_format="%Y-%m-%d %H:%M:%S",
+        time_format="%H:%M",
+        decimal_format="{}",
+        tzinfo=None,
+        serialize_types=(),
+    )
+    return serializer
+
+
+def test_fork_with_none_key(mocker, test_class):
+    value = "test_value"
+    expected = "serialized"
+    schema = mocker.MagicMock()
+    mocker.patch(
+        "sqlalchemy_serializer.serializer.Serializer.__call__", return_value=expected
+    )
+
+    with mocker.patch.object(test_class, "schema", schema):
+        result = test_class.fork(value)
+
+    assert result == expected
+    schema.fork.assert_not_called()
+
+
+def test_fork_with_key(mocker, test_class):
+    value, key, expected = "test_value", "test_key", "serialized"
+    schema = mocker.MagicMock()
+
+    mocker.patch(
+        "sqlalchemy_serializer.serializer.Serializer.__call__", return_value=expected
+    )
+
+    with mocker.patch.object(test_class, "schema", schema):
+        result = test_class.fork(value=value, key=key)
+
+    assert result == expected
+    schema.fork.assert_called_once_with(key=key)
+
+
+def test_fork_logger(mocker, test_class):
+    mocked_logger = mocker.patch("sqlalchemy_serializer.serializer.logger")
+    mocker.patch("sqlalchemy_serializer.serializer.Serializer.__call__")
+
+    with mocker.patch.object(test_class, "schema", mocker.MagicMock()):
+        test_class.fork("value")
+
+    mocked_logger.debug.assert_called_once_with(
+        "Fork serializer for type:%s", "str"
+    )