reduced the duplication and removed the python 3.7 testing on the changes

Author: sufyankhanrao

.github/workflows/test-runner.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-22.04]
-        python: ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        python: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Python

tests/apimatic_core/pagination_tests/strategies/test_offset_pagination.py

@@ -9,12 +9,10 @@ class TestOffsetPagination:
 
     @pytest.fixture
     def mock_metadata_wrapper(self, mocker):
-        # Reusing the mock_metadata_wrapper from previous context
         return mocker.Mock(name="metadata_wrapper_mock")
 
     @pytest.fixture
     def mock_request_builder(self, mocker):
-        # Reusing the mock_request_builder from previous context
         class MockRequestBuilder(RequestBuilder):
             @property
             def template_params(self):
@@ -36,12 +34,10 @@ def __init__(self, template_params=None, query_params=None, header_params=None):
 
             def clone_with(self, **kwargs):
                 new_rb = MockRequestBuilder()
-                # Copy existing attributes
                 new_rb._template_params = self.template_params.copy()
                 new_rb._query_params = self.query_params.copy()
                 new_rb._header_params = self.header_params.copy()
 
-                # Apply updates from kwargs
                 if 'template_params' in kwargs:
                     new_rb.template_params.update(kwargs['template_params'])
                 if 'query_params' in kwargs:
@@ -67,158 +63,127 @@ def mock_last_response(self, mocker):
     @pytest.fixture
     def mock_paginated_data_initial_call(self, mocker, mock_request_builder):
         paginated_data = mocker.Mock(spec=PaginatedData)
-        paginated_data.last_response = None  # Indicates initial call
+        paginated_data.last_response = None
         paginated_data.request_builder = mock_request_builder
-        paginated_data.page_size = 0  # Not relevant for initial call
+        paginated_data.page_size = 0
         return paginated_data
 
     @pytest.fixture
     def mock_paginated_data_subsequent_call(self, mocker, mock_request_builder, mock_last_response):
         paginated_data = mocker.Mock(spec=PaginatedData)
         paginated_data.last_response = mock_last_response
         paginated_data.request_builder = mock_request_builder
-        paginated_data.page_size = 10  # Assume previous page had 10 items
+        paginated_data.page_size = 10
         return paginated_data
 
-    # Test __init__
+    def _create_offset_pagination_instance(self, input_value, metadata_wrapper):
+        """Helper to create an OffsetPagination instance."""
+        return OffsetPagination(input_=input_value, metadata_wrapper=metadata_wrapper)
+
+    # --- Test __init__ ---
     def test_init_success(self, mock_metadata_wrapper):
-        op = OffsetPagination(input_="$request.query#/offset", metadata_wrapper=mock_metadata_wrapper)
+        op = self._create_offset_pagination_instance("$request.query#/offset", mock_metadata_wrapper)
         assert op._input == "$request.query#/offset"
         assert op._metadata_wrapper == mock_metadata_wrapper
         assert op._offset == 0
 
     def test_init_input_none_raises_error(self, mock_metadata_wrapper):
         with pytest.raises(ValueError, match="Input pointer for offset based pagination cannot be None"):
-            OffsetPagination(input_=None, metadata_wrapper=mock_metadata_wrapper)
+            self._create_offset_pagination_instance(None, mock_metadata_wrapper)
 
-    def test_init_metadata_wrapper_none_raises_error(self, mock_metadata_wrapper):
+    def test_init_metadata_wrapper_none_raises_error(self):
         with pytest.raises(ValueError, match="Metadata wrapper for the pagination cannot be None"):
-            OffsetPagination(input_=None, metadata_wrapper=None)
+            self._create_offset_pagination_instance("$request.query#/offset", None)
 
-    # Test apply
+    # --- Test apply ---
     def test_apply_initial_call_with_offset_from_query(self, mocker, mock_paginated_data_initial_call,
                                                        mock_request_builder):
-        # Mock _get_initial_offset to return a specific value
         mock_get_initial_request_param_value = mocker.patch.object(OffsetPagination, '_get_initial_request_param_value', return_value=100)
 
-        op = OffsetPagination(input_="$request.query#/offset", metadata_wrapper=mocker.Mock())
+        op = self._create_offset_pagination_instance("$request.query#/offset", mocker.Mock())
         result_rb = op.apply(mock_paginated_data_initial_call)
 
-        # Assert that _get_initial_offset was called
         mock_get_initial_request_param_value.assert_called_once_with(mock_request_builder, "$request.query#/offset")
         assert op._offset == 100
