adds test cases for the utilities and fixes the utilities in the APIHelper class as well

Author: sufyankhanrao

apimatic_core/utilities/api_helper.py

@@ -753,8 +753,8 @@ def resolve_response_pointer(pointer, json_body, json_headers):
         if pointer is None or pointer == '':
             return None
 
-        prefix = pointer.split("#")[0]
-        path = pointer.rsplit('#')[1].rstrip('}')
+        prefix, path = ApiHelper.split_into_parts(pointer)
+        path = path.rstrip('}')
 
         try:
             if prefix == "$response.body":
@@ -778,7 +778,7 @@ def split_into_parts(json_pointer):
         Returns:
             tuple: A tuple containing the path prefix and the field path. Returns None if input is None.
         """
-        if json_pointer is None:
+        if json_pointer is None or json_pointer == '':
             return None
 
         pointer_parts = json_pointer.split("#")
@@ -801,7 +801,18 @@ def update_entry_by_json_pointer(dictionary, pointer, value, inplace=True):
         Returns:
             dict: The updated dictionary.
         """
-        return set_pointer(dictionary, pointer, value, inplace=inplace)
+        if not inplace:
+            import copy
+            dictionary = copy.deepcopy(dictionary)
+
+        parts = pointer.strip("/").split("/")
+        current = dictionary
+        for part in parts[:-1]:
+            if part not in current or not isinstance(current[part], dict):
+                current[part] = {}
+            current = current[part]
+        current[parts[-1]] = value
+        return dictionary
 
     @staticmethod
     def get_value_by_json_pointer(dictionary, pointer):
@@ -820,7 +831,7 @@ def get_value_by_json_pointer(dictionary, pointer):
         """
         try:
             return resolve_pointer(dictionary, pointer)
-        except JsonPointerException as jpe:
+        except JsonPointerException:
             return None
 
     class CustomDate(object):

tests/apimatic_core/utility_tests/test_api_helper.py

@@ -1,3 +1,4 @@
+import copy
 from datetime import datetime, date
 
 import jsonpickle
@@ -1099,4 +1100,73 @@ def test_apply_unboxing_function(self, value, unboxing_function, is_array, is_di
             is_array_of_map,
             is_map_of_array,
             dimension_count)
-        assert result == expected
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "dictionary, pointer, expected",
+        [
+            ({"foo": "bar"}, "/foo", "bar"),  # basic access
+            ({"a": {"b": {"c": 1}}}, "/a/b/c", 1),  # nested path
+            ({"list": [10, 20, 30]}, "/list/1", 20),  # list index
+            ({}, "/missing", None),  # missing key
+            ({"x": {"y": 5}}, "/x/z", None),  # partial match but invalid final key
+            ({"": "empty_key"}, "/", "empty_key"),  # root-level empty string key
+        ]
+    )
+    def test_get_value_by_json_pointer_valid_and_invalid(self, dictionary, pointer, expected):
+        result = ApiHelper.get_value_by_json_pointer(dictionary, pointer)
+        assert result == expected
+
+    def test_get_value_by_json_pointer_raises_invalid_pointer(self):
+        # Pointer with invalid format (should raise and be caught internally)
+        result = ApiHelper.get_value_by_json_pointer({"foo": "bar"}, "invalid_pointer")
+        assert result is None
+
+    @pytest.mark.parametrize(
+        "pointer, json_body, json_headers, expected",
+        [
+            ("$response.body#/name", '{"name": "Alice"}', {}, "Alice"),
+            ("$response.body#/details/age", '{"details": {"age": 30}}', {}, 30),
+            ("$response.headers#/X-Request-ID", "", {"X-Request-ID": "abc-123"}, "abc-123"),
+            ("$response.body#/missing", '{"name": "Alice"}', {}, None),
+            ("$response.headers#/missing", "", {"X-Request-ID": "abc-123"}, None),
+            ("$response.unknown#/path", '{"some": "data"}', {}, None),
+            ("", '{"some": "data"}', {}, None),
+            (None, '{"some": "data"}', {}, None),
+        ]
+    )
+    def test_resolve_response_pointer(self, pointer, json_body, json_headers, expected):
+        result = ApiHelper.resolve_response_pointer(pointer, json_body, json_headers)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "json_pointer, expected",
+        [
+            ("$response.body#/name", ("$response.body", "/name")),
+            ("$response.headers#/X-Header", ("$response.headers", "/X-Header")),
+            ("$response.body#", ("$response.body", "")),
+            ("$response.body", ("$response.body", "")),
+            ("", None),
+            (None, None),
+        ]
+    )
+    def test_split_into_parts(self, json_pointer, expected):
+        result = ApiHelper.split_into_parts(json_pointer)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "initial_dict, pointer, new_value, inplace, expected_dict",
+        [
+            ({"name": "Alice"}, "/name", "Bob", True, {"name": "Bob"}),
+            ({"a": {"b": 1}}, "/a/b", 2, True, {"a": {"b": 2}}),
+            ({}, "/new/key", "value", True, {"new": {"key": "value"}}),
+            ({"x": 1}, "/x", {"nested": "yes"}, False, {"x": {"nested": "yes"}}),
+        ]
+    )
+    def test_update_entry_by_json_pointer(self, initial_dict, pointer, new_value, inplace, expected_dict):
+        original_copy = copy.deepcopy(initial_dict)
+        result = ApiHelper.update_entry_by_json_pointer(initial_dict, pointer, new_value, inplace=inplace)
+
+        assert result == expected_dict
+        if not inplace:
+            assert initial_dict == original_copy