DEVEXP-733: Refactor Token Paginator

Author: asein-sinch

sinch/core/pagination.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from collections import namedtuple
 from typing import Generic
 from sinch.core.types import BM
 
@@ -81,11 +80,6 @@ def content(self):
     def iterator(self):
         pass
 
-    # TODO: Make get_content() method abstract in Parent class as we implement in the other domains:
-    #  - Refactor pydantic models in other domains to have a content property.
-    def get_content(self):
-        pass
-
     @abstractmethod
     def next_page(self):
         pass
@@ -172,44 +166,6 @@ def iterator(self):
                 break
             paginator = next_page_instance
 
-    def get_content(self):
-        """Returns structured pagination metadata along with the first page's content (sync)."""
-        next_page_instance = self.next_page()
-        return self._get_content(next_page_instance, sync=True)
-
-    def _get_content(self, next_page_instance, sync=True):
-        """Core logic for `get_content()`, shared between sync and async versions."""
-        PagedListResponse = namedtuple(
-            "PagedResponse", ["result", "has_next_page", "next_page_info", "next_page"]
-        )
-
-        next_page_info = {
-            "result": self.content(),
-            "result.next": (
-                self.content() + (next_page_instance.content() if next_page_instance else [])
-            ),
-            "has_next_page": self.has_next_page,
-            "has_next_page.next": bool(next_page_instance and next_page_instance.has_next_page),
-        }
-
-        next_page_wrapper = self._get_next_page_wrapper(next_page_instance, sync)
-
-        return PagedListResponse(
-            result=self.content(),
-            has_next_page=self.has_next_page,
-            next_page_info=next_page_info,
-            next_page=next_page_wrapper
-        )
-
-    def _get_next_page_wrapper(self, next_page_instance, sync):
-        """Returns a function for fetching the next page."""
-        if sync:
-            return lambda: next_page_instance.get_content() if next_page_instance else None
-        else:
-            async def async_next_page_wrapper():
-                return await next_page_instance.get_content() if next_page_instance else None
-            return async_next_page_wrapper
-
     def _calculate_next_page(self):
         self.has_next_page = bool(getattr(self.result, "next_page_token", None))
 
@@ -244,11 +200,6 @@ async def iterator(self):
                 break
             paginator = next_page_instance
 
-    async def get_content(self):
-        """Returns structured pagination metadata"""
-        next_page_instance = await self.next_page()
-        return self._get_content(next_page_instance, sync=False)
-
     @classmethod
     async def _initialize(cls, sinch, endpoint):
         result = await sinch.configuration.transport.request(endpoint)

tests/conftest.py

@@ -186,30 +186,6 @@ def token_based_pagination_request_data():
     )
 
 
-@pytest.fixture
-def first_token_based_pagination_response():
-    return TokenBasedPaginationResponse(
-        pig_dogs=["Walaszek", "Połać"],
-        next_page_token="za30%wsze"
-    )
-
-
-@pytest.fixture
-def second_token_based_pagination_response():
-    return TokenBasedPaginationResponse(
-        pig_dogs=["Bartosz", "Piotr"],
-        next_page_token="ka#556"
-    )
-
-
-@pytest.fixture
-def third_token_based_pagination_response():
-    return TokenBasedPaginationResponse(
-        pig_dogs=["Madrid", "Spain"],
-        next_page_token=""
-    )
-
-
 @pytest.fixture
 def int_based_pagination_request_data():
     return IntBasedPaginationRequest(

tests/e2e/numbers/features/steps/numbers.steps.py

@@ -165,13 +165,13 @@ def step_when_list_phone_numbers(context):
         number_type='LOCAL'
     )
     # Get the first page
-    context.response = response.get_content()
+    context.response = response.content()
 
 
 @then('the response contains "{count}" phone numbers')
 def step_then_response_contains_x_phone_numbers(context, count):
-    assert len(context.response.result) == int(count), \
-        f'Expected {count}, got {len(context.response.data)}'
+    assert len(context.response) == int(count), \
+        f'Expected {count}, got {len(context.response)}'
 
 @when("I send a request to list all the phone numbers")
 def step_when_list_all_phone_numbers(context):

tests/unit/test_pagination.py

