Merge ~r00ta/maas:refactor-pagination-tests into maas:master

[Jacopo Rota]

refactoring: move pagination tests to ApiCommonTests in order to reuse them

This MP aims to move the pagination tests to the common class for the API tests.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b refactor-pagination-tests lp:~r00ta/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas-tester/5296/console
COMMIT: 4023501e6d37c693f2efe63436929a704cb7042f

review: Needs Fixing

c6440f2... by Jacopo Rota on 2024-04-16

refactoring

[MAAS Lander (maas-lander)]

UNIT TESTS
-b refactor-pagination-tests lp:~r00ta/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas-tester/5297/console
COMMIT: c6440f28ad1b8fe75f9b9bd4f00f354ebc6cc8cb

review: Needs Fixing

[Jack Lloyd-Walters (lloydwaltersj)]

Awesome! very nice way of solving this!

review: Approve

[Jacopo Rota (r00ta)]

jenkins: !test

[MAAS Lander (maas-lander)]

UNIT TESTS
-b refactor-pagination-tests lp:~r00ta/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: c6440f28ad1b8fe75f9b9bd4f00f354ebc6cc8cb

review: Approve

diff --git a/src/tests/maasapiserver/v3/api/base.py b/src/tests/maasapiserver/v3/api/base.py
index aab1883..c692cf9 100644
--- a/src/tests/maasapiserver/v3/api/base.py
+++ b/src/tests/maasapiserver/v3/api/base.py
@@ -1,53 +1,110 @@
 import abc
 from dataclasses import dataclass
+from typing import Callable, Type, TypeVar
 
 from httpx import AsyncClient
 import pytest
 
+from maasapiserver.common.api.models.responses.errors import ErrorBodyResponse
+from maasapiserver.v3.api.models.responses.base import PaginatedResponse
+from maasapiserver.v3.auth.jwt import UserRole
+from tests.maasapiserver.fixtures.db import Fixture
 
-@dataclass
-class EndpointDetails:
-    method: str
-    path: str
+T = TypeVar("T", bound=PaginatedResponse)
 
 
 @dataclass
-class ApiEndpointsRoles:
-    # endpoints that should be accessed without authentication
-    unauthenticated_endpoints: list[EndpointDetails]
+class PaginatedEndpointTestConfig:
+    response_type: Type[T]
+    create_resources_routine: Callable
+    assert_routine: Callable
+    size_parameters: list[int] = range(0, 10)
 
-    # endpoints that can be accessed with user permissions
-    user_endpoints: list[EndpointDetails]
 
-    # endpoints that can be accessed with admin permissions
-    admin_endpoints: list[EndpointDetails]
+@dataclass
+class EndpointDetails:
+    method: str
+    path: str
+    user_role: UserRole
+    # None if the endpoint does not support pagination
+    pagination_config: PaginatedEndpointTestConfig | None = None
 
 
 @pytest.mark.usefixtures("ensuremaasdb")
 @pytest.mark.asyncio
 class ApiCommonTests(abc.ABC):
+    INVALID_PAGINATION_TEST_DATA = [(1, 0), (0, 1), (-1, -1), (1, 1001)]
+
     @abc.abstractmethod
-    def get_endpoints_configuration(self) -> ApiEndpointsRoles:
-        """Retrieve the configuration for testing authentication of the endpoints.
+    def get_endpoints_configuration(self) -> list[EndpointDetails]:
+        """Retrieve the configuration for testing authentication and pagination of the endpoints.
 
         This method should be overridden by every concrete test class to provide
         the specific configuration required for testing authentication.
 
         Returns:
