feat: validate search and order requests (#56)

Adopt EODAG's request validation. The validation is enabled via
configuration (enabled by default).

Endpoint where validation is enabled:

- `/search`
- `/collections/{collection_id}/order`

---------

Co-authored-by: Sylvain Brunato <sylvain.brunato@c-s.fr>

Author: dalpasso

stac_fastapi/eodag/config.py

@@ -65,6 +65,12 @@ class Settings(ApiSettings):
         validate_default=False,
     )
 
+    validate_request: bool = Field(
+        default=True,
+        description="Validate search and product order requests",
+        alias="validate",
+    )
+
 
 @lru_cache(maxsize=1)
 def get_settings() -> Settings:

stac_fastapi/eodag/core.py

@@ -169,6 +169,10 @@ def _search_base(self, search_request: BaseSearchPostRequest, request: Request)
 
         request.state.eodag_args = eodag_args
 
+        # validate request
+        settings = get_settings()
+        validate: bool = settings.validate_request
+
         # check if the collection exists
         if collection := eodag_args.get("collection"):
             all_pt = request.app.state.dag.list_collections(fetch_providers=False)
@@ -184,11 +188,11 @@ def _search_base(self, search_request: BaseSearchPostRequest, request: Request)
             search_result = SearchResult([])
             for item_id in ids:
                 eodag_args["id"] = item_id
-                search_result.extend(request.app.state.dag.search(**eodag_args))
+                search_result.extend(request.app.state.dag.search(validate=validate, **eodag_args))
             search_result.number_matched = len(search_result)
         else:
             # search without ids
-            search_result = request.app.state.dag.search(**eodag_args)
+            search_result = request.app.state.dag.search(validate=validate, **eodag_args)
 
         if search_result.errors and not len(search_result):
             raise ResponseSearchError(search_result.errors, self.stac_metadata_model)