@@ -136,170 +136,105 @@ async def test_page_int_iterator_async_using_auto_pagination(
     assert not int_based_paginator.result.pig_dogs
 
 
+# Helper function to initialize token paginators
+def initialize_token_paginator(endpoint_mock, request_data, responses, is_async=False):
+    client = AsyncMock() if is_async else Mock()
+    client.configuration.transport.request.side_effect = responses
+
+    endpoint_mock.request_data = request_data
+
+    if is_async:
+        return AsyncTokenBasedPaginator._initialize(sinch=client, endpoint=endpoint_mock)
+    return TokenBasedPaginator(sinch=client, endpoint=endpoint_mock)
+
+EXPECTED_PHONE_NUMBERS = [
+    '+12345678901', '+12345678902', '+12345678903', '+12345678904', '+12345678905'
+]
+
+
 def test_page_token_iterator_sync_using_manual_pagination(
-    token_based_pagination_request_data,
-    first_token_based_pagination_response,
-    second_token_based_pagination_response,
-    third_token_based_pagination_response
+        token_based_pagination_request_data,
+        mock_pagination_active_number_responses
 ):
-    endpoint = Mock()
-    endpoint.request_data = token_based_pagination_request_data
-    sinch_client = Mock()
-
-    sinch_client.configuration.transport.request.side_effect = [
-        first_token_based_pagination_response,
-        second_token_based_pagination_response,
-        third_token_based_pagination_response
-    ]
-    token_based_paginator = TokenBasedPaginator._initialize(
-        sinch=sinch_client,
-        endpoint=endpoint
+    token_based_paginator = initialize_token_paginator(
+        endpoint_mock=Mock(),
+        request_data=token_based_pagination_request_data,
+        responses=mock_pagination_active_number_responses
     )
-    assert token_based_paginator
+    assert token_based_paginator is not None
 
     page_counter = 1
+    active_numbers_list = [num.phone_number for num in token_based_paginator.content()]
+
     while token_based_paginator.has_next_page:
         token_based_paginator = token_based_paginator.next_page()
         page_counter += 1
         assert isinstance(token_based_paginator, TokenBasedPaginator)
+        active_numbers_list.extend(num.phone_number for num in token_based_paginator.content())
 
     assert page_counter == 3
+    assert active_numbers_list == EXPECTED_PHONE_NUMBERS
 
 
-def test_page_token_iterator_numbers_sync_using_auto_pagination_expects_iter(token_based_pagination_request_data,
-                                                                             mock_pagination_active_number_responses):
-    """ Test that the pagination iterates correctly through multiple items. """
-
-    sinch_client = Mock()
-    sinch_client.configuration.transport.request.side_effect = mock_pagination_active_number_responses
-    endpoint = Mock()
-    endpoint.request_data = token_based_pagination_request_data
-
-    token_based_paginator = TokenBasedPaginator(
-        sinch=sinch_client,
-        endpoint=endpoint
-    )
-    assert token_based_paginator
-
-    number_counter = 0
-    for _ in token_based_paginator.iterator():
-        number_counter += 1
-    assert number_counter == 5
-
-
-def test_page_token_iterator_sync_using_list_expects_correct_metadata(token_based_pagination_request_data,
-                                                                      mock_pagination_active_number_responses):
-    """Test `list()` correctly structures pagination metadata with proper `.content` handling."""
-
-    endpoint = Mock()
-    endpoint.request_data = token_based_pagination_request_data
-    sinch_client = Mock()
-
-    sinch_client.configuration.transport.request.side_effect = mock_pagination_active_number_responses
-
-    token_based_paginator = TokenBasedPaginator(
-        sinch=sinch_client,
-        endpoint=endpoint
+def test_page_token_iterator_sync_using_auto_pagination(
+        token_based_pagination_request_data,
+        mock_pagination_active_number_responses
+):
+    token_based_paginator = initialize_token_paginator(
+        endpoint_mock=Mock(),
+        request_data=token_based_pagination_request_data,
+        responses=mock_pagination_active_number_responses
     )
-    assert token_based_paginator
+    assert token_based_paginator is not None
 
-    list_response = token_based_paginator.get_content()
+    active_numbers_list = [num.phone_number for num in token_based_paginator.iterator()]
 
-    page_counter = 0
-    reached_last_page = False
-
-    while not reached_last_page:
-        page_counter += 1
-        if list_response.has_next_page:
-            list_response = list_response.next_page()
-        else:
-            reached_last_page = True
-
-    assert page_counter == 3
+    assert len(active_numbers_list) == len(EXPECTED_PHONE_NUMBERS)
+    assert active_numbers_list == EXPECTED_PHONE_NUMBERS
 
 
+@pytest.mark.asyncio
 async def test_page_token_iterator_async_using_manual_pagination(
     token_based_pagination_request_data,
-    first_token_based_pagination_response,
-    second_token_based_pagination_response,
-    third_token_based_pagination_response
+    mock_pagination_active_number_responses
 ):
-    endpoint = Mock()
-    endpoint.request_data = token_based_pagination_request_data
-    sinch_client = AsyncMock()
-
-    sinch_client.configuration.transport.request.side_effect = [
-        first_token_based_pagination_response,
-        second_token_based_pagination_response,
-        third_token_based_pagination_response
-    ]
-    token_based_paginator = await AsyncTokenBasedPaginator._initialize(
-        sinch=sinch_client,
-        endpoint=endpoint
+    async_token_based_paginator = await initialize_token_paginator(
+        endpoint_mock=AsyncMock(),
+        request_data=token_based_pagination_request_data,
+        responses=mock_pagination_active_number_responses,
+        is_async=True
     )
-    assert token_based_paginator
+    assert async_token_based_paginator is not None
 
+    active_numbers_list = [num.phone_number for num in async_token_based_paginator.content()]
     page_counter = 1
-    while token_based_paginator.has_next_page:
-        token_based_paginator = await token_based_paginator.next_page()
+
+    while async_token_based_paginator.has_next_page:
+        async_token_based_paginator = await async_token_based_paginator.next_page()
         page_counter += 1
-        assert isinstance(token_based_paginator, AsyncTokenBasedPaginator)
+        assert isinstance(async_token_based_paginator, AsyncTokenBasedPaginator)
+        active_numbers_list.extend(num.phone_number for num in async_token_based_paginator.content())
 
     assert page_counter == 3
+    assert active_numbers_list == EXPECTED_PHONE_NUMBERS
 
 
-async def test_page_token_iterator_async_using_list_expects_correct_metadata(
-    token_based_pagination_request_data,
-    mock_pagination_active_number_responses
-):
-    """Test async`list()` correctly structures pagination metadata with proper `.content` handling."""
-
-    endpoint = Mock()
-    endpoint.request_data = token_based_pagination_request_data
-    sinch_client = AsyncMock()
-
-    sinch_client.configuration.transport.request.side_effect = mock_pagination_active_number_responses
-
-    async_token_based_paginator = await AsyncTokenBasedPaginator._initialize(
-        sinch=sinch_client,
-        endpoint=endpoint
-    )
-    assert async_token_based_paginator
-
-    list_response = await async_token_based_paginator.get_content()
-
-    page_counter = 0
-    reached_last_page = False
-
-    while not reached_last_page:
-        if list_response.has_next_page:
-            list_response = await list_response.next_page()
-            page_counter += 1
-        else:
-            reached_last_page = True
-
-    assert page_counter == 2
-
-
+@pytest.mark.asyncio
 async def test_page_token_iterator_numbers_async_using_auto_pagination_expects_iter(
     token_based_pagination_request_data,
     mock_pagination_active_number_responses
 ):
-    """Test that the async pagination iterates correctly through multiple items."""
-
-    sinch_client = AsyncMock()
-    sinch_client.configuration.transport.request.side_effect = mock_pagination_active_number_responses
-    endpoint = Mock()
-    endpoint.request_data = token_based_pagination_request_data
-
-    async_token_based_paginator = await AsyncTokenBasedPaginator._initialize(
-        sinch=sinch_client,
-        endpoint=endpoint
+    async_token_based_paginator = await initialize_token_paginator(
+        endpoint_mock=AsyncMock(),
+        request_data=token_based_pagination_request_data,
+        responses=mock_pagination_active_number_responses,
+        is_async=True
     )
-    assert async_token_based_paginator
+    assert async_token_based_paginator is not None
 
-    number_counter = 0
-    async for _ in async_token_based_paginator.iterator():
-        number_counter += 1
+    active_numbers_list = [
+        num.phone_number async for num in async_token_based_paginator.iterator()
+    ]
 
-    assert number_counter == 5
+    assert len(active_numbers_list) == len(EXPECTED_PHONE_NUMBERS)
+    assert active_numbers_list == EXPECTED_PHONE_NUMBERS