fix(http-api): prevent infinite loop in rule engine listing

Older versions of the rule engine ignore "offset" and "limit" parameters
and omit the "total_count" field in the response. This caused an infinite
loop in the pagination utility as it kept receiving the same results for
increasing offsets.

Implemented a local slicing workaround in _list_rules when "total_count"
is missing. Updated unit tests to include "total_count" in mock responses
and added a regression test for the unpaginated case.

Author: rnovatorov

src/enapter/http/api/rule_engine/client.py

@@ -64,7 +64,18 @@ async def _list_rules(
         params = {"offset": offset, "limit": limit}
         response = await self._client.get(url, params=params)
         await api.check_error(response)
-        return [Rule.from_dto(dto) for dto in response.json()["rules"]]
+
+        payload = response.json()
+        rules = [Rule.from_dto(dto) for dto in payload["rules"]]
+
+        # NOTE: Some older versions of the rule engine ignore pagination parameters
+        # (offset and limit) and return all rules without a "total_count" field.
+        # In such cases, we slice the list locally to simulate pagination and
+        # prevent an infinite loop in the `paginate` utility.
+        if "total_count" not in payload:
+            return rules[offset : offset + limit]
+
+        return rules
 
     async def get_rule(self, rule_id: str, site_id: str | None = None) -> Rule:
         """Get a single rule."""

tests/unit/test_http/test_api/test_rule_engine/test_client.py

@@ -109,12 +109,17 @@ async def test_list_rules(client, mock_httpx_client):
                 "state": "STOPPED",
                 "script": {"code": "cHJpbnQoJzInKQ==", "runtime_version": "V3"},
             },
-        ]
+        ],
+        "total_count": 2,
     }
     mock_httpx_client.get = AsyncMock(
         side_effect=[
             mock_response,
-            MagicMock(spec=httpx.Response, status_code=200, json=lambda: {"rules": []}),
+            MagicMock(
+                spec=httpx.Response,
+                status_code=200,
+                json=lambda: {"rules": [], "total_count": 2},
+            ),
         ]
     )
 
@@ -154,7 +159,8 @@ async def test_list_rules_pagination(client, mock_httpx_client):
                 "script": {"code": "cHJpbnQoJzEnKQ==", "runtime_version": "V3"},
             }
             for i in range(50)
-        ]
+        ],
+        "total_count": 51,
     }
 
     mock_response_2 = MagicMock(spec=httpx.Response)
@@ -168,12 +174,13 @@ async def test_list_rules_pagination(client, mock_httpx_client):
                 "state": "STARTED",
                 "script": {"code": "cHJpbnQoJzEnKQ==", "runtime_version": "V3"},
             }
-        ]
+        ],
+        "total_count": 51,
     }
 
     mock_response_3 = MagicMock(spec=httpx.Response)
     mock_response_3.status_code = 200
-    mock_response_3.json.return_value = {"rules": []}
+    mock_response_3.json.return_value = {"rules": [], "total_count": 51}
 
     mock_httpx_client.get = AsyncMock(
         side_effect=[mock_response_1, mock_response_2, mock_response_3]
@@ -200,6 +207,43 @@ async def test_list_rules_pagination(client, mock_httpx_client):
     )
 
 
+@pytest.mark.asyncio
+async def test_list_rules_unpaginated_workaround(client, mock_httpx_client):
+    """Test listing rules when the API ignores pagination and total_count is missing."""
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 200
+    # No "total_count" in the payload
+    mock_response.json.return_value = {
+        "rules": [
+            {
+                "id": "rule_1",
+                "slug": "rule-1",
+                "disabled": False,
+                "state": "STARTED",
+                "script": {"code": "cHJpbnQoJzEnKQ==", "runtime_version": "V3"},
+            }
+        ]
+    }
+    mock_httpx_client.get = AsyncMock(return_value=mock_response)
+
+    rules = []
+    # If the workaround is NOT implemented, this will loop forever because paginate()
+    # will keep calling _list_rules with increasing offsets, and _list_rules will
+    # keep returning the same rule_1.
+    async with client.list_rules(site_id="site_123") as stream:
+        async for rule in stream:
+            rules.append(rule)
+            if len(rules) > 10:
+                pytest.fail("Infinite loop detected in list_rules")
+
+    # With the workaround, it should only return the rule once (for offset 0)
+    # and then return an empty list for offset 50 (sliced [50:100]).
+    assert len(rules) == 1
+    assert rules[0].id == "rule_1"
+    # It should have been called twice: once for offset 0, and once for offset 50 (which returns empty)
+    assert mock_httpx_client.get.call_count == 2
+
+
 @pytest.mark.asyncio
 async def test_get_rule(client, mock_httpx_client):
     """Test getting a single rule."""