@@ -561,7 +565,7 @@ def prepare_search_base_args(search_request: BaseSearchPostRequest, model: type[
 
     :param search_request: the search request
     :param model: the model used to validate stac metadata
-    :returns: a dictionnary containing arguments for the eodag search
+    :returns: a dictionary containing arguments for the eodag search
     """
     base_args = (
         {

stac_fastapi/eodag/extensions/collection_order.py

@@ -36,6 +36,8 @@
 from stac_fastapi.types.search import APIRequest
 from stac_fastapi.types.stac import Item
 
+from stac_fastapi.eodag.config import get_settings
+from stac_fastapi.eodag.errors import ResponseSearchError
 from stac_fastapi.eodag.models.stac_metadata import (
     CommonStacMetadata,
     create_stac_item,
@@ -81,18 +83,27 @@ def order_collection(
 
         if request_body is None:
             federation_backend = None
-            request_params = {}
+            search_params = {}
         else:
             federation_backend = request_body.federation_backends[0] if request_body.federation_backends else None
 
             request_params = request_body.model_dump(exclude={"federation_backends": True})
             # use eodag formatting for search
             search_params = {f"ecmwf:{k}": v for k, v in request_params.items()}
-        search_results = dag.search(collection=collection_id, provider=federation_backend, **search_params)
+
+        settings = get_settings()
+        validate: bool = settings.validate_request
+        search_results = dag.search(
+            collection=collection_id,
+            provider=federation_backend,
+            validate=validate,
+            **search_params,
+        )
 
         if len(search_results) > 0:
             product = cast(EOProduct, search_results[0])
-
+        elif search_results.errors:
+            raise ResponseSearchError(search_results.errors, self.stac_metadata_model)
         else:
             raise NotFoundError(
                 f"Could not find any item in {collection_id} collection for backend {federation_backend}.",

tests/test_order.py

@@ -27,6 +27,9 @@
 from eodag.config import load_default_config
 from eodag.plugins.download.base import Download
 from eodag.plugins.manager import PluginManager
+from eodag.utils.exceptions import ValidationError
+
+from stac_fastapi.eodag.config import get_settings
 
 
 @pytest.mark.parametrize("post_data", [{"foo": "bar"}, {}])
@@ -99,6 +102,7 @@ async def run():
                 collection=collection_id,
                 provider=None,
                 **{f"ecmwf:{k}": v for k, v in post_data.items()},
+                validate=True,
             ),
         )
 
@@ -190,6 +194,7 @@ async def run():
                 collection=collection_id,
                 provider=None,
                 **{f"ecmwf:{k}": v for k, v in post_data.items()},
+                validate=True,
             ),
         )
 
@@ -336,3 +341,128 @@ async def test_order_not_order_id_ko(request_not_found, mock_search, mock_order)
         post_data={},
         error_message="Download order failed.",
     )
+
+
+@pytest.mark.parametrize("validate", [True, False])
+async def test_order_validate(request_valid, settings_cache_clear, validate):
+    """Product order through eodag server must be validated according to settings"""
+    get_settings().validate_request = validate
+    post_data = {"foo": "bar"}
+    federation_backend = "cop_ads"
+    collection_id = "CAMS_EAC4"
+    expected_search_kwargs = dict(
+        collection=collection_id,
+        provider=None,
+        validate=validate,
+        **{f"ecmwf:{k}": v for k, v in post_data.items()},
+    )
+    url = f"collections/{collection_id}/order"
+    product = EOProduct(
+        federation_backend,
+        dict(
+            geometry="POINT (0 0)",
+            title="dummy_product",
+            id="dummy_id",
+        ),
+    )
+    product.collection = collection_id
+
+    product_dataset = "cams-global-reanalysis-eac4"
+    endpoint = "https://ads.atmosphere.copernicus.eu/api/retrieve/v1"
+    product.properties["eodag:order_link"] = (
+        f"{endpoint}/processes/{product_dataset}/execution" + '?{"inputs": {"qux": "quux"}}'
+    )
+
+    # order an offline product
+    product.properties["order:status"] = OFFLINE_STATUS
+
+    # add auth and download plugins to make the order works
+    plugins_manager = PluginManager(load_default_config())
+    download_plugin = plugins_manager.get_download_plugin(product)
+    auth_plugin = plugins_manager.get_auth_plugin(download_plugin, product)
+    auth_plugin.config.credentials = {"apikey": "anicekey"}
+    product.register_downloader(download_plugin, auth_plugin)
+
+    product_id = product.properties["id"]
+
+    @responses.activate(registry=responses.registries.OrderedRegistry)
+    async def run():
+        responses.add(
+            responses.POST,
+            f"{endpoint}/processes/{product_dataset}/execution",
+            status=200,
+            content_type="application/json",
+            body=f'{{"status": "accepted", "jobID": "{product_id}"}}'.encode("utf-8"),
+            auto_calculate_content_length=True,
+        )
+        responses.add(
+            responses.GET,
+            f"{endpoint}/jobs/{product_id}",
+            status=200,
+            content_type="application/json",
+            body=f'{{"status": "successful", "jobID": "{product_id}"}}'.encode("utf-8"),
+            auto_calculate_content_length=True,
+        )
+        responses.add(
+            responses.GET,
+            f"{endpoint}/jobs/{product_id}/results",
+            status=200,
+            content_type="application/json",
+            body=(f'{{"asset": {{"value": {{"href": "http://somewhere/download/{product_id}"}} }} }}'.encode("utf-8")),
+            auto_calculate_content_length=True,
+        )
+
+        await request_valid(
+            url=url,
+            method="POST",
+            post_data=post_data,
+            search_result=SearchResult([product]),
+            expected_search_kwargs=expected_search_kwargs,
+        )
+
+    await run()
+
+
+async def test_order_validate_with_errors(app, app_client, mocker, settings_cache_clear):
+    """Order a product through eodag server with invalid parameters must return informative error message"""
+    get_settings().validate_request = True
+    collection_id = "AG_ERA5"
+    errors = [
+        ("wekeo_ecmwf", ValidationError("2 error(s). ecmwf:version: Field required; ecmwf:variable: Field required")),
+        ("cop_cds", ValidationError("2 error(s). ecmwf:version: Field required; ecmwf:variable: Field required")),
+    ]
+    expected_response = {
+        "code": "400",
+        "description": "Something went wrong",
+        "errors": [
+            {
+                "provider": "wekeo_ecmwf",
+                "error": "ValidationError",
+                "status_code": 400,
+                "message": "2 error(s). ecmwf:version: Field required; ecmwf:variable: Field required",
+            },
+            {
+                "provider": "cop_cds",
+                "error": "ValidationError",
+                "status_code": 400,
+                "message": "2 error(s). ecmwf:version: Field required; ecmwf:variable: Field required",
+            },
+        ],
+    }
+
+    mock_search = mocker.patch.object(app.state.dag, "search")
+    mock_search.return_value = SearchResult([], 0, errors)
+
+    response = await app_client.request(
+        "POST",
+        f"/collections/{collection_id}/order",
+        json=None,
+        follow_redirects=True,
+        headers={},
+    )
+    response_content = response.json()
+
+    assert response.status_code == 400
+    assert "ticket" in response_content
+    response_content.pop("ticket", None)
+    assert expected_response == response_content