adds multi-dimensional array handling for additional properties

Author: sufyankhanrao

apimatic_core/utilities/api_helper.py

@@ -128,17 +128,31 @@ def json_deserialize(json, unboxing_function=None, as_dict=False):
 
     @staticmethod
     def apply_unboxing_function(value, unboxing_function, is_array=False, is_dict=False, is_array_of_map=False,
-                                is_map_of_array=False):
+                                is_map_of_array=False, dimension_count=1):
         if is_dict:
             if is_map_of_array:
-                return {k: list(map(unboxing_function, v)) for k, v in value.items()}
+                return {k: ApiHelper.apply_unboxing_function(v,
+                                                             unboxing_function,
+                                                             is_array=True,
+                                                             dimension_count=dimension_count)
+                        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))
+                return [
+                    ApiHelper.apply_unboxing_function(element,
+                                                      unboxing_function,
+                                                      is_dict=True,
+                                                      dimension_count=dimension_count)
+                    for element in value]
+            elif dimension_count > 1:
+                return [ApiHelper.apply_unboxing_function(element, unboxing_function,
+                                                          is_array=True,
+                                                          dimension_count=dimension_count - 1)
+                        for element in value]
             else:
-                return list(map(unboxing_function, value))
+                return [unboxing_function(element) for element in value]
 
         return unboxing_function(value)
 

tests/apimatic_core/utility_tests/test_api_helper.py

@@ -1068,27 +1068,35 @@ def test_get_additional_properties_exception(self, dictionary):
         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",
+        "value, unboxing_function, is_array, is_dict, is_array_of_map, is_map_of_array, dimension_count, expected",
         [
             # Test case 1: Simple object
-            (5, lambda x: x * 2, False, False, False, False, 10),
+            (5, lambda x: x * 2, False, False, False, False, 0, 10),
             # Test case 2: Array
-            ([1, 2, 3], lambda x: x * 2, True, False, False, False, [2, 4, 6]),
+            ([1, 2, 3], lambda x: x * 2, True, False, False, False, 0, [2, 4, 6]),
             # Test case 3: Dictionary
-            ({"a": 1, "b": 2}, lambda x: x * 2, False, True, False, False, {"a": 2, "b": 4}),
+            ({"a": 1, "b": 2}, lambda x: x * 2, False, True, False, False, 0, {"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}]),
+            ([{"a": 1}, {"b": 2}], lambda x: x * 2, True, False, True, False, 0, [{"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]}),
+            ({"a": [1, 2], "b": [3, 4]}, lambda x: x * 2, False, True, False, True, 0, {"a": [2, 4], "b": [6, 8]}),
+            # Test case 6: Multi-dimensional array
+            ([[1], [2, 3], [4]], lambda x: x * 2, True, False, False, False, 2, [[2], [4, 6], [8]]),
+            # Test case 7: Array of arrays
+            ([[1, 2], [3, 4]], lambda x: x * 2, True, False, False, False, 2, [[2, 4], [6, 8]]),
+            # Test case 8: Array of arrays of arrays
+            ([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], lambda x: x * 2, True, False, False, False, 3,
+             [[[2, 4], [6, 8]], [[10, 12], [14, 16]]]),
         ],
     )
     def test_apply_unboxing_function(self, value, unboxing_function, is_array, is_dict,
-                                     is_array_of_map, is_map_of_array, expected):
+                                     is_array_of_map, is_map_of_array, dimension_count, expected):
         result = ApiHelper.apply_unboxing_function(
             value,
             unboxing_function,
             is_array,
             is_dict,
             is_array_of_map,
-            is_map_of_array)
+            is_map_of_array,
+            dimension_count)
         assert result == expected