add test for getting latest solver

Author: bisgaard-itis

services/api-server/src/simcore_service_api_server/_service_solvers.py

@@ -1,14 +1,20 @@
 from typing import Annotated
 
+from common_library.pagination_tools import iter_pagination_params
 from fastapi import Depends
 from models_library.basic_types import VersionStr
 from models_library.products import ProductName
+from models_library.rest_pagination import MAXIMUM_NUMBER_OF_ITEMS_PER_PAGE
 from models_library.services_enums import ServiceType
+from models_library.services_history import ServiceRelease
 from models_library.users import UserID
+from packaging.version import Version
 
 from .models.schemas.solvers import Solver, SolverKeyId
 from .services_rpc.catalog import CatalogService
 
+DEFAULT_PAGINATION_LIMIT = MAXIMUM_NUMBER_OF_ITEMS_PER_PAGE - 1
+
 
 class SolverService:
     _catalog_service: CatalogService
@@ -37,3 +43,32 @@ async def get_solver(
         ), "Expected by SolverName regex"
 
         return Solver.create_from_service(service)
+
+    async def get_latest_release(
+        self,
+        *,
+        user_id: int,
+        solver_key: SolverKeyId,
+        product_name: str,
+    ) -> Solver:
+        service_releases: list[ServiceRelease] = []
+        for page_params in iter_pagination_params(limit=DEFAULT_PAGINATION_LIMIT):
+            releases, page_meta = await self._catalog_service.list_release_history(
+                user_id=user_id,
+                service_key=solver_key,
+                product_name=product_name,
+                offset=page_params.offset,
+                limit=page_params.limit,
+            )
+            page_params.total_number_of_items = page_meta.total
+            service_releases.extend(releases)
+
+        release = sorted(service_releases, key=lambda s: Version(s.version))[-1]
+        service = await self._catalog_service.get(
+            user_id=user_id,
+            service_key=solver_key,
+            service_version=release.version,
+            product_name=product_name,
+        )
+
+        return Solver.create_from_service(service)

services/api-server/src/simcore_service_api_server/api/routes/solvers.py

@@ -136,15 +136,15 @@ async def get_solvers_releases_page(
 async def get_solver(
     solver_key: SolverKeyId,
     user_id: Annotated[int, Depends(get_current_user_id)],
-    catalog_client: Annotated[CatalogApi, Depends(get_api_client(CatalogApi))],
+    solver_service: Annotated[SolverService, Depends(SolverService)],
     url_for: Annotated[Callable, Depends(get_reverse_url_mapper)],
     product_name: Annotated[str, Depends(get_product_name)],
 ) -> Solver:
     """Gets latest release of a solver"""
     # IMPORTANT: by adding /latest, we avoid changing the order of this entry in the router list
     # otherwise, {solver_key:path} will override and consume any of the paths that follow.
     try:
-        solver = await catalog_client.get_latest_release(
+        solver = await solver_service.get_latest_release(
             user_id=user_id,
             solver_key=solver_key,
             product_name=product_name,

services/api-server/src/simcore_service_api_server/services_http/catalog.py

@@ -4,7 +4,6 @@
 from collections.abc import Callable
 from dataclasses import dataclass
 from functools import partial
-from operator import attrgetter
 from typing import Final, Literal
 
 from fastapi import FastAPI, status
@@ -145,32 +144,6 @@ async def list_services(
             services = [service for service in services if predicate(service)]
         return services
 
-    @_exception_mapper(
-        http_status_map={status.HTTP_404_NOT_FOUND: SolverOrStudyNotFoundError}
-    )
-    async def _get_service(
-        self, *, user_id: int, name: SolverKeyId, version: VersionStr, product_name: str
-    ) -> TruncatedCatalogServiceOut:
-
-        assert version != LATEST_VERSION  # nosec
-
-        service_key = urllib.parse.quote_plus(name)
-        service_version = version
-
-        response = await self.client.get(
-            f"/services/{service_key}/{service_version}",
-            params={"user_id": user_id},
-            headers={"x-simcore-products-name": product_name},
-        )
-        response.raise_for_status()
-
-        service: (
-            TruncatedCatalogServiceOut
-        ) = await asyncio.get_event_loop().run_in_executor(
-            None, _parse_response, TruncatedCatalogServiceOutAdapter, response
-        )
-        return service
-
     @_exception_mapper(
         http_status_map={status.HTTP_404_NOT_FOUND: SolverOrStudyNotFoundError}
     )
@@ -236,22 +209,6 @@ def _this_solver(solver: Solver) -> bool:
         solvers = [service.to_solver() for service in services]
         return [solver for solver in solvers if _this_solver(solver)]
 
-    async def get_latest_release(
-        self,
-        *,
-        user_id: int,
-        solver_key: SolverKeyId,
-        product_name: str,
-    ) -> Solver:
-        releases = await self.list_service_releases(
-            user_id=user_id,
-            solver_key=solver_key,
-            product_name=product_name,
-        )
-
-        # raises IndexError if None
-        return sorted(releases, key=attrgetter("pep404_version"))[-1]
-
 
 # MODULES APP SETUP -------------------------------------------------------------
 

services/api-server/tests/unit/test_api_solvers.py

@@ -50,3 +50,26 @@ async def test_get_solver_pricing_plan(
     assert expected_status_code == response.status_code
     if response.status_code == status.HTTP_200_OK:
         _ = ServicePricingPlanGet.model_validate(response.json())
+
+
+@pytest.mark.parametrize(
+    "solver_key,expected_status_code",
+    [
+        ("simcore/services/comp/valid_solver", status.HTTP_200_OK),
+    ],
+)
+async def test_get_latest_solver_release(
+    client: AsyncClient,
+    mocked_rpc_catalog_service_api,
+    auth: httpx.BasicAuth,
+    solver_key: str,
+    expected_status_code: int,
+):
+    response = await client.get(
+        f"{API_VTAG}/solvers/{solver_key}/latest",
+        auth=auth,
+    )
+    assert response.status_code == expected_status_code
+    if response.status_code == status.HTTP_200_OK:
+        assert "id" in response.json()
+        assert response.json()["id"] == solver_key