Set back the starlette changes, going to bring them from the develop branch

Author: Alex Grosu

services/cadip/rs_server_cadip/api/cadip_search.py

@@ -561,7 +561,7 @@ def process_session_search(  # type: ignore # pylint: disable=too-many-arguments
     except ValueError as exception:
         logger.error(exception)
         raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=str(exception),
         ) from exception
     except Exception as exception:  # pylint: disable=broad-exception-caught
@@ -611,7 +611,7 @@ def process_files_search(  # pylint: disable=too-many-locals
         queryables["SessionId"] = split_multiple_values(session_id)
 
     if limit < 1:  # type: ignore
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail="Pagination cannot be less 0")
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Pagination cannot be less 0")
     # Init dataretriever / get products / return
     try:
         products = cadip_retriever.init_cadip_provider(station).search(

services/cadip/rs_server_cadip/cadip_utils.py

@@ -198,12 +198,12 @@ def cadip_map_mission(platform: str, constellation: str) -> str | None:
             )
             if satellite and satellite not in satellites:
                 raise HTTPException(
-                    status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                     detail="Invalid combination of platform-constellation",
                 )
     except (KeyError, IndexError, StopIteration) as exc:
         raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Cannot map platform/constellation",
         ) from exc
     return satellite or satellites

services/catalog/tests/test_authentication_catalog.py

@@ -42,7 +42,7 @@
     HTTP_401_UNAUTHORIZED,
     HTTP_403_FORBIDDEN,
     HTTP_404_NOT_FOUND,
-    HTTP_422_UNPROCESSABLE_CONTENT,
+    HTTP_422_UNPROCESSABLE_ENTITY,
     HTTP_500_INTERNAL_SERVER_ERROR,
 )
 