-        assert result_rb == mock_request_builder  # Should return the original request_builder
+        assert result_rb == mock_request_builder
 
     def test_apply_subsequent_call_increments_offset_and_updates_builder(self, mocker,
                                                                          mock_paginated_data_subsequent_call,
                                                                          mock_request_builder):
-        # Initialize the offset to simulate it being set by a previous call (e.g., test_apply_initial_call)
-        # or just set it to 0 and let apply handle the first increment
-        op = OffsetPagination(input_="$request.query#/offset", metadata_wrapper=mocker.Mock())
-        op._offset = 10  # Simulate offset after 1st page
+        op = self._create_offset_pagination_instance("$request.query#/offset", mocker.Mock())
+        op._offset = 10
 
-        # Patch get_updated_request_builder to simulate its behavior
         mock_get_updated_request_builder = mocker.patch.object(
             OffsetPagination, 'get_updated_request_builder',
             return_value=mock_request_builder.clone_with(query_params={"offset": 20, "limit": 10})
         )
 
         result_rb = op.apply(mock_paginated_data_subsequent_call)
 
-        # Expected offset: initial (10) + last_page_size (10) = 20
         assert op._offset == 20
         mock_get_updated_request_builder.assert_called_once_with(
             mock_request_builder, "$request.query#/offset", 20
         )
-        # Verify that the returned request builder has the updated offset
         assert result_rb.query_params["offset"] == 20
 
-    # Test apply_metadata_wrapper
+    # --- Test apply_metadata_wrapper ---
     def test_apply_metadata_wrapper(self, mock_metadata_wrapper, mocker):
         mock_metadata_wrapper.return_value = "wrapped_response_with_offset"
 
-        op = OffsetPagination(
-            input_="$request.query#/offset",
-            metadata_wrapper=mock_metadata_wrapper
-        )
-        op._offset = 50  # Set an offset value for the test
+        op = self._create_offset_pagination_instance("$request.query#/offset", mock_metadata_wrapper)
+        op._offset = 50
         mock_page_response = mocker.Mock()
 
         result = op.apply_metadata_wrapper(mock_page_response)
 
         mock_metadata_wrapper.assert_called_once_with(mock_page_response, 50)
         assert result == "wrapped_response_with_offset"
 
-    # Test _get_initial_offset
-    def test_get_initial_offset_from_path(self, mocker, mock_request_builder):
-        # Ensure the mock_request_builder has the value in template_params for this test
-        mock_request_builder._template_params = {"offset": 50}
-
-        mock_split_into_parts = mocker.patch.object(ApiHelper, 'split_into_parts',
-                                                    return_value=("$request.path", "/offset"))
-        mock_get_value_by_json_pointer = mocker.patch.object(ApiHelper, 'get_value_by_json_pointer', return_value="50")
-
-        op = OffsetPagination(input_="$request.path#/offset", metadata_wrapper=mocker.Mock())
-        result = op._get_initial_request_param_value(mock_request_builder, "$request.path#/offset")
-
-        mock_split_into_parts.assert_called_once_with("$request.path#/offset")
-        mock_get_value_by_json_pointer.assert_called_once_with(mock_request_builder.template_params, "/offset")
-        assert result == 50
-
-    def test_get_initial_offset_from_query(self, mocker, mock_request_builder, mock_metadata_wrapper):
-        # Ensure the mock_request_builder has the value in query_params for this test
-        mock_request_builder._query_params = {"offset": 100, "limit": 20}
-
-        mock_split_into_parts = mocker.patch.object(ApiHelper, 'split_into_parts',
-                                                    return_value=("$request.query", "/offset"))
-        mock_get_value_by_json_pointer = mocker.patch.object(ApiHelper, 'get_value_by_json_pointer', return_value="100")
-
-        op = OffsetPagination(input_="$request.query#/offset", metadata_wrapper=mock_metadata_wrapper)
-        result = op._get_initial_request_param_value(mock_request_builder, "$request.query#/offset")
-
-        mock_split_into_parts.assert_called_once_with("$request.query#/offset")
-        mock_get_value_by_json_pointer.assert_called_once_with(mock_request_builder.query_params, "/offset")
-        assert result == 100
-
-    def test_get_initial_offset_from_headers(self, mocker, mock_request_builder, mock_metadata_wrapper):
-        # Ensure the mock_request_builder has the value in header_params for this test
-        mock_request_builder._header_params = {"offset": 200}
-
-        mock_split_into_parts = mocker.patch.object(ApiHelper, 'split_into_parts',
-                                                    return_value=("$request.headers", "/offset"))
-        mock_get_value_by_json_pointer = mocker.patch.object(ApiHelper, 'get_value_by_json_pointer', return_value="200")
-
-        op = OffsetPagination(input_="$request.headers#/offset", metadata_wrapper=mock_metadata_wrapper)
-        result = op._get_initial_request_param_value(mock_request_builder, "$request.headers#/offset")
-
-        mock_split_into_parts.assert_called_once_with("$request.headers#/offset")
-        mock_get_value_by_json_pointer.assert_called_once_with(mock_request_builder.header_params, "/offset")
-        assert result == 200
-
-    def test_get_initial_offset_no_value_found(self, mocker, mock_request_builder, mock_metadata_wrapper):
-        # Ensure the mock_request_builder has no 'offset' in the relevant params
-        mock_request_builder._query_params = {"limit": 20}
-
+    # --- Test _get_initial_request_param_value ---
+    @pytest.mark.parametrize(
+        "input_pointer, initial_params, expected_value, json_pointer_return_value",
+        [
+            ("$request.path#/offset", {"offset": 50}, 50, "50"),
+            ("$request.query#/offset", {"offset": 100, "limit": 20}, 100, "100"),
+            ("$request.headers#/offset", {"offset": 200}, 200, "200"),
+            ("$request.query#/offset", {"limit": 20}, 0, None),  # No value found
+            ("invalid_prefix#/offset", {"offset": 10}, 0, "10"),  # Invalid prefix, should default to 0
+        ]
+    )
+    def test_get_initial_offset_various_scenarios(self, mocker, mock_request_builder, mock_metadata_wrapper,
+                                                   input_pointer, initial_params, expected_value, json_pointer_return_value):
+        # Dynamically set params based on the test case
+        if "$request.path" in input_pointer:
+            mock_request_builder._template_params = initial_params
+        elif "$request.query" in input_pointer:
+            mock_request_builder._query_params = initial_params
+        elif "$request.headers" in input_pointer:
+            mock_request_builder._header_params = initial_params
+
+        # Mocks
         mock_split_into_parts = mocker.patch.object(ApiHelper, 'split_into_parts',
-                                                    return_value=("$request.query", "/offset"))
+                                                    return_value=(input_pointer.split('#')[0], input_pointer.split('#')[1]))
         mock_get_value_by_json_pointer = mocker.patch.object(ApiHelper, 'get_value_by_json_pointer',
-                                                             return_value=None)  # Simulate not found
+                                                             return_value=json_pointer_return_value)
 
