extracting new util method + added test coverage

Author: anikolaienko

automapper/mapper.py

@@ -21,7 +21,7 @@
     DuplicatedRegistrationError,
     MappingError,
 )
-from .utils import is_enum, is_primitive, is_sequence, object_contains
+from .utils import is_dictionary, is_enum, is_primitive, is_sequence, object_contains
 
 # Custom Types
 S = TypeVar("S")
@@ -264,23 +264,24 @@ def _map_subobject(
         else:
             _visited_stack.add(obj_id)
 
-            if is_sequence(obj):
-                if isinstance(obj, dict):
-                    result = {
+            if is_dictionary(obj):
+                result = type(obj)(  # type: ignore [call-arg]
+                    {
                         k: self._map_subobject(
                             v, _visited_stack, skip_none_values=skip_none_values
                         )
-                        for k, v in obj.items()
+                        for k, v in obj.items()  # type: ignore [attr-defined]
                     }
-                else:
-                    result = type(obj)(  # type: ignore [call-arg]
-                        [
-                            self._map_subobject(
-                                x, _visited_stack, skip_none_values=skip_none_values
-                            )
-                            for x in cast(Iterable[Any], obj)
-                        ]
-                    )
+                )
+            elif is_sequence(obj):
+                result = type(obj)(  # type: ignore [call-arg]
+                    [
+                        self._map_subobject(
+                            x, _visited_stack, skip_none_values=skip_none_values
+                        )
+                        for x in cast(Iterable[Any], obj)
+                    ]
+                )
             else:
                 result = deepcopy(obj)
 

automapper/utils.py

@@ -1,4 +1,10 @@
-import collections
+import sys
+
+if sys.version_info >= (3, 10):
+    from collections.abc import Sequence
+else:
+    from collections import Sequence
+
 from enum import Enum
 from typing import Any
 
@@ -7,7 +13,12 @@
 
 def is_sequence(obj: Any) -> bool:
     """Check if object implements `__iter__` method"""
-    return isinstance(obj, collections.Sequence)
+    return isinstance(obj, Sequence)
+
+
+def is_dictionary(obj: Any) -> bool:
+    """Check is object is of type dictionary"""
+    return isinstance(obj, dict)
 
 
 def is_subscriptable(obj: Any) -> bool:

tests/test_automapper_dict.py

@@ -0,0 +1,45 @@
+from collections import OrderedDict
+from dataclasses import dataclass
+
+from automapper import mapper
+
+
+@dataclass
+class Teacher:
+    teacher: str
+
+
+class Student:
+    def __init__(self, name: str, classes: dict[str, Teacher]):
+        self.name = name
+        self.classes = classes
+        self.ordered_classes = OrderedDict(classes)
+
+
+class PublicUserInfo:
+    def __init__(
+        self,
+        name: str,
+        classes: dict[str, Teacher],
+        ordered_classes: dict[str, Teacher],
+    ):
+        self.name = name
+        self.classes = classes
+        self.ordered_classes = ordered_classes
+
+
+def test_map__dict_and_ordereddict_are_mapped_correctly_to_same_types():
+    classes = {"math": Teacher("Ms G"), "art": Teacher("Mr A")}
+    student = Student("Tim", classes)
+
+    public_info = mapper.to(PublicUserInfo).map(student)
+
+    assert public_info.name is student.name
+
+    assert public_info.classes == student.classes
+    assert public_info.classes is not student.classes
+    assert isinstance(public_info.classes, dict)
+
+    assert public_info.ordered_classes == student.ordered_classes
+    assert public_info.ordered_classes is not student.ordered_classes
+    assert isinstance(public_info.ordered_classes, OrderedDict)

tests/test_utils.py

@@ -0,0 +1,79 @@
+from collections import OrderedDict
+from enum import Enum
+
+from automapper.utils import (
+    is_dictionary,
+    is_enum,
+    is_primitive,
+    is_sequence,
+    is_subscriptable,
+    object_contains,
+)
+
+
+def test_is_sequence__list_is_sequence():
+    assert is_sequence([1, 2])
+
+
+def test_is_sequence__tuple_is_sequence():
+    assert is_sequence((1, 2, 3))
+
+
+def test_is_sequence__dict_is_not_a_sequence():
+    assert not is_sequence({"a": 1})
+
+
+def test_is_dictionary__dict_is_of_type_dictionary():
+    assert is_dictionary({"a1": 1})
+
+
+def test_is_dictionary__ordered_dict_is_of_type_dictionary():
+    assert is_dictionary(OrderedDict({"a1": 1}))
+
+
+def test_is_subscriptable__dict_is_subscriptable():
+    assert is_subscriptable({"a": 1})
+
+
+def test_is_subscriptable__custom_class_can_be_subscriptable():
+    class A:
+        def __getitem__(self):
+            yield 1
+
+    assert is_subscriptable(A())
+
+
+def test_object_contains__dict_contains_field():
+    assert object_contains({"a1": 1, "b2": 2}, "a1")
+
+
+def test_object_contains__dict_does_not_contain_field():
+    assert not object_contains({"a1": 1, "b2": 2}, "c3")
+
+
+def test_is_primitive__int_is_primitive():
+    assert is_primitive(1)
+
+
+def test_is_primitive__float_is_primitive():
+    assert is_primitive(1.2)
+
+
+def test_is_primitive__str_is_primitive():
+    assert is_primitive("hello")
+
+
+def test_is_primitive__bool_is_primitive():
+    assert is_primitive(False)
+
+
+def test_is_enum__object_is_enum():
+    class EnumValue(Enum):
+        A = "A"
+        B = "B"
+
+    assert is_enum(EnumValue("A"))
+
+
+def test_is_enum__dict_is_not_enum():
+    assert not is_enum({"A": 1, "B": 2})