@@ -1572,7 +1572,7 @@ async def test_error_when_not_authenticated(mocker, client, httpx_mock: HTTPXMoc
                 assert response.status_code not in (
                     HTTP_401_UNAUTHORIZED,
                     HTTP_403_FORBIDDEN,
-                    HTTP_422_UNPROCESSABLE_CONTENT,  # with 422, the authentication is not called and not tested
+                    HTTP_422_UNPROCESSABLE_ENTITY,  # with 422, the authentication is not called and not tested
                 )
 
                 # With a wrong apikey, we should have a 403 error

services/common/rs_server_common/stac_api_common.py

@@ -393,7 +393,7 @@ def format_dict(field: dict):
                     raise ValueError
             except ValueError as exc:
                 raise log_http_exception(
-                    status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                     detail=f"Invalid page value: {page!r}",
                 ) from exc
 
@@ -406,7 +406,7 @@ def format_dict(field: dict):
                     raise ValueError
             except ValueError as exc:
                 raise log_http_exception(
-                    status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                     detail=f"Invalid limit value: {limit!r}",
                 ) from exc
 
@@ -421,7 +421,7 @@ def format_dict(field: dict):
         elif isinstance(sortby_param, list):
             if len(sortby_param) > 1:
                 raise log_http_exception(
-                    status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status.HTTP_422_UNPROCESSABLE_ENTITY,
                     f"Only one 'sortby' search parameter is allowed: {sortby_param!r}",
                 )
             if sortby_param:
@@ -440,7 +440,7 @@ def format_dict(field: dict):
                     stac_params["published"] = datetime
             except HTTPException as exception:
                 raise log_http_exception(
-                    status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status.HTTP_422_UNPROCESSABLE_ENTITY,
                     f"Invalid datetime interval: {datetime!r}. "
                     "Expected format is either: 'YYYY-MM-DDThh:mm:ssZ', 'YYYY-MM-DDThh:mm:ssZ/YYYY-MM-DDThh:mm:ssZ', "
                     "'YYYY-MM-DDThh:mm:ssZ/..' or '../YYYY-MM-DDThh:mm:ssZ'",
@@ -457,7 +457,7 @@ def read_property(prop: str, value: Any):
             nonlocal stac_params  # noqa: F824
             if prop not in allowed_properties:
                 raise log_http_exception(
-                    status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status.HTTP_422_UNPROCESSABLE_ENTITY,
                     f"Invalid query or CQL property: {prop!r}, " f"allowed properties are: {allowed_properties}",
                 )
             if isinstance(value, dict):
@@ -488,7 +488,7 @@ def read_cql(filt: dict):
             if op and op.lower() == "intersects":
                 if len(args) != 2:
                     raise log_http_exception(
-                        status.HTTP_422_UNPROCESSABLE_CONTENT,
+                        status.HTTP_422_UNPROCESSABLE_ENTITY,
                         f"Invalid intersects: {format_dict(filt)}",
                     )
                 geom = args[1]
@@ -504,7 +504,7 @@ def read_cql(filt: dict):
             if op == "=":
                 if (len(args) != 2) or not (prop := args[0].get("property")):
                     raise log_http_exception(
-                        status.HTTP_422_UNPROCESSABLE_CONTENT,
+                        status.HTTP_422_UNPROCESSABLE_ENTITY,
                         f"Invalid CQL2 filter: {format_dict(filt)}",
                     )
                 value = args[1]
@@ -521,7 +521,7 @@ def read_cql(filt: dict):
             # Else we are reading several properties
             if op != "and":
                 raise log_http_exception(
-                    status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status.HTTP_422_UNPROCESSABLE_ENTITY,
                     f"Invalid CQL2 filter, only '=', 'and' and temporal operators are allowed, got '{op}': {format_dict(filt)}",  # noqa: E501 # pylint: disable=line-too-long
                 )
             for sub_filter in args:
@@ -544,7 +544,7 @@ def read_query(query_arg: str | None):
                 # Extract prop and check if it's in the queryables.
                 if (prop := kv[0].strip()) not in allowed_properties:
                     raise log_http_exception(
-                        status.HTTP_422_UNPROCESSABLE_CONTENT,
+                        status.HTTP_422_UNPROCESSABLE_ENTITY,
                         f"Invalid query filter property: {prop!r}, allowed properties are: {allowed_properties}",
                     )
                 value = str(kv[1]).strip("'\"")
@@ -561,7 +561,7 @@ def read_query(query_arg: str | None):
                 logger.debug(f"Temporal operator detected: {op} -> {stac_params[op]}")
             else:
                 raise log_http_exception(
-                    status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status.HTTP_422_UNPROCESSABLE_ENTITY,
                     "Invalid query filter, only '=' and temporal operators are allowed, got: " + query_arg,
                 )
 
@@ -572,7 +572,7 @@ def read_query(query_arg: str | None):
         for prop, operator in query.items():
             if (len(operator) != 1) or not (value := operator.get("eq")):
                 raise log_http_exception(
-                    status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status.HTTP_422_UNPROCESSABLE_ENTITY,
                     f"Invalid query: {{{prop!r}: {format_dict(operator)}}}"
                     ", only {'<property>': {'eq': <value>}} is allowed",
                 )
@@ -599,7 +599,7 @@ def read_query(query_arg: str | None):
         # If search parameters remain, they are not implemented
         if params:
             raise log_http_exception(
-                status.HTTP_422_UNPROCESSABLE_CONTENT,
+                status.HTTP_422_UNPROCESSABLE_ENTITY,
                 f"Unimplemented search parameters: {format_dict(params)}",
             )
 
@@ -1056,7 +1056,7 @@ def create_collection(collection: dict) -> stac_pydantic.Collection:
     except ValidationError as exc:
         raise log_http_exception(
             detail=f"Unable to create stac_pydantic.Collection, {repr(exc.errors())}",
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
         ) from exc
 
 
@@ -1073,13 +1073,13 @@ def wrapping_logic(*_args, **_kwargs):
         except KeyError as exc:
             logger.error(f"KeyError caught in {func.__name__}")
             raise log_http_exception(
-                status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                 detail=f"Cannot create STAC Collection -> Missing {exc}",
             ) from exc
         except ValidationError as exc:
             logger.error(f"ValidationError caught in {func.__name__}")
             raise log_http_exception(
-                status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                 detail=f"Parameters validation error: {exc}",
             ) from exc
 
@@ -1149,7 +1149,7 @@ def filter_allowed_collections(all_collections: list[dict], role: ServiceRole |
 
         # If a collection is incomplete in the configuration file, log the error and proceed
         except HTTPException as exception:
-            if exception.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT:
+            if exception.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY:
                 logger.error(exception)
             else:
                 raise
@@ -1251,7 +1251,7 @@ def get_sort_key(item):
         sorted_items = sorted(item_collection.features, key=get_sort_key, reverse=direction == "-")
     except AttributeError as e:
         raise log_http_exception(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=f"Invalid attribute '{attribute}' for sorting: {str(e)},",
         ) from e
     return ItemCollection(features=sorted_items, type=item_collection.type)
@@ -1271,7 +1271,7 @@ def check_input_type(field_info, key, input_value):
 
     if not type_mapping.get(expected_type)(input_value):  # type: ignore
         raise log_http_exception(
-            status.HTTP_422_UNPROCESSABLE_CONTENT,
+            status.HTTP_422_UNPROCESSABLE_ENTITY,
             "Invalid CQL2 filter value",
         )
 

services/common/rs_server_common/utils/utils.py

@@ -117,7 +117,7 @@ def validate_inputs_format(
             fixed_date = date_time
     except ValueError as exc:
         logger.error("Missing start or stop in endpoint call!")
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail="Missing start/stop") from exc
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Missing start/stop") from exc
 
     def is_valid_date(date: str) -> bool:
         """Check if the string can be converted to a valid datetime."""
@@ -184,7 +184,7 @@ def map_auxip_prip_mission(platform: str, constellation: str) -> tuple[str | Non
             if platform_short_name and platform_short_name != constellation:
                 # Inconsistent combination of platform / constellation case
                 raise HTTPException(
-                    status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                     detail="Invalid combination of platform-constellation",
                 )
             if any(
@@ -197,7 +197,7 @@ def map_auxip_prip_mission(platform: str, constellation: str) -> tuple[str | Non
                 raise KeyError
     except (KeyError, IndexError, StopIteration) as exc:
         raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Cannot map platform/constellation",
         ) from exc
     return platform_short_name, platform_serial_identifier

services/staging/tests/test_authentication_staging.py

@@ -28,7 +28,7 @@
 from starlette.status import (
     HTTP_401_UNAUTHORIZED,
     HTTP_403_FORBIDDEN,
-    HTTP_422_UNPROCESSABLE_CONTENT,
+    HTTP_422_UNPROCESSABLE_ENTITY,
 )
 
 from .resources.sample_data import sample_process_metadata_model
@@ -93,7 +93,7 @@ async def test_error_when_not_authenticated(  # pylint: disable=too-many-locals
                 assert response.status_code not in (
                     HTTP_401_UNAUTHORIZED,
                     HTTP_403_FORBIDDEN,
-                    HTTP_422_UNPROCESSABLE_CONTENT,  # with 422, the authentication is not called and not tested
+                    HTTP_422_UNPROCESSABLE_ENTITY,  # with 422, the authentication is not called and not tested
                 )
                 # With a wrong apikey, we should have a 403 error
                 if test_apikey:

services/staging/tests/test_staging_endpoints.py

@@ -30,7 +30,7 @@
     HTTP_200_OK,
     HTTP_201_CREATED,
     HTTP_404_NOT_FOUND,
-    HTTP_422_UNPROCESSABLE_CONTENT,
+    HTTP_422_UNPROCESSABLE_ENTITY,
     HTTP_500_INTERNAL_SERVER_ERROR,
 )
 
@@ -547,7 +547,7 @@ async def test_execute_staging(
     resource_name = "staging"
     # ----- Test case where we have a staging body uncompliant with ogc
     response = staging_client.post(f"/processes/{resource_name}/execution", json=wrong_staging_body)
-    assert response.status_code == HTTP_422_UNPROCESSABLE_CONTENT
+    assert response.status_code == HTTP_422_UNPROCESSABLE_ENTITY
 
     mock_db_table = mocker.MagicMock()
     mocker.patch(

tests/test_search_endpoint.py

@@ -47,7 +47,7 @@ class TestOperatorDefinedCollections:
     @pytest.mark.parametrize(
         "endpoint, code",
         [
-            ("/cadip/collections/cadip_session_incomplete/items", status.HTTP_422_UNPROCESSABLE_CONTENT),
+            ("/cadip/collections/cadip_session_incomplete/items", status.HTTP_422_UNPROCESSABLE_ENTITY),
             ("/cadip/collections/cadip_session_incomplete_no_stop/items", status.HTTP_400_BAD_REQUEST),
             ("/cadip/collections/cadip_session_incomplete_no_start/items", status.HTTP_400_BAD_REQUEST),
             ("/auxip/collections/adgs_invalid_no_start/items", status.HTTP_400_BAD_REQUEST),
@@ -346,7 +346,7 @@ def test_cadip_validation_errors(self, client, mocker, endpoint):
             "rs_server_cadip.api.cadip_search.process_session_search",
             side_effect=ValidationError.from_exception_data("Invalid data", line_errors=[]),
         )
-        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
 
     @pytest.mark.unit
     @pytest.mark.parametrize(
@@ -363,7 +363,7 @@ def test_adgs_validation_errors(self, client, mocker, endpoint):
             "rs_server_adgs.api.adgs_search.process_product_search",
             side_effect=ValidationError.from_exception_data("Invalid data", line_errors=[]),
         )
-        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
 
     @pytest.mark.unit
     @pytest.mark.parametrize(
@@ -380,7 +380,7 @@ def test_prip_validation_errors(self, client, mocker, endpoint):
             "rs_server_prip.api.prip_search.process_product_search",
             side_effect=ValidationError.from_exception_data("Invalid data", line_errors=[]),
         )
-        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
 
     @pytest.mark.unit
     def test_adgs_search_error(self, client, mocker):
@@ -442,7 +442,7 @@ class TestErrorWhileBuildUpCollection:
     def test_cadip_collection_creation_failure(self, client, mocker, endpoint):
         """Test used to generate a KeyError while Collection is created, should return HTTP 422."""
         mocker.patch("rs_server_cadip.api.cadip_search.process_session_search", side_effect=KeyError)
-        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
 
     @pytest.mark.unit
     @pytest.mark.parametrize(
@@ -453,7 +453,7 @@ def test_cadip_collection_creation_failure(self, client, mocker, endpoint):
     def test_adgs_collection_creation_failure(self, client, mocker, endpoint):
         """Test used to generate a KeyError while Collection is created, should return HTTP 422."""
         mocker.patch("rs_server_adgs.api.adgs_search.process_product_search", side_effect=KeyError)
-        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
 
     @pytest.mark.unit
     @pytest.mark.parametrize(
@@ -466,7 +466,7 @@ def test_adgs_collection_creation_failure(self, client, mocker, endpoint):
     def test_prip_collection_creation_failure(self, client, mocker, endpoint):
         """Test used to generate a KeyError while Collection is created, should return HTTP 422."""
         mocker.patch("rs_server_prip.api.prip_search.process_product_search", side_effect=KeyError)
-        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert client.get(endpoint).status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
 
 
 class TestFeatureOdataStacMapping:
@@ -859,7 +859,7 @@ def test_prip_feature_collection_mapping(
                 ROUTER_PREFIX_CADIP,
                 "/cadip/collections/cadip_session_by_satellite/items?filter=cadip:retransfer=should_be_bool",
                 "no_odata",
-                status.HTTP_422_UNPROCESSABLE_CONTENT,
+                status.HTTP_422_UNPROCESSABLE_ENTITY,
             ),
             (
                 ROUTER_PREFIX_CADIP,
@@ -873,7 +873,7 @@ def test_prip_feature_collection_mapping(
                 ROUTER_PREFIX_CADIP,
                 "/cadip/collections/cadip_session_by_satellite/items?filter=invalid='x'",
                 "No odata for this",
-                status.HTTP_422_UNPROCESSABLE_CONTENT,
+                status.HTTP_422_UNPROCESSABLE_ENTITY,
             ),
             (
                 ROUTER_PREFIX_AUXIP,
@@ -915,13 +915,13 @@ def test_prip_feature_collection_mapping(
                 ROUTER_PREFIX_AUXIP,
                 "/auxip/collections/adgs_by_platform/items?filter=invalid='x'",
                 "No odata",
-                status.HTTP_422_UNPROCESSABLE_CONTENT,
+                status.HTTP_422_UNPROCESSABLE_ENTITY,
             ),
             (
                 ROUTER_PREFIX_AUXIP,
                 "/auxip/collections/adgs_by_platform/items?filter=published=invalid_date_format2020",
                 "No odata",
-                status.HTTP_422_UNPROCESSABLE_CONTENT,
+                status.HTTP_422_UNPROCESSABLE_ENTITY,
             ),
         ],
         indirect=["fastapi_app"],
@@ -1167,7 +1167,7 @@ def test_bigger_limit_than_allowed(self, client, endpoint, odata):
     def test_invalid_page_values(self, client, endpoint):
         """Test endpoint call with invalid pages (str, negative, 0)"""
         response = client.get(endpoint)
-        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
         assert "Invalid page value" in response.json()["description"]
 
     @pytest.mark.unit