adds array of map and map of array handling for unboxing function in ApiHelper

Author: sufyankhanrao

apimatic_core/utilities/api_helper.py

@@ -119,16 +119,28 @@ def json_deserialize(json, unboxing_function=None, as_dict=False):
         if unboxing_function is None:
             return decoded
 
-        return ApiHelper.apply_unboxing_function(decoded, unboxing_function, as_dict)
+        if as_dict:
+            return {k: unboxing_function(v) for k, v in decoded.items()}
+        elif isinstance(decoded, list):
+            return [unboxing_function(element) for element in decoded]
+
+        return unboxing_function(decoded)
 
     @staticmethod
-    def apply_unboxing_function(obj, unboxing_function, as_dict=False):
-        if as_dict:
-            return {k: unboxing_function(v) for k, v in obj.items()}
-        elif isinstance(obj, list):
-            return [unboxing_function(element) for element in obj]
+    def apply_unboxing_function(value, unboxing_function, is_array=False, is_dict=False, is_array_of_map=False,
+                                is_map_of_array=False):
+        if is_dict:
+            if is_map_of_array:
+                return {k: list(map(unboxing_function, v)) for k, v in value.items()}
+            else:
+                return {k: unboxing_function(v) for k, v in value.items()}
+        elif is_array:
+            if is_array_of_map:
+                return list(map(lambda x: {k: unboxing_function(v) for k, v in x.items()}, value))
+            else:
+                return list(map(unboxing_function, value))
 
-        return unboxing_function(obj)
+        return unboxing_function(value)
 
     @staticmethod
     def dynamic_deserialize(dynamic_response):

tests/apimatic_core/mocks/models/model_with_additional_properties.py

@@ -120,7 +120,7 @@ def from_dictionary(cls,
 
         additional_properties = ApiHelper.get_additional_properties(
             dictionary={k: v for k, v in dictionary.items() if k not in cls._names.values()},
-            unboxing_function=lambda x: ApiHelper.apply_unboxing_function(x, lambda item: int(item)))
+            unboxing_function=lambda x: ApiHelper.apply_unboxing_function(x, lambda item: int(item), is_array=True))
 
         # Return an object of this model
         return cls(email, additional_properties)
@@ -181,7 +181,7 @@ def from_dictionary(cls,
 
         additional_properties = ApiHelper.get_additional_properties(
             dictionary={k: v for k, v in dictionary.items() if k not in cls._names.values()},
-            unboxing_function=lambda x: ApiHelper.apply_unboxing_function(x, lambda item: int(item), as_dict=True))
+            unboxing_function=lambda x: ApiHelper.apply_unboxing_function(x, lambda item: int(item), is_dict=True))
 
         # Return an object of this model
         return cls(email, additional_properties)
@@ -303,7 +303,7 @@ def from_dictionary(cls,
 
         additional_properties = ApiHelper.get_additional_properties(
             dictionary={k: v for k, v in dictionary.items() if k not in cls._names.values()},
-            unboxing_function=lambda x: ApiHelper.apply_unboxing_function(x, lambda item: Lion.from_dictionary(item)))
+            unboxing_function=lambda x: ApiHelper.apply_unboxing_function(x, lambda item: Lion.from_dictionary(item), is_array=True))
 
         # Return an object of this model
         return cls(email, additional_properties)
@@ -366,7 +366,7 @@ def from_dictionary(cls,
             dictionary={k: v for k, v in dictionary.items() if k not in cls._names.values()},
             unboxing_function=lambda x: ApiHelper.apply_unboxing_function(
                 x, lambda item: Lion.from_dictionary(item),
-                as_dict=True))
+                is_dict=True))
 
         # Return an object of this model
         return cls(email, additional_properties)

tests/apimatic_core/utility_tests/test_api_helper.py

@@ -1040,18 +1040,20 @@ def test_to_lower_case(self, input_list, expected_output):
         assert actual_output == expected_output
 
     @pytest.mark.parametrize(
-        "dictionary, expected_result, unboxing_func, is_dict",
+        "dictionary, expected_result, unboxing_func, is_array, is_dict",
         [
-            ({}, {}, lambda x: int(x), False),
-            ({"a": 1, "b": 2}, {"a": 1, "b": 2}, lambda x: int(x), False),
-            ({"a": "1", "b": "2"}, {"a": "1", "b": "2"}, lambda x: str(x), False),
-            ({"a": "Test 1", "b": "Test 2"}, {}, lambda x: int(x), False),
-            ({"a": [1, 2], "b": [3, 4]}, {"a": [1, 2], "b": [3, 4]}, lambda x: int(x), False),
-            ({"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}}, {"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}}, lambda x: int(x), True),
+            ({}, {}, lambda x: int(x), False, False),
+            ({"a": 1, "b": 2}, {"a": 1, "b": 2}, lambda x: int(x), False, False),
+            ({"a": "1", "b": "2"}, {"a": "1", "b": "2"}, lambda x: str(x), False, False),
+            ({"a": "Test 1", "b": "Test 2"}, {}, lambda x: int(x), False, False),
+            ({"a": [1, 2], "b": [3, 4]}, {"a": [1, 2], "b": [3, 4]}, lambda x: int(x), True, False),
+            ({"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}}, {"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}}, lambda x: int(x), False, True),
         ],
     )
-    def test_get_additional_properties_success(self, dictionary, expected_result, unboxing_func, is_dict):
-        result = ApiHelper.get_additional_properties(dictionary, lambda x: ApiHelper.apply_unboxing_function(x, unboxing_func, is_dict))
+    def test_get_additional_properties_success(self, dictionary, expected_result, unboxing_func, is_array, is_dict):
+        result = ApiHelper.get_additional_properties(
+            dictionary, lambda x: ApiHelper.apply_unboxing_function(
+                x, unboxing_func, is_array, is_dict))
         assert result == expected_result
 
     @pytest.mark.parametrize(
@@ -1063,4 +1065,30 @@ def test_get_additional_properties_success(self, dictionary, expected_result, un
     )
     def test_get_additional_properties_exception(self, dictionary):
         result = ApiHelper.get_additional_properties(dictionary, ApiHelper.apply_unboxing_function)
-        assert result == {}  # expected result when exception occurs
+        assert result == {}  # expected result when exception occurs
+
+    @pytest.mark.parametrize(
+        "value, unboxing_function, is_array, is_dict, is_array_of_map, is_map_of_array, expected",
+        [
+            # Test case 1: Simple object
+            (5, lambda x: x * 2, False, False, False, False, 10),
+            # Test case 2: Array
+            ([1, 2, 3], lambda x: x * 2, True, False, False, False, [2, 4, 6]),
+            # Test case 3: Dictionary
+            ({"a": 1, "b": 2}, lambda x: x * 2, False, True, False, False, {"a": 2, "b": 4}),
+            # Test case 4: Array of maps
+            ([{"a": 1}, {"b": 2}], lambda x: x * 2, True, False, True, False, [{"a": 2}, {"b": 4}]),
+            # Test case 5: Map of arrays
+            ({"a": [1, 2], "b": [3, 4]}, lambda x: x * 2, False, True, False, True, {"a": [2, 4], "b": [6, 8]}),
+        ],
+    )
+    def test_apply_unboxing_function(self, value, unboxing_function, is_array, is_dict,
+                                     is_array_of_map, is_map_of_array, expected):
+        result = ApiHelper.apply_unboxing_function(
+            value,
+            unboxing_function,
+            is_array,
+            is_dict,
+            is_array_of_map,
+            is_map_of_array)
+        assert result == expected