Merge pull request #27 from anikolaienko/bugfix/issue-25

Fixing issue 25

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,12 +1,17 @@
 from enum import Enum
-from typing import Any
+from typing import Any, Dict, Sequence
 
 __PRIMITIVE_TYPES = {int, float, complex, str, bytes, bytearray, bool}
 
 
 def is_sequence(obj: Any) -> bool:
     """Check if object implements `__iter__` method"""
-    return hasattr(obj, "__iter__")
+    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:

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "py-automapper"
-version = "2.0.0"
+version = "2.1.0"
 description = "Library for automatically mapping one object to another"
 authors = [
   {name = "Andrii Nikolaienko", email = "[email protected]"}

tests/test_automapper_dict.py

@@ -0,0 +1,46 @@
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import Dict
+
+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_issue_25.py

@@ -0,0 +1,39 @@
+from typing import Optional
+
+from automapper import mapper
+from pydantic import BaseModel
+
+
+class Address(BaseModel):
+    street: Optional[str]
+    number: Optional[int]
+    zip_code: Optional[int]
+    city: Optional[str]
+
+
+class PersonInfo(BaseModel):
+    name: Optional[str] = None
+    age: Optional[int] = None
+    address: Optional[Address] = None
+
+
+class PublicPersonInfo(BaseModel):
+    name: Optional[str] = None
+    address: Optional[Address] = None
+
+
+def test_map__without_deepcopy_mapped_objects_should_be_the_same():
+    address = Address(street="Main Street", number=1, zip_code=100001, city="Test City")
+    info = PersonInfo(name="John Doe", age=35, address=address)
+
+    # default deepcopy behavior
+    public_info = mapper.to(PublicPersonInfo).map(info)
+    assert (
+        public_info.address is not address
+    ), "Address mapped object is same as origin."
+
+    # disable deepcopy
+    public_info = mapper.to(PublicPersonInfo).map(info, use_deepcopy=False)
+    assert (
+        public_info.address is info.address
+    ), "Address mapped object is not same as origin."

tests/test_try_get_field_values.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+
+from automapper.mapper import _try_get_field_value
+
+
+@dataclass
+class TestClass:
+    map_field: str
+
+
+def test_try_get_field_value__if_in_custom_mapping():
+    is_found, mapped_value = _try_get_field_value("field1", None, {"field1": 123})
+
+    assert is_found
+    assert mapped_value == 123
+
+
+def test_try_get_field_value__if_origin_has_same_field_attr():
+    is_found, mapped_value = _try_get_field_value(
+        "map_field", TestClass("Hello world"), None
+    )
+
+    assert is_found
+    assert mapped_value == "Hello world"
+
+
+def test_try_get_field_value__if_origin_contains_same_field_as_item():
+    is_found, mapped_value = _try_get_field_value(
+        "map_field", {"map_field": "Hello world. Again"}, None
+    )
+
+    assert is_found
+    assert mapped_value == "Hello world. Again"
+
+
+def test_try_get_field_value__if_field_not_found():
+    is_found, mapped_value = _try_get_field_value("field1", None, None)
+
+    assert not is_found
+    assert mapped_value is None

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})