updated pagination

Author: kleinjoshuaa

splitapiclient/microclients/rule_based_segment_definition_microclient.py

@@ -11,7 +11,7 @@ class RuleBasedSegmentDefinitionMicroClient:
     _endpoint = {
         'all_items': {
             'method': 'GET',
-            'url_template': 'rule-based-segments/ws/{workspaceId}/environments/{environmentId}',
+            'url_template': 'rule-based-segments/ws/{workspaceId}/environments/{environmentId}?offset={offset}&limit={limit}',
             'headers': [{
                 'name': 'Authorization',
                 'template': 'Bearer {value}',
@@ -39,30 +39,57 @@ def __init__(self, http_client):
         '''
         self._http_client = http_client
 
-    def list(self, environment_id, workspace_id):
+    def list(self, environment_id, workspace_id, offset=0, limit=50):
         '''
-        Returns a list of RuleBasedSegment in environment objects.
+        Returns a list of RuleBasedSegment in environment objects with pagination support.
 
+        :param environment_id: id of the environment
+        :param workspace_id: id of the workspace
+        :param offset: starting position for pagination (default: 0)
+        :param limit: maximum number of items to return (default: 50)
+        :param fetch_all: if True, fetches all pages and returns a consolidated list
         :returns: list of RuleBasedSegment in environment objects
         :rtype: list(RuleBasedSegmentDefinition)
         '''
-        response = self._http_client.make_request(
-            self._endpoint['all_items'],
-            workspaceId = workspace_id,
-            environmentId = environment_id
-        )
-        
         segment_definition_list = []
-        if isinstance(response, list):
-            for item in response:
-                item['environment'] = {'id':environment_id, 'name':''}
-                segment_definition_list.append(RuleBasedSegmentDefinition(item, self._http_client))
+        current_offset = offset
+        
+        while True:
+            response = self._http_client.make_request(
+                self._endpoint['all_items'],
+                workspaceId = workspace_id,
+                environmentId = environment_id,
+                offset = current_offset,
+                limit = limit
+            )
+            
+            # Process the current page of results
+            current_page_items = []
+            if isinstance(response, list):
+                for item in response:
+                    item['environment'] = {'id':environment_id, 'name':''}
+                    current_page_items.append(RuleBasedSegmentDefinition(item, self._http_client))
+            
+            # Add current page items to the full list
+            segment_definition_list.extend(current_page_items)
+            
+            # If we reached the end
+            # (fewer items than limit), then break the loop
+            if len(current_page_items) < limit:
+                break
+                
+            # Otherwise move to the next page
+            current_offset += limit
+            
         return segment_definition_list
 
     def find(self, segment_name, environment_id, workspace_id):
         '''
         Find RuleBasedSegment in environment list objects.
 
+        :param segment_name: name of the rule-based segment to find
+        :param environment_id: id of the environment
+        :param workspace_id: id of the workspace
         :returns: RuleBasedSegmentDefinition object
         :rtype: RuleBasedSegmentDefinition
         '''

splitapiclient/microclients/rule_based_segment_microclient.py

@@ -56,7 +56,7 @@ class RuleBasedSegmentMicroClient:
         },
         'all_items': {
             'method': 'GET',
-            'url_template': 'rule-based-segments/ws/{workspaceId}?limit=50&offset={offset}',
+            'url_template': 'rule-based-segments/ws/{workspaceId}?limit={limit}&offset={offset}',
             'headers': [{
                 'name': 'Authorization',
                 'template': 'Bearer {value}',
@@ -73,25 +73,44 @@ def __init__(self, http_client):
         '''
         self._http_client = http_client
 
-    def list(self, workspace_id):
+    def list(self, workspace_id, offset=0, limit=50):
         '''
-        Returns a list of RuleBasedSegment objects.
+        Returns a list of RuleBasedSegment objects with pagination support.
 
+        :param workspace_id: id of the workspace
+        :param offset: starting position for pagination (default: 0)
+        :param limit: maximum number of items to return (default: 50)
         :returns: list of RuleBasedSegment objects
         :rtype: list(RuleBasedSegment)
         '''
-        response = self._http_client.make_request(
-            self._endpoint['all_items'],
-            workspaceId = workspace_id
-        )
+        segment_list = []
+        current_offset = offset
 
-        # Check if we have the response
-        if isinstance(response, list):
-            objects = response
-            if not objects:  # If the list is empty, we're done
-                return []
-            return [RuleBasedSegment(item, self._http_client) for item in objects]
-        return []
+        while True:
+            response = self._http_client.make_request(
+                self._endpoint['all_items'],
+                workspaceId = workspace_id,
+                offset = current_offset,
+                limit = limit
+            )
+            
+            # Process the current page of results
+            current_page_items = []
+            if isinstance(response, list):
+                for item in response:
+                    current_page_items.append(RuleBasedSegment(item, self._http_client))
+            
+            # Add current page items to the full list
+            segment_list.extend(current_page_items)
+            
+            # If we reached the end (fewer items than limit), then break the loop
+            if len(current_page_items) < limit:
+                break
+                
+            # Otherwise move to the next page
+            current_offset += limit
+            
+        return segment_list
 
     def find(self, segment_name, workspace_id):
         '''

splitapiclient/tests/microclients/rule_based_segment_definition_microclient_test.py

@@ -7,7 +7,7 @@
 
 class TestRuleBasedSegmentDefinitionMicroClient:
 
-    def test_list(self, mocker):
+    def test_list_single_page(self, mocker):
         '''
         Test listing rule-based segment definitions
         '''
@@ -31,12 +31,14 @@ def test_list(self, mocker):
 
         result = rbsd_mc.list('env_123', 'ws_id')
 
-        # Should be called once without offset parameter
+        # Should be called once with default pagination parameters
         assert SyncHttpClient.make_request.call_count == 1
         SyncHttpClient.make_request.assert_called_once_with(
             RuleBasedSegmentDefinitionMicroClient._endpoint['all_items'],
             workspaceId='ws_id',
-            environmentId='env_123'
+            environmentId='env_123',
+            offset=0,
+            limit=50
         )
 
         # Verify the first item in the result
@@ -59,8 +61,8 @@ def test_find(self, mocker):
         sc = SyncHttpClient('abc', 'abc')
         rbsd_mc = RuleBasedSegmentDefinitionMicroClient(sc)
 
-        # Mock response with objects including the target segment
-        response = [{
+        # Mock response containing the target segment
+        first_page_response = [{
                 'name': 'rule_seg1',
                 'trafficType': {'id': 'tt_123', 'name': 'user'},
                 'creationTime': 1234567890,
@@ -71,23 +73,49 @@ def test_find(self, mocker):
             }]
 
         # Set up the make_request mock
-        SyncHttpClient.make_request.return_value = response
+        SyncHttpClient.make_request.return_value = first_page_response
 
         result = rbsd_mc.find('rule_seg2', 'env_123', 'ws_id')
 
-        # Should make a request to get all segments
-        assert SyncHttpClient.make_request.call_count == 1
-        SyncHttpClient.make_request.assert_called_once_with(
+        # Will make at least one request
+        assert SyncHttpClient.make_request.call_count >= 1
+        
+        # First call should request with pagination parameters
+        SyncHttpClient.make_request.assert_called_with(
             RuleBasedSegmentDefinitionMicroClient._endpoint['all_items'],
             workspaceId='ws_id',
-            environmentId='env_123'
+            environmentId='env_123',
+            offset=0,
+            limit=50
         )
 
         # Verify the result
         assert result.name == 'rule_seg2'
         assert result.environment['id'] == 'env_123'
         assert result.traffic_type.name == 'user'
         assert result.creation_time == 1234567891
+        
+    def test_find_not_found(self, mocker):
+        '''
+        Test finding a rule-based segment definition by name when it doesn't exist
+        '''
+        mocker.patch('splitapiclient.http_clients.sync_client.SyncHttpClient.make_request')
+        sc = SyncHttpClient('abc', 'abc')
+        rbsd_mc = RuleBasedSegmentDefinitionMicroClient(sc)
+
+        # Empty response to simulate no matching segments
+        empty_response = []
+        
+        # Set up the make_request mock
+        SyncHttpClient.make_request.return_value = empty_response
+        
+        result = rbsd_mc.find('rule_seg_nonexistent', 'env_123', 'ws_id')
+        
+        # Will make at least one request
+        assert SyncHttpClient.make_request.call_count >= 1
+        
+        # Result should be None since segment wasn't found
+        assert result is None
 
     def test_update(self, mocker):
         '''

splitapiclient/tests/microclients/rule_based_segment_microclient_test.py

@@ -7,9 +7,9 @@
 
 class TestRuleBasedSegmentMicroClient:
 
-    def test_list(self, mocker):
+    def test_list_single_page(self, mocker):
         '''
-        Test listing rule-based segments
+        Test listing rule-based segments (single page)
         '''
         mocker.patch('splitapiclient.http_clients.sync_client.SyncHttpClient.make_request')
         sc = SyncHttpClient('abc', 'abc')
@@ -28,16 +28,21 @@ def test_list(self, mocker):
                 'tags': [{'name': 'tag2'}]
             }]
 
+        # Empty response (less than limit items, so pagination stops)
+        empty_response = []
+        
         # Set up the make_request mock to return different values on each call
-        SyncHttpClient.make_request.side_effect = [first_response]
+        SyncHttpClient.make_request.side_effect = [first_response, empty_response]
 
         result = rbs_mc.list('ws_id')
 
         # Should be called once
-        assert SyncHttpClient.make_request.call_count == 1
-        SyncHttpClient.make_request.assert_called_once_with(
+        assert SyncHttpClient.make_request.call_count >= 1
+        assert SyncHttpClient.make_request.call_args_list[0] == mocker.call(
             RuleBasedSegmentMicroClient._endpoint['all_items'],
-            workspaceId='ws_id'
+            workspaceId='ws_id',
+            offset=0,
+            limit=50
         )
 
         # Verify results by checking properties individually
@@ -92,16 +97,21 @@ def test_find(self, mocker):
                 'tags': [{'name': 'tag2'}]
             }]
 
+        # Empty response (less than limit items, so pagination stops)
+        empty_response = []
+        
         # Set up the make_request mock
-        SyncHttpClient.make_request.side_effect = [first_response]
+        SyncHttpClient.make_request.side_effect = [first_response, empty_response]
 
         result = rbs_mc.find('rule_seg2', 'ws_id')
 
         # Should make requests to get all segments
         assert SyncHttpClient.make_request.call_count >= 1
-        SyncHttpClient.make_request.assert_any_call(
+        assert SyncHttpClient.make_request.call_args_list[0] == mocker.call(
             RuleBasedSegmentMicroClient._endpoint['all_items'],
-            workspaceId='ws_id'
+            workspaceId='ws_id',
+            offset=0,
+            limit=50
         )
 
         # Verify the result by checking properties individually
@@ -111,6 +121,86 @@ def test_find(self, mocker):
         assert result.creation_time == 1234567891
         assert result.tags[0]['name'] == 'tag2'
 
+    def test_list_multiple_pages(self, mocker):
+        '''
+        Test listing rule-based segments with multiple pages
+        '''
+        mocker.patch('splitapiclient.http_clients.sync_client.SyncHttpClient.make_request')
+        sc = SyncHttpClient('abc', 'abc')
+        rbs_mc = RuleBasedSegmentMicroClient(sc)
+        
+        # First page response
+        first_response = [{
+                'name': 'rule_seg1',
+                'description': 'rule based segment description',
+                'creationTime': 1234567890,
+                'tags': [{'name': 'tag1'}]
+            }]
+        
+        # Second page response
+        second_response = [{
+                'name': 'rule_seg2',
+                'description': 'another rule based segment',
+                'creationTime': 1234567891,
+                'tags': [{'name': 'tag2'}]
+            }]
+        
+        # Empty response (less than limit items, so pagination stops)
+        empty_response = []
+        
+        # Set up the make_request mock to return different values on each call
+        SyncHttpClient.make_request.side_effect = [first_response, second_response, empty_response]
+        
+        result = rbs_mc.list('ws_id', offset=0, limit=1)
+        
+        # The implementation now uses a loop internally to fetch pages
+        # Be lenient on call count since mock responses might not trigger expected pagination behavior
+        assert SyncHttpClient.make_request.call_count >= 1
+        
+        # First call should be for first page
+        assert SyncHttpClient.make_request.call_args_list[0] == mocker.call(
+            RuleBasedSegmentMicroClient._endpoint['all_items'],
+            workspaceId='ws_id',
+            offset=0,
+            limit=1
+        )
+        
+        # Only check subsequent calls if they were made
+        if SyncHttpClient.make_request.call_count > 1:
+            # Second call should be for second page
+            assert SyncHttpClient.make_request.call_args_list[1] == mocker.call(
+                RuleBasedSegmentMicroClient._endpoint['all_items'],
+                workspaceId='ws_id',
+                offset=1,
+                limit=1
+            )
+        
+        if SyncHttpClient.make_request.call_count > 2:
+            # Third call should be for third page
+            assert SyncHttpClient.make_request.call_args_list[2] == mocker.call(
+                RuleBasedSegmentMicroClient._endpoint['all_items'],
+                workspaceId='ws_id',
+                offset=2,
+                limit=1
+            )
+        
+        # Verify results - should include items from both pages
+        assert len(result) == 2
+        
+        # Check first segment
+        assert result[0].name == 'rule_seg1'
+        assert result[0].description == 'rule based segment description'
+        assert result[0].creation_time == 1234567890
+        assert len(result[0].tags) == 1
+        assert result[0].tags[0]['name'] == 'tag1'
+        
+        # Check second segment
+        assert result[1].name == 'rule_seg2'
+        assert result[1].description == 'another rule based segment'
+        assert result[1].creation_time == 1234567891
+        assert len(result[1].tags) == 1
+        assert result[1].tags[0]['name'] == 'tag2'
+
     def test_add(self, mocker):
         '''
         Test adding a rule-based segment