Feat/tr/pagination

src/stapi_fastapi/backends/root_backend.py

@@ -13,9 +13,12 @@
 
 
 class RootBackend[T: OrderStatusPayload, U: OrderStatus](Protocol):  # pragma: nocover
-    async def get_orders(self, request: Request) -> ResultE[OrderCollection]:
+    async def get_orders(
+        self, request: Request, next: str | None, limit: int
+    ) -> ResultE[tuple[OrderCollection, str]]:
         """
-        Return a list of existing orders.
+        Return a list of existing orders and pagination token if applicable
+        No pagination will return empty string for token
         """
         ...
 

src/stapi_fastapi/routers/root_router.py

@@ -159,10 +159,12 @@ def get_products(self, request: Request) -> ProductsCollection:
             ],
         )
 
-    async def get_orders(self, request: Request) -> OrderCollection:
-        match await self.backend.get_orders(request):
-            case Success(orders):
-                for order in orders:
+    async def get_orders(
+        self, request: Request, next: str | None = None, limit: int = 10
+    ) -> OrderCollection:
+        match await self.backend.get_orders(request, next, limit):
+            case Success((collections, token)):
+                for order in collections:
                     order.links.append(
                         Link(
                             href=str(
@@ -174,13 +176,21 @@ async def get_orders(self, request: Request) -> OrderCollection:
                             type=TYPE_JSON,
                         )
                     )
-                return orders
+                if token:  # pagination link if backend returns token
+                    updated_url = request.url.include_query_params(next=token)
+                    collections.links.append(
+                        Link(href=str(updated_url), rel="next", type=TYPE_JSON)
+                    )
+                return collections
             case Failure(e):
-                logging.exception("An error occurred while retrieving orders", e)
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail="Error finding Orders",
-                )
+                logging.exception(f"An error occurred while retrieving orders: {e}")
+                if isinstance(e, IndexError):
+                    raise NotFoundException(detail="Error finding pagination token")
+                else:
+                    raise HTTPException(
+                        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        detail="Error finding Orders",
+                    )
             case _:
                 raise AssertionError("Expected code to be unreachable")
 

tests/application.py

@@ -43,11 +43,40 @@ class MockRootBackend(RootBackend):
     def __init__(self, orders: InMemoryOrderDB) -> None:
         self._orders_db: InMemoryOrderDB = orders
 
-    async def get_orders(self, request: Request) -> ResultE[OrderCollection]:
+    async def get_orders(
+        self, request: Request, next: str | None, limit: int
+    ) -> ResultE[tuple[OrderCollection, str]]:
         """
-        Show all orders.
+        Return orders from backend.  Handle pagination/limit if applicable
         """