-        op = OffsetPagination(input_="$request.query#/offset", metadata_wrapper=mock_metadata_wrapper)
-        result = op._get_initial_request_param_value(mock_request_builder, "$request.query#/offset")
-        mock_split_into_parts.assert_called_once_with("$request.query#/offset")
-        mock_get_value_by_json_pointer.assert_called_once_with(mock_request_builder.query_params, "/offset")
-        assert result == 0  # Should default to 0 if not found
+        op = self._create_offset_pagination_instance(input_pointer, mock_metadata_wrapper)
+        result = op._get_initial_request_param_value(mock_request_builder, input_pointer)
 
-    def test_get_initial_offset_invalid_prefix(self, mocker, mock_request_builder, mock_metadata_wrapper):
-        mock_split_into_parts = mocker.patch.object(ApiHelper, 'split_into_parts',
-                                                    return_value=("invalid_prefix", "/offset"))
-        # Ensure get_value_by_json_pointer is not called for invalid prefixes
-        mock_get_value_by_json_pointer = mocker.patch.object(ApiHelper, 'get_value_by_json_pointer')
+        mock_split_into_parts.assert_called_once_with(input_pointer)
+
+        # Assertions for mock calls based on prefix validity
+        if input_pointer.startswith(("$request.path", "$request.query", "$request.headers")):
+            # Determine which params dict was accessed
+            accessed_params = None
+            if "$request.path" in input_pointer:
+                accessed_params = mock_request_builder.template_params
+            elif "$request.query" in input_pointer:
+                accessed_params = mock_request_builder.query_params
+            elif "$request.headers" in input_pointer:
+                accessed_params = mock_request_builder.header_params
 
-        op = OffsetPagination(input_="invalid_prefix#/offset", metadata_wrapper=mock_metadata_wrapper)
-        result = op._get_initial_request_param_value(mock_request_builder, "invalid_prefix#/offset")
+            mock_get_value_by_json_pointer.assert_called_once_with(accessed_params, input_pointer.split('#')[1])
+        else:
+            mock_get_value_by_json_pointer.assert_not_called()
 
-        mock_split_into_parts.assert_called_once_with("invalid_prefix#/offset")
-        mock_get_value_by_json_pointer.assert_not_called()
-        assert result == 0
+        assert result == expected_value