-            ApiEndpointsRoles: The configuration containing roles and associated endpoints.
+            list[EndpointDetails]: The list containing the endpoints configurations.
         """
         pass
 
     def pytest_generate_tests(self, metafunc):
-        if "user_endpoint" in metafunc.fixturenames:
+        # generate dynamically the data for the parametrized tests
+        if metafunc.definition.originalname == "test_user_endpoints_forbidden":
             metafunc.parametrize(
                 "user_endpoint",
-                self.get_endpoints_configuration().user_endpoints,
+                list(
+                    filter(
+                        lambda endpoint: endpoint.user_role == UserRole.USER,
+                        self.get_endpoints_configuration(),
+                    )
+                ),
             )
-        if "admin_endpoint" in metafunc.fixturenames:
+        if (
+            metafunc.definition.originalname
+            == "test_admin_endpoints_forbidden"
+        ):
             metafunc.parametrize(
                 "admin_endpoint",
-                self.get_endpoints_configuration().admin_endpoints,
+                list(
+                    filter(
+                        lambda endpoint: endpoint.user_role == UserRole.ADMIN,
+                        self.get_endpoints_configuration(),
+                    )
+                ),
+            )
+        if (
+            metafunc.definition.originalname
+            == "test_pagination_endpoint_with_invalid_data"
+        ):
+            paginated_endpoints = list(
+                filter(
+                    lambda endpoint: endpoint.pagination_config,
+                    self.get_endpoints_configuration(),
+                )
+            )
+            # for each endpoint
+            metafunc.parametrize(
+                "paginated_endpoint",
+                paginated_endpoints,
+            )
+            # for each test data
+            metafunc.parametrize(
+                "page,size", self.INVALID_PAGINATION_TEST_DATA
+            )
+        if metafunc.definition.originalname == "test_pagination_parameters":
+            paginated_endpoints = list(
+                filter(
+                    lambda endpoint: endpoint.pagination_config,
+                    self.get_endpoints_configuration(),
+                )
+            )
+            metafunc.parametrize(
+                "paginated_endpoint,size",
+                [
+                    (endpoint, size)
+                    for endpoint in paginated_endpoints
+                    for size in endpoint.pagination_config.size_parameters
+                ],
             )
 
     async def test_user_endpoints_forbidden(
@@ -73,3 +130,73 @@ class ApiCommonTests(abc.ABC):
             admin_endpoint.method, admin_endpoint.path
         )
         assert response.status_code == 403
+
+    async def test_pagination_endpoint_with_invalid_data(
+        self,
+        paginated_endpoint: EndpointDetails,
+        page: int,
+        size: int,
+        authenticated_user_api_client_v3: AsyncClient,
+    ) -> None:
+        response = await authenticated_user_api_client_v3.request(
+            paginated_endpoint.method,
+            f"{paginated_endpoint.path}?page={page}&size={size}",
+        )
+        assert response.status_code == 422
+
+        error_response = ErrorBodyResponse(**response.json())
+        assert error_response.kind == "Error"
+        assert error_response.code == 422
+
+    async def test_pagination_parameters(
+        self,
+        paginated_endpoint: EndpointDetails,
+        size: int,
+        api_client: AsyncClient,
+        authenticated_user_api_client_v3: AsyncClient,
+        authenticated_admin_api_client_v3: AsyncClient,
+        fixture: Fixture,
+    ) -> None:
+        # set the required client according to the endpoint requirements
+        if paginated_endpoint.user_role == UserRole.USER:
+            api_client = authenticated_user_api_client_v3
+        if paginated_endpoint.user_role == UserRole.ADMIN:
+            api_client = authenticated_admin_api_client_v3
+
+        created_resources = await paginated_endpoint.pagination_config.create_resources_routine(
+            fixture, size
+        )
+
+        response = await api_client.request(
+            paginated_endpoint.method, paginated_endpoint.path
+        )
+        assert response.status_code == 200
+
+        typed_response = paginated_endpoint.pagination_config.response_type(
+            **response.json()
+        )
+        assert typed_response.total == size
+        assert len(typed_response.items) == size
+
+        for resource in created_resources:
+            paginated_endpoint.pagination_config.assert_routine(
+                resource, typed_response
+            )
+
+        for page in range(1, size // 2):
+            response = await api_client.request(
+                paginated_endpoint.method,
+                f"{paginated_endpoint.path}?page={page}&size=2",
+            )
+            assert response.status_code == 200
+            typed_response = (
+                paginated_endpoint.pagination_config.response_type(
+                    **response.json()
+                )
+            )
+            assert typed_response.total == size
+            assert (
+                len(typed_response.items) == 2
+                if page != size // 2
+                else (size % 2 or 2)
+            )
diff --git a/src/tests/maasapiserver/v3/api/test_machines.py b/src/tests/maasapiserver/v3/api/test_machines.py
index 05538ff..2566aba 100644
--- a/src/tests/maasapiserver/v3/api/test_machines.py
+++ b/src/tests/maasapiserver/v3/api/test_machines.py
@@ -1,8 +1,5 @@
-from httpx import AsyncClient
-import pytest
-
-from maasapiserver.common.api.models.responses.errors import ErrorBodyResponse
 from maasapiserver.v3.api.models.responses.machines import MachinesListResponse
+from maasapiserver.v3.auth.jwt import UserRole
 from maasapiserver.v3.constants import EXTERNAL_V3_API_PREFIX
 from maasapiserver.v3.models.machines import Machine
 from tests.fixtures.factories.bmc import create_test_bmc
@@ -11,99 +8,51 @@ from tests.fixtures.factories.user import create_test_user
 from tests.maasapiserver.fixtures.db import Fixture
 from tests.maasapiserver.v3.api.base import (
     ApiCommonTests,
-    ApiEndpointsRoles,
     EndpointDetails,
+    PaginatedEndpointTestConfig,
 )
 
 
[e-mail]("ensuremaasdb")
[e-mail]
 class TestMachinesApi(ApiCommonTests):
-    def get_endpoints_configuration(self) -> ApiEndpointsRoles:
-        return ApiEndpointsRoles(
-            unauthenticated_endpoints=[],
-            user_endpoints=[
-                EndpointDetails(
-                    method="GET",
-                    path="/api/v3/machines",
-                ),
-            ],
-            admin_endpoints=[],
-        )
-
-    def _assert_machine_in_list(
-        self, machine: Machine, machines_response: MachinesListResponse
-    ) -> None:
-        machine_response = next(
-            filter(
-                lambda machine_response: machine.id == machine_response.id,
-                machines_response.items,
-            )
-        )
-        assert machine.id == machine_response.id
-        assert (
-            machine.to_response(f"{EXTERNAL_V3_API_PREFIX}/machines")
-            == machine_response
-        )
-
-    @pytest.mark.parametrize("machines_size", range(0, 10))
-    async def test_list_parameters_200(
-        self,
-        authenticated_user_api_client_v3: AsyncClient,
-        fixture: Fixture,
-        machines_size: int,
-    ) -> None:
-        bmc = await create_test_bmc(fixture)
-        user = await create_test_user(fixture)
-        created_machines = [
-            (
-                await create_test_machine(
-                    fixture, description=str(i), bmc=bmc, user=user
+    def get_endpoints_configuration(self) -> list[EndpointDetails]:
+        def _assert_machine_in_list(
+            machine: Machine, machines_response: MachinesListResponse
+        ) -> None:
+            machine_response = next(
+                filter(
+                    lambda machine_response: machine.id == machine_response.id,
+                    machines_response.items,
                 )
             )
-            for i in range(0, machines_size)
-        ]
-
-        response = await authenticated_user_api_client_v3.get(
-            "/api/v3/machines"
-        )
-        assert response.status_code == 200
-
-        machines_response = MachinesListResponse(**response.json())
-        assert machines_response.kind == "MachinesList"
-        assert machines_response.total == machines_size
-        assert len(machines_response.items) == machines_size
-        for machine in created_machines:
-            self._assert_machine_in_list(machine, machines_response)
-
-        for page in range(1, machines_size // 2):
-            response = await authenticated_user_api_client_v3.get(
-                f"/api/v3/machines?page={page}&size=2"
-            )
-            assert response.status_code == 200
-            machines_response = MachinesListResponse(**response.json())
-            assert machines_response.kind == "MachinesList"
-            assert machines_response.total == machines_size
+            assert machine.id == machine_response.id
             assert (
-                len(machines_response.items) == 2
-                if page != machines_size // 2
-                else (machines_size % 2 or 2)
+                machine.to_response(f"{EXTERNAL_V3_API_PREFIX}/machines")
+                == machine_response
             )
 
-    @pytest.mark.parametrize(
-        "page,size", [(1, 0), (0, 1), (-1, -1), (1, 1001)]
-    )
-    async def test_list_422(
-        self,
-        page: int,
-        size: int,
-        authenticated_user_api_client_v3: AsyncClient,
-    ) -> None:
-        response = await authenticated_user_api_client_v3.get(
-            f"/api/v3/machines?page={page}&size={size}"
-        )
-        assert response.status_code == 422
-
-        error_response = ErrorBodyResponse(**response.json())
-        assert error_response.kind == "Error"
-        assert error_response.code == 422
+        async def create_pagination_test_resources(
+            fixture: Fixture, size: int
+        ) -> list[Machine]:
+            bmc = await create_test_bmc(fixture)
+            user = await create_test_user(fixture)
+            return [
+                (
+                    await create_test_machine(
+                        fixture, description=str(i), bmc=bmc, user=user
+                    )
+                )
+                for i in range(0, size)
+            ]
+
+        return [
+            EndpointDetails(
+                method="GET",
+                path="/api/v3/machines",
+                user_role=UserRole.USER,
+                pagination_config=PaginatedEndpointTestConfig(
+                    response_type=MachinesListResponse,
+                    assert_routine=_assert_machine_in_list,
+                    create_resources_routine=create_pagination_test_resources,
+                ),
+            ),
+        ]
diff --git a/src/tests/maasapiserver/v3/api/test_resource_pools.py b/src/tests/maasapiserver/v3/api/test_resource_pools.py
index 95ff9f2..048fbda 100644
--- a/src/tests/maasapiserver/v3/api/test_resource_pools.py
+++ b/src/tests/maasapiserver/v3/api/test_resource_pools.py
@@ -13,6 +13,7 @@ from maasapiserver.v3.api.models.responses.resource_pools import (
     ResourcePoolResponse,
     ResourcePoolsListResponse,
 )
+from maasapiserver.v3.auth.jwt import UserRole
 from maasapiserver.v3.constants import EXTERNAL_V3_API_PREFIX
 from maasapiserver.v3.models.resource_pools import ResourcePool
 from tests.fixtures.factories.resource_pools import (
@@ -22,113 +23,69 @@ from tests.fixtures.factories.resource_pools import (
 from tests.maasapiserver.fixtures.db import Fixture
 from tests.maasapiserver.v3.api.base import (
     ApiCommonTests,
-    ApiEndpointsRoles,
     EndpointDetails,
+    PaginatedEndpointTestConfig,
 )
 
 
 class TestResourcePoolApi(ApiCommonTests):
-    def get_endpoints_configuration(self) -> ApiEndpointsRoles:
-        return ApiEndpointsRoles(
-            unauthenticated_endpoints=[],
-            user_endpoints=[
-                EndpointDetails(
-                    method="GET",
-                    path="/api/v3/resource_pools",
-                ),
-                EndpointDetails(
-                    method="GET",
-                    path="/api/v3/resource_pools/1",
-                ),
-            ],
-            admin_endpoints=[
-                EndpointDetails(
-                    method="POST",
-                    path="/api/v3/resource_pools",
-                ),
-                EndpointDetails(
-                    method="PATCH", path="/api/v3/resource_pools/1"
-                ),
-            ],
-        )
-
-    def _assert_resource_pools_in_list(
-        self,
-        resource_pools: ResourcePool,
-        resource_pools_response: ResourcePoolsListResponse,
-    ) -> None:
-        resource_pools_response = next(
-            filter(
-                lambda resource_pools_response: resource_pools.id
-                == resource_pools_response.id,
-                resource_pools_response.items,
+    def get_endpoints_configuration(self) -> list[EndpointDetails]:
+        def _assert_resource_pools_in_list(
+            resource_pools: ResourcePool,
+            resource_pools_response: ResourcePoolsListResponse,
+        ) -> None:
+            resource_pools_response = next(
+                filter(
+                    lambda resource_pools_response: resource_pools.id
+                    == resource_pools_response.id,
+                    resource_pools_response.items,
+                )
             )
-        )
-        assert resource_pools.id == resource_pools_response.id
-        assert resource_pools.name == resource_pools_response.name
-        assert (
-            resource_pools.description == resource_pools_response.description
-        )
-
-    @pytest.mark.parametrize("resource_pools_size", range(1, 3))
-    async def test_list(
-        self,
-        resource_pools_size: int,
-        authenticated_user_api_client_v3: AsyncClient,
-        fixture: Fixture,
-    ) -> None:
-        created_resource_pools = await create_n_test_resource_pools(
-            fixture, size=resource_pools_size
-        )
-        response = await authenticated_user_api_client_v3.get(
-            "/api/v3/resource_pools"
-        )
-        assert response.status_code == 200
-
-        resource_pools_response = ResourcePoolsListResponse(**response.json())
-        assert resource_pools_response.kind == "ResourcePoolList"
-        # Increment as the default resource pool is included in the count.
-        assert resource_pools_response.total == resource_pools_size + 1
-        assert len(resource_pools_response.items) == resource_pools_size + 1
-        for resource_pools in created_resource_pools:
-            self._assert_resource_pools_in_list(
-                resource_pools, resource_pools_response
+            assert resource_pools.id == resource_pools_response.id
+            assert resource_pools.name == resource_pools_response.name
+            assert (
+                resource_pools.description
+                == resource_pools_response.description
             )
 
-    async def test_parametrised_list(
-        self, authenticated_user_api_client_v3: AsyncClient, fixture: Fixture
-    ) -> None:
-        await create_n_test_resource_pools(fixture, size=9)
-
-        for page in range(1, 6):
-            response = await authenticated_user_api_client_v3.get(
-                f"/api/v3/resource_pools?page={page}&size=2"
-            )
-            assert response.status_code == 200
-            resource_pools_response = ResourcePoolsListResponse(
-                **response.json()
-            )
-            assert resource_pools_response.kind == "ResourcePoolList"
-            assert resource_pools_response.total == 10
-            assert len(resource_pools_response.items) == 2
-
-    @pytest.mark.parametrize(
-        "page,size", [(1, 0), (0, 1), (-1, -1), (1, 1001)]
-    )
-    async def test_invalid_list(
-        self,
-        page: int,
-        size: int,
-        authenticated_user_api_client_v3: AsyncClient,
-    ) -> None:
-        response = await authenticated_user_api_client_v3.get(
-            f"/api/v3/resource_pools?page={page}&size={size}"
-        )
-        assert response.status_code == 422
+        async def create_pagination_test_resources(
+            fixture: Fixture, size: int
+        ) -> list[ResourcePool]:
+            if size > 1:
+                # remove one because we have to consider the default resource pool
+                return await create_n_test_resource_pools(
+                    fixture, size=size - 1
+                )
+            return []
 
-        error_response = ErrorBodyResponse(**response.json())
-        assert error_response.kind == "Error"
-        assert error_response.code == 422
+        return [
+            EndpointDetails(
+                method="GET",
+                path="/api/v3/resource_pools",
+                user_role=UserRole.USER,
+                pagination_config=PaginatedEndpointTestConfig(
+                    response_type=ResourcePoolsListResponse,
+                    assert_routine=_assert_resource_pools_in_list,
+                    create_resources_routine=create_pagination_test_resources,
+                    size_parameters=list(range(1, 10)),
+                ),
+            ),
+            EndpointDetails(
+                method="GET",
+                path="/api/v3/resource_pools/1",
+                user_role=UserRole.USER,
+            ),
+            EndpointDetails(
+                method="POST",
+                path="/api/v3/resource_pools",
+                user_role=UserRole.ADMIN,
+            ),
+            EndpointDetails(
+                method="PATCH",
+                path="/api/v3/resource_pools/1",
+                user_role=UserRole.ADMIN,
+            ),
+        ]
 
     async def test_get(
         self, authenticated_user_api_client_v3: AsyncClient, fixture: Fixture
diff --git a/src/tests/maasapiserver/v3/api/test_zones.py b/src/tests/maasapiserver/v3/api/test_zones.py
index 63c3342..827d8bf 100644
--- a/src/tests/maasapiserver/v3/api/test_zones.py
+++ b/src/tests/maasapiserver/v3/api/test_zones.py
@@ -14,116 +14,72 @@ from maasapiserver.v3.api.models.responses.zones import (
     ZoneResponse,
     ZonesListResponse,
 )
+from maasapiserver.v3.auth.jwt import UserRole
 from maasapiserver.v3.constants import EXTERNAL_V3_API_PREFIX
 from maasapiserver.v3.models.zones import Zone
 from tests.fixtures.factories.zone import create_test_zone
 from tests.maasapiserver.fixtures.db import Fixture
 from tests.maasapiserver.v3.api.base import (
     ApiCommonTests,
-    ApiEndpointsRoles,
     EndpointDetails,
+    PaginatedEndpointTestConfig,
 )
 
 
[e-mail]("ensuremaasdb")
[e-mail]
 class TestZonesApi(ApiCommonTests):
-    def get_endpoints_configuration(self) -> ApiEndpointsRoles:
-        return ApiEndpointsRoles(
-            unauthenticated_endpoints=[],
-            user_endpoints=[
-                EndpointDetails(
-                    method="GET",
-                    path="/api/v3/zones",
-                ),
-                EndpointDetails(
-                    method="GET",
-                    path="/api/v3/zones/1",
-                ),
-            ],
-            admin_endpoints=[
-                EndpointDetails(
-                    method="POST",
-                    path="/api/v3/zones",
-                ),
-                EndpointDetails(method="DELETE", path="/api/v3/zones/1"),
-            ],
-        )
-
-    def _assert_zone_in_list(
-        self, zone: Zone, zones_response: ZonesListResponse
-    ) -> None:
-        zone_response = next(
-            filter(
-                lambda zone_response: zone.id == zone_response.id,
-                zones_response.items,
-            )
-        )
-        assert zone.id == zone_response.id
-        assert zone.name == zone_response.name
-        assert zone.description == zone_response.description
-
-    # GET /zones
-    # We don't have a test that checks for empty list because it's impossible: there is always at least one "default" zone
-    # created at startup by the migration scripts.
-    @pytest.mark.parametrize("zones_size", range(1, 3))
-    async def test_list_default_200(
-        self,
-        zones_size: int,
-        authenticated_user_api_client_v3: AsyncClient,
-        fixture: Fixture,
-    ) -> None:
-        # The "default" zone with id=1 is created at startup with the migrations. By consequence, we create zones_size-1 zones
-        # here.
-        created_zones = [
-            (await create_test_zone(fixture, name=str(i), description=str(i)))
-            for i in range(0, zones_size - 1)
-        ]
-        response = await authenticated_user_api_client_v3.get("/api/v3/zones")
-        assert response.status_code == 200
-
-        zones_response = ZonesListResponse(**response.json())
-        assert zones_response.kind == "ZonesList"
-        assert zones_response.total == zones_size
-        assert len(zones_response.items) == zones_size
-        for zone in created_zones:
-            self._assert_zone_in_list(zone, zones_response)
-
-    async def test_list_parameters_200(
-        self, authenticated_user_api_client_v3: AsyncClient, fixture: Fixture
-    ) -> None:
-        # The "default" zone with id=1 is created at startup with the migrations. By consequence, we create zones_size-1 zones
-        # here.
-        for i in range(0, 9):
-            await create_test_zone(fixture, name=str(i), description=str(i))
-
-        for page in range(1, 6):
-            response = await authenticated_user_api_client_v3.get(
-                f"/api/v3/zones?page={page}&size=2"
+    def get_endpoints_configuration(self) -> list[EndpointDetails]:
+        def _assert_zone_in_list(
+            zone: Zone, zones_response: ZonesListResponse
+        ) -> None:
+            zone_response = next(
+                filter(
+                    lambda zone_response: zone.id == zone_response.id,
+                    zones_response.items,
+                )
             )
-            assert response.status_code == 200
-            zones_response = ZonesListResponse(**response.json())
-            assert zones_response.kind == "ZonesList"
-            assert zones_response.total == 10
-            assert len(zones_response.items) == 2
+            assert zone.id == zone_response.id
+            assert zone.name == zone_response.name
+            assert zone.description == zone_response.description
 
-    @pytest.mark.parametrize(
-        "page,size", [(1, 0), (0, 1), (-1, -1), (1, 1001)]
-    )
-    async def test_list_422(
-        self,
-        page: int,
-        size: int,
-        authenticated_user_api_client_v3: AsyncClient,
-    ) -> None:
-        response = await authenticated_user_api_client_v3.get(
-            f"/api/v3/zones?page={page}&size={size}"
-        )
-        assert response.status_code == 422
+        async def create_pagination_test_resources(
+            fixture: Fixture, size: int
+        ) -> list[Zone]:
+            if size > 1:
+                # remove one because we have to consider the default zone
+                return [
+                    (
+                        await create_test_zone(
+                            fixture, name=str(i), description=str(i)
+                        )
+                    )
+                    for i in range(0, size - 1)
+                ]
+            return []
 
-        error_response = ErrorBodyResponse(**response.json())
-        assert error_response.kind == "Error"
-        assert error_response.code == 422
+        return [
+            EndpointDetails(
+                method="GET",
+                path="/api/v3/zones",
+                user_role=UserRole.USER,
+                pagination_config=PaginatedEndpointTestConfig(
+                    response_type=ZonesListResponse,
+                    assert_routine=_assert_zone_in_list,
+                    create_resources_routine=create_pagination_test_resources,
+                    size_parameters=list(range(1, 10)),
+                ),
+            ),
+            EndpointDetails(
+                method="GET", path="/api/v3/zones/1", user_role=UserRole.USER
+            ),
+            EndpointDetails(
+                method="POST", path="/api/v3/zones", user_role=UserRole.ADMIN
+            ),
+            EndpointDetails(
+                method="DELETE",
+                path="/api/v3/zones/1",
+                user_role=UserRole.ADMIN,
+            ),
+        ]
 
     # GET /zones/{zone_id}
     async def test_get_default(