-        return Success(OrderCollection(features=list(self._orders_db._orders.values())))
+        try:
+            start = 0
+            if limit > 100:
+                limit = 100
+
+            order_ids = [*self._orders_db._orders.keys()]
+            if not order_ids:  # no data in db
+                return Success(
+                    (
+                        OrderCollection(
+                            features=list(self._orders_db._orders.values())
+                        ),
+                        "",
+                    )
+                )
+
+            if next:
+                start = [i for i, x in enumerate(order_ids) if x == next][0]
+            end = start + limit
+            ids = order_ids[start:end]
+            feats = [self._orders_db._orders[order_id] for order_id in ids]
+
+            next = ""
+            if end < len(order_ids):
+                next = self._orders_db._orders[order_ids[end]].id
+            return Success((OrderCollection(features=feats), next))
+        except Exception as e:
+            return Failure(e)
 
     async def get_order(self, order_id: str, request: Request) -> ResultE[Maybe[Order]]:
         """

tests/test_order.py

@@ -168,3 +168,131 @@ def test_order_status_after_update(
     assert s["reason_text"] is None
     assert s["status_code"] == "received"
     assert s["timestamp"]
+
+
+@pytest.fixture
+def create_order_payloads() -> list[OrderPayload]:
+    datetimes = [
+        ("2024-10-09T18:55:33Z", "2024-10-12T18:55:33Z"),
+        ("2024-10-15T18:55:33Z", "2024-10-18T18:55:33Z"),
+        ("2024-10-20T18:55:33Z", "2024-10-23T18:55:33Z"),
+    ]
+    payloads = []
+    for start, end in datetimes:
+        payload = OrderPayload(
+            geometry=Point(
+                type="Point", coordinates=Position2D(longitude=14.4, latitude=56.5)
+            ),
+            datetime=(
+                datetime.fromisoformat(start),
+                datetime.fromisoformat(end),
+            ),
+            filter=None,
+            order_parameters=MyOrderParameters(s3_path="s3://my-bucket"),
+        )
+        payloads.append(payload)
+    return payloads
+
+
+@pytest.fixture
+def prepare_order_pagination(
+    stapi_client: TestClient, create_order_payloads: list[OrderPayload]
+) -> tuple[str, str, str]:
+    # product_backend._allowed_payloads = create_order_payloads
+    product_id = "test-spotlight"
+
+    # # check empty
+    # res = stapi_client.get("/orders")
+    # default_orders = {"type": "FeatureCollection", "features": [], "links": []}
+    # assert res.status_code == status.HTTP_200_OK
+    # assert res.headers["Content-Type"] == "application/geo+json"
+    # assert res.json() == default_orders
+
+    # get uuids created to use as pagination tokens
+    order_ids = []
+    for payload in create_order_payloads:
+        res = stapi_client.post(
+            f"products/{product_id}/orders",
+            json=payload.model_dump(),
+        )
+        assert res.status_code == status.HTTP_201_CREATED, res.text
+        assert res.headers["Content-Type"] == "application/geo+json"
+        order_ids.append(res.json()["id"])
+
+    # res = stapi_client.get("/orders")
+    # checker = res.json()
+    # assert len(checker['features']) == 3
+
+    return tuple(order_ids)
+
+
+@pytest.mark.parametrize(
+    "product_id,expected_status,limit,id_retrieval,token_back",
+    [
+        pytest.param(
+            "test-spotlight",
+            status.HTTP_200_OK,
+            1,
+            0,
+            True,
+            id="input frst order_id token get new token back",
+        ),
+        pytest.param(
+            "test-spotlight",
+            status.HTTP_200_OK,
+            1,
+            2,
+            False,
+            id="input last order_id token get NO token back",
+        ),
+        pytest.param(
+            "test-spotlight",
+            status.HTTP_404_NOT_FOUND,
+            1,
+            "BAD_TOKEN",
+            False,
+            id="input bad token get 404 back",
+        ),
+        pytest.param(
+            "test-spotlight",
+            status.HTTP_200_OK,
+            1,
+            1000000,
+            False,
+            id="high limit handled and returns valid records",
+        ),
+    ],
+)
+def test_order_pagination(
+    prepare_order_pagination,
+    stapi_client: TestClient,
+    product_id: str,
+    expected_status: int,
+    limit: int,
+    id_retrieval: int | str,
+    token_back: bool,
+) -> None:
+    order_ids = prepare_order_pagination
+
+    res = stapi_client.get(
+        "/orders", params={"next": order_ids[id_retrieval], "limit": limit}
+    )
+    assert res.status_code == expected_status
+
+    body = res.json()
+    for link in body["features"][0]["links"]:
+        assert link["rel"] != "next"
+    assert body["links"] != []
+
+    # check to make sure new token in link
+    if token_back:
+        assert order_ids[id_retrieval] not in body["links"][0]["href"]
+
+        assert len(body["features"]) == limit
+
+
+# test cases to check
+# 1. Input token and get last record.  Should not return a token if we are returning the last record - 'last' record being what is sorted
+# 2. Input a crzy high limit - how to handle?  Default to max or all records if less than max
+# 3. Input token and get some intermediate records - return a token for next records
+# 4. handle requesting an orderid/token that does't exist and returns 400/404. Bad token --> bad request.