stac-fastapi.api 2.5.5.post1__tar.gz → 3.0.0a0__tar.gz

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 2.5.5.post1
+Version: 3.0.0a0
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -18,9 +18,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: attrs
-Requires-Dist: pydantic[dotenv]<2
-Requires-Dist: stac_pydantic==2.0.*
 Requires-Dist: brotli_asgi
 Requires-Dist: stac-fastapi.types
 Provides-Extra: dev

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/setup.py

@@ -6,9 +6,6 @@ with open("README.md") as f:
     desc = f.read()
 
 install_requires = [
-    "attrs",
-    "pydantic[dotenv]<2",
-    "stac_pydantic==2.0.*",
     "brotli_asgi",
     "stac-fastapi.types",
 ]

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi/api/app.py

@@ -1,5 +1,6 @@
 """Fastapi app creation."""
 
+
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 import attr
@@ -7,10 +8,11 @@ from brotli_asgi import BrotliMiddleware
 from fastapi import APIRouter, FastAPI
 from fastapi.openapi.utils import get_openapi
 from fastapi.params import Depends
-from stac_pydantic import Collection, Item, ItemCollection
-from stac_pydantic.api import ConformanceClasses, LandingPage
+from stac_pydantic import api
 from stac_pydantic.api.collections import Collections
-from stac_pydantic.version import STAC_VERSION
+from stac_pydantic.api.version import STAC_API_VERSION
+from stac_pydantic.shared import MimeTypes
+from starlette.middleware import Middleware
 from starlette.responses import JSONResponse, Response
 
 from stac_fastapi.api.errors import DEFAULT_STATUS_CODES, add_exception_handlers
@@ -94,7 +96,7 @@ class StacApi:
             lambda self: self.settings.stac_fastapi_version, takes_self=True
         )
     )
-    stac_version: str = attr.ib(default=STAC_VERSION)
+    stac_version: str = attr.ib(default=STAC_API_VERSION)
     description: str = attr.ib(
         default=attr.Factory(
             lambda self: self.settings.stac_fastapi_description, takes_self=True
@@ -108,9 +110,13 @@ class StacApi:
     )
     pagination_extension = attr.ib(default=TokenPaginationExtension)
     response_class: Type[Response] = attr.ib(default=JSONResponse)
-    middlewares: List = attr.ib(
+    middlewares: List[Middleware] = attr.ib(
         default=attr.Factory(
-            lambda: [BrotliMiddleware, CORSMiddleware, ProxyHeaderMiddleware]
+            lambda: [
+                Middleware(BrotliMiddleware),
+                Middleware(CORSMiddleware),
+                Middleware(ProxyHeaderMiddleware),
+            ]
         )
     )
     route_dependencies: List[Tuple[List[Scope], List[Depends]]] = attr.ib(default=[])
@@ -138,9 +144,17 @@ class StacApi:
         self.router.add_api_route(
             name="Landing Page",
             path="/",
-            response_model=LandingPage
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                api.LandingPage if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": api.LandingPage,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=False,
             response_model_exclude_none=True,
@@ -157,9 +171,17 @@ class StacApi:
         self.router.add_api_route(
             name="Conformance Classes",
             path="/conformance",
-            response_model=ConformanceClasses
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                api.ConformanceClasses if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": api.ConformanceClasses,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -176,7 +198,15 @@ class StacApi:
         self.router.add_api_route(
             name="Get Item",
             path="/collections/{collection_id}/items/{item_id}",
-            response_model=Item if self.settings.enable_response_models else None,
+            response_model=api.Item if self.settings.enable_response_models else None,
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.Item,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -194,9 +224,19 @@ class StacApi:
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(ItemCollection if not fields_ext else None)
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                (api.ItemCollection if not fields_ext else None)
+                if self.settings.enable_response_models
+                else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.ItemCollection,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -216,9 +256,19 @@ class StacApi:
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(ItemCollection if not fields_ext else None)
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                (api.ItemCollection if not fields_ext else None)
+                if self.settings.enable_response_models
+                else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.ItemCollection,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -237,9 +287,17 @@ class StacApi:
         self.router.add_api_route(
             name="Get Collections",
             path="/collections",
-            response_model=Collections
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                Collections if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": Collections,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -256,7 +314,17 @@ class StacApi:
         self.router.add_api_route(
             name="Get Collection",
             path="/collections/{collection_id}",
-            response_model=Collection if self.settings.enable_response_models else None,
+            response_model=api.Collection
+            if self.settings.enable_response_models
+            else None,
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": api.Collection,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -283,9 +351,17 @@ class StacApi:
         self.router.add_api_route(
             name="Get ItemCollection",
             path="/collections/{collection_id}/items",
-            response_model=ItemCollection
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                api.ItemCollection if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.ItemCollection,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -363,6 +439,11 @@ class StacApi:
         """
         return add_route_dependencies(self.app.router.routes, scopes, dependencies)
 
+    def add_middleware(self, middleware: Middleware):
+        """Add a middleware class to the application."""
+        self.app.user_middleware.insert(0, middleware)
+        self.app.middleware_stack = self.app.build_middleware_stack()
+
     def __attrs_post_init__(self):
         """Post-init hook.
 
@@ -407,7 +488,7 @@ class StacApi:
 
         # add middlewares
         for middleware in self.middlewares:
-            self.app.add_middleware(middleware)
+            self.add_middleware(middleware)
 
         # customize route dependencies
         for scopes, dependencies in self.route_dependencies:

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi/api/config.py

@@ -1,4 +1,5 @@
 """Application settings."""
+
 import enum
 
 

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi/api/errors.py

@@ -4,7 +4,7 @@ import logging
 from typing import Callable, Dict, Type, TypedDict
 
 from fastapi import FastAPI
-from fastapi.exceptions import RequestValidationError
+from fastapi.exceptions import RequestValidationError, ResponseValidationError
 from starlette import status
 from starlette.requests import Request
 from starlette.responses import JSONResponse
@@ -27,6 +27,7 @@ DEFAULT_STATUS_CODES = {
     DatabaseError: status.HTTP_424_FAILED_DEPENDENCY,
     Exception: status.HTTP_500_INTERNAL_SERVER_ERROR,
     InvalidQueryParameter: status.HTTP_400_BAD_REQUEST,
+    ResponseValidationError: status.HTTP_500_INTERNAL_SERVER_ERROR,
 }
 
 

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi/api/middleware.py

@@ -1,4 +1,5 @@
 """Api middleware."""
+
 import re
 import typing
 from http.client import HTTP_PORT, HTTPS_PORT

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi/api/models.py

@@ -1,12 +1,11 @@
 """Api request/response models."""
 
 import importlib.util
-from typing import Optional, Type, Union
+from typing import List, Optional, Type, Union
 
 import attr
-from fastapi import Body, Path
+from fastapi import Path
 from pydantic import BaseModel, create_model
-from pydantic.fields import UndefinedType
 from stac_pydantic.shared import BBox
 
 from stac_fastapi.types.extension import ApiExtension
@@ -23,8 +22,8 @@ from stac_fastapi.types.search import (
 def create_request_model(
     model_name="SearchGetRequest",
     base_model: Union[Type[BaseModel], APIRequest] = BaseSearchGetRequest,
-    extensions: Optional[ApiExtension] = None,
-    mixins: Optional[Union[BaseModel, APIRequest]] = None,
+    extensions: Optional[List[ApiExtension]] = None,
+    mixins: Optional[Union[List[BaseModel], List[APIRequest]]] = None,
     request_type: Optional[str] = "GET",
 ) -> Union[Type[BaseModel], APIRequest]:
     """Create a pydantic model for validating request bodies."""
@@ -47,40 +46,19 @@ def create_request_model(
     # Handle POST requests
     elif all([issubclass(m, BaseModel) for m in models]):
         for model in models:
-            for k, v in model.__fields__.items():
-                field_info = v.field_info
-                body = Body(
-                    None
-                    if isinstance(field_info.default, UndefinedType)
-                    else field_info.default,
-                    default_factory=field_info.default_factory,
-                    alias=field_info.alias,
-                    alias_priority=field_info.alias_priority,
-                    title=field_info.title,
-                    description=field_info.description,
-                    const=field_info.const,
-                    gt=field_info.gt,
-                    ge=field_info.ge,
-                    lt=field_info.lt,
-                    le=field_info.le,
-                    multiple_of=field_info.multiple_of,
-                    min_items=field_info.min_items,
-                    max_items=field_info.max_items,
-                    min_length=field_info.min_length,
-                    max_length=field_info.max_length,
-                    regex=field_info.regex,
-                    extra=field_info.extra,
-                )
-                fields[k] = (v.outer_type_, body)
+            for k, field_info in model.model_fields.items():
+                fields[k] = (field_info.annotation, field_info)
         return create_model(model_name, **fields, __base__=base_model)
 
     raise TypeError("Mixed Request Model types. Check extension request types.")
 
 
 def create_get_request_model(
-    extensions, base_model: BaseSearchGetRequest = BaseSearchGetRequest
-):
+    extensions: Optional[List[ApiExtension]],
+    base_model: BaseSearchGetRequest = BaseSearchGetRequest,
+) -> APIRequest:
     """Wrap create_request_model to create the GET request model."""
+
     return create_request_model(
         "SearchGetRequest",
         base_model=base_model,
@@ -90,8 +68,9 @@ def create_get_request_model(
 
 
 def create_post_request_model(
-    extensions, base_model: BaseSearchPostRequest = BaseSearchPostRequest
-):
+    extensions: Optional[List[ApiExtension]],
+    base_model: BaseSearchPostRequest = BaseSearchPostRequest,
+) -> Type[BaseModel]:
     """Wrap create_request_model to create the POST request model."""
     return create_request_model(
         "SearchPostRequest",

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi/api/openapi.py

@@ -1,4 +1,5 @@
 """openapi."""
+
 import warnings
 
 from fastapi import FastAPI
@@ -43,9 +44,7 @@ def update_openapi(app: FastAPI) -> FastAPI:
         # Get the response from the old endpoint function
         response: JSONResponse = await old_endpoint(req)
         # Update the content type header in place
-        response.headers[
-            "content-type"
-        ] = "application/vnd.oai.openapi+json;version=3.0"
+        response.headers["content-type"] = "application/vnd.oai.openapi+json;version=3.0"
         # Return the updated response
         return response
 

stac_fastapi_api-3.0.0a0/stac_fastapi/api/version.py

@@ -0,0 +1,2 @@
+"""Library version."""
+__version__ = "3.0.0a0"

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi.api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 2.5.5.post1
+Version: 3.0.0a0
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -18,9 +18,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: attrs
-Requires-Dist: pydantic[dotenv]<2
-Requires-Dist: stac_pydantic==2.0.*
 Requires-Dist: brotli_asgi
 Requires-Dist: stac-fastapi.types
 Provides-Extra: dev

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi.api.egg-info/SOURCES.txt

@@ -17,5 +17,7 @@ stac_fastapi/api/openapi.py
 stac_fastapi/api/routes.py
 stac_fastapi/api/version.py
 tests/test_api.py
+tests/test_app.py
 tests/test_app_prefix.py
-tests/test_middleware.py
+tests/test_middleware.py
+tests/test_models.py

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/stac_fastapi.api.egg-info/requires.txt

@@ -1,6 +1,3 @@
-attrs
-pydantic[dotenv]<2
-stac_pydantic==2.0.*
 brotli_asgi
 stac-fastapi.types
 

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/tests/test_api.py

@@ -41,11 +41,11 @@ class TestRouteDependencies:
                     method=route["method"].lower(),
                     url=path,
                     auth=("bob", "dobbs"),
-                    content='{"dummy": "payload"}',
+                    content=route["payload"],
                     headers={"content-type": "application/json"},
                 )
                 assert (
-                    response.status_code == 200
+                    200 <= response.status_code < 300
                 ), "Authenticated requests should be accepted"
                 assert response.json() == "dummy response"
 
@@ -58,27 +58,59 @@ class TestRouteDependencies:
                 == "application/vnd.oai.openapi+json;version=3.0"
             )
 
-    def test_build_api_with_route_dependencies(self):
+    def test_build_api_with_route_dependencies(self, collection, item):
         routes = [
-            {"path": "/collections", "method": "POST"},
-            {"path": "/collections/{collectionId}", "method": "PUT"},
-            {"path": "/collections/{collectionId}", "method": "DELETE"},
-            {"path": "/collections/{collectionId}/items", "method": "POST"},
-            {"path": "/collections/{collectionId}/items/{itemId}", "method": "PUT"},
-            {"path": "/collections/{collectionId}/items/{itemId}", "method": "DELETE"},
+            {"path": "/collections", "method": "POST", "payload": collection},
+            {
+                "path": "/collections/{collectionId}",
+                "method": "PUT",
+                "payload": collection,
+            },
+            {"path": "/collections/{collectionId}", "method": "DELETE", "payload": ""},
+            {
+                "path": "/collections/{collectionId}/items",
+                "method": "POST",
+                "payload": item,
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "PUT",
+                "payload": item,
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "DELETE",
+                "payload": "",
+            },
         ]
         dependencies = [Depends(must_be_bob)]
         api = self._build_api(route_dependencies=[(routes, dependencies)])
         self._assert_dependency_applied(api, routes)
 
-    def test_add_route_dependencies_after_building_api(self):
+    def test_add_route_dependencies_after_building_api(self, collection, item):
         routes = [
-            {"path": "/collections", "method": "POST"},
-            {"path": "/collections/{collectionId}", "method": "PUT"},
-            {"path": "/collections/{collectionId}", "method": "DELETE"},
-            {"path": "/collections/{collectionId}/items", "method": "POST"},
-            {"path": "/collections/{collectionId}/items/{itemId}", "method": "PUT"},
-            {"path": "/collections/{collectionId}/items/{itemId}", "method": "DELETE"},
+            {"path": "/collections", "method": "POST", "payload": collection},
+            {
+                "path": "/collections/{collectionId}",
+                "method": "PUT",
+                "payload": collection,
+            },
+            {"path": "/collections/{collectionId}", "method": "DELETE", "payload": ""},
+            {
+                "path": "/collections/{collectionId}/items",
+                "method": "POST",
+                "payload": item,
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "PUT",
+                "payload": item,
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "DELETE",
+                "payload": "",
+            },
         ]
         api = self._build_api()
         api.add_route_dependencies(scopes=routes, dependencies=[Depends(must_be_bob)])

stac_fastapi_api-3.0.0a0/tests/test_app.py

@@ -0,0 +1,188 @@
+from datetime import datetime
+from typing import List, Optional, Union
+
+import pytest
+from fastapi.testclient import TestClient
+from pydantic import ValidationError
+from stac_pydantic import api
+
+from stac_fastapi.api import app
+from stac_fastapi.api.models import create_get_request_model, create_post_request_model
+from stac_fastapi.extensions.core.filter.filter import FilterExtension
+from stac_fastapi.types import stac
+from stac_fastapi.types.config import ApiSettings
+from stac_fastapi.types.core import NumType
+from stac_fastapi.types.search import BaseSearchPostRequest
+
+
+def test_client_response_type(TestCoreClient):
+    """Test all GET endpoints. Verify that responses are valid STAC items."""
+
+    test_app = app.StacApi(
+        settings=ApiSettings(),
+        client=TestCoreClient(),
+    )
+
+    with TestClient(test_app.app) as client:
+        landing = client.get("/")
+        collection = client.get("/collections/test")
+        collections = client.get("/collections")
+        item = client.get("/collections/test/items/test")
+        item_collection = client.get(
+            "/collections/test/items",
+            params={"limit": 10},
+        )
+        get_search = client.get(
+            "/search",
+            params={
+                "collections": ["test"],
+            },
+        )
+        post_search = client.post(
+            "/search",
+            json={
+                "collections": ["test"],
+            },
+        )
+
+    assert landing.status_code == 200, landing.text
+    api.LandingPage(**landing.json())
+
+    assert collection.status_code == 200, collection.text
+    api.Collection(**collection.json())
+
+    assert collections.status_code == 200, collections.text
+    api.collections.Collections(**collections.json())
+
+    assert item.status_code == 200, item.text
+    api.Item(**item.json())
+
+    assert item_collection.status_code == 200, item_collection.text
+    api.ItemCollection(**item_collection.json())
+
+    assert get_search.status_code == 200, get_search.text
+    api.ItemCollection(**get_search.json())
+
+    assert post_search.status_code == 200, post_search.text
+    api.ItemCollection(**post_search.json())
+
+
+@pytest.mark.parametrize("validate", [True, False])
+def test_client_invalid_response_type(validate, TestCoreClient, item_dict):
+    """Check if the build in response validation switch works."""
+
+    class InValidResponseClient(TestCoreClient):
+        def get_item(self, item_id: str, collection_id: str, **kwargs) -> stac.Item:
+            item_dict.pop("bbox")
+            item_dict.pop("geometry")
+            return stac.Item(**item_dict)
+
+    test_app = app.StacApi(
+        settings=ApiSettings(enable_response_models=validate),
+        client=InValidResponseClient(),
+    )
+
+    with TestClient(test_app.app) as client:
+        item = client.get("/collections/test/items/test")
+
+    # Even if API validation passes, we should receive an invalid item
+    if item.status_code == 200:
+        with pytest.raises(ValidationError):
+            api.Item(**item.json())
+
+    # If internal validation is on, we should expect an internal error
+    if validate:
+        assert item.status_code == 500, item.text
+    else:
+        assert item.status_code == 200, item.text
+
+
+def test_client_openapi(TestCoreClient):
+    """Test if response models are all documented with OpenAPI."""
+
+    test_app = app.StacApi(
+        settings=ApiSettings(),
+        client=TestCoreClient(),
+    )
+    test_app.app.openapi()
+    components = ["LandingPage", "Collection", "Collections", "Item", "ItemCollection"]
+    for component in components:
+        assert component in test_app.app.openapi_schema["components"]["schemas"]
+
+
+def test_filter_extension(TestCoreClient, item_dict):
+    """Test if Filter Parameters are passed correctly."""
+
+    class FilterClient(TestCoreClient):
+        def post_search(
+            self, search_request: BaseSearchPostRequest, **kwargs
+        ) -> stac.ItemCollection:
+            search_request.collections = ["test"]
+            search_request.filter = {}
+            search_request.filter_crs = "EPSG:4326"
+            search_request.filter_lang = "cql2-text"
+
+            return stac.ItemCollection(
+                type="FeatureCollection", features=[stac.Item(**item_dict)]
+            )
+
+        def get_search(
+            self,
+            collections: Optional[List[str]] = None,
+            ids: Optional[List[str]] = None,
+            bbox: Optional[List[NumType]] = None,
+            intersects: Optional[str] = None,
+            datetime: Optional[Union[str, datetime]] = None,
+            limit: Optional[int] = 10,
+            filter: Optional[str] = None,
+            filter_crs: Optional[str] = None,
+            filter_lang: Optional[str] = None,
+            **kwargs,
+        ) -> stac.ItemCollection:
+            # Check if all filter parameters are passed correctly
+
+            assert filter == "TEST"
+
+            # FIXME: https://github.com/stac-utils/stac-fastapi/issues/638
+            # hyphen alias for filter_crs and filter_lang are currently not working
+            # Query parameters `filter-crs` and `filter-lang`
+            # should be recognized by the API
+            # They are present in the `request.query_params` but not in the `kwargs`
+
+            # assert filter_crs == "EPSG:4326"
+            # assert filter_lang == "cql2-text"
+
+            return stac.ItemCollection(
+                type="FeatureCollection", features=[stac.Item(**item_dict)]
+            )
+
+    post_request_model = create_post_request_model([FilterExtension()])
+
+    test_app = app.StacApi(
+        settings=ApiSettings(),
+        client=FilterClient(post_request_model=post_request_model),
+        search_get_request_model=create_get_request_model([FilterExtension()]),
+        search_post_request_model=post_request_model,
+    )
+
+    with TestClient(test_app.app) as client:
+        get_search = client.get(
+            "/search",
+            params={
+                "filter": "TEST",
+                "filter-crs": "EPSG:4326",
+                "filter-lang": "cql2-text",
+            },
+        )
+        post_search = client.post(
+            "/search",
+            json={
+                "collections": ["test"],
+                "filter": {},
+                "filter-crs": "EPSG:4326",
+                "filter-lang": "cql2-text",
+            },
+        )
+
+    assert get_search.status_code == 200, get_search.text
+    assert post_search.status_code == 200, post_search.text

{stac_fastapi_api-2.5.5.post1 → stac_fastapi_api-3.0.0a0}/tests/test_app_prefix.py

@@ -51,7 +51,7 @@ def test_api_prefix(TestCoreClient, prefix):
         collections = client.get(f"{prefix}/collections")
         assert collections.status_code == 200, collections.json()
         collection_id = collections.json()["collections"][0]["id"]
-        print(collections.json()["links"])
+
         collection = client.get(f"{prefix}/collections/{collection_id}")
         assert collection.status_code == 200, collection.json()
 

stac_fastapi_api-3.0.0a0/tests/test_models.py

@@ -0,0 +1,101 @@
+import json
+
+import pytest
+from pydantic import ValidationError
+
+from stac_fastapi.api.models import create_get_request_model, create_post_request_model
+from stac_fastapi.extensions.core.filter.filter import FilterExtension
+from stac_fastapi.extensions.core.sort.sort import SortExtension
+from stac_fastapi.types.search import BaseSearchGetRequest, BaseSearchPostRequest
+
+
+def test_create_get_request_model():
+    extensions = [FilterExtension()]
+    request_model = create_get_request_model(extensions, BaseSearchGetRequest)
+
+    model = request_model(
+        collections="test1,test2",
+        ids="test1,test2",
+        bbox="0,0,1,1",
+        intersects=json.dumps(
+            {
+                "type": "Polygon",
+                "coordinates": [[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]],
+            }
+        ),
+        datetime="2020-01-01T00:00:00Z",
+        limit=10,
+        filter="test==test",
+        # FIXME: https://github.com/stac-utils/stac-fastapi/issues/638
+        # hyphen aliases are not properly working
+        # **{"filter-crs": "epsg:4326", "filter-lang": "cql2-text"},
+    )
+
+    assert model.collections == ["test1", "test2"]
+    # assert model.filter_crs == "epsg:4326"
+
+
+@pytest.mark.parametrize(
+    "filter,passes",
+    [(None, True), ({"test": "test"}, True), ("test==test", False), ([], False)],
+)
+def test_create_post_request_model(filter, passes):
+    extensions = [FilterExtension()]
+    request_model = create_post_request_model(extensions, BaseSearchPostRequest)
+
+    if not passes:
+        with pytest.raises(ValidationError):
+            model = request_model(filter=filter)
+    else:
+        model = request_model(
+            collections=["test1", "test2"],
+            ids=["test1", "test2"],
+            bbox=[0, 0, 1, 1],
+            datetime="2020-01-01T00:00:00Z",
+            limit=10,
+            filter=filter,
+            **{"filter-crs": "epsg:4326", "filter-lang": "cql2-text"},
+        )
+
+        assert model.collections == ["test1", "test2"]
+        assert model.filter_crs == "epsg:4326"
+        assert model.filter == filter
+
+
+@pytest.mark.parametrize(
+    "sortby,passes",
+    [
+        (None, True),
+        (
+            [
+                {"field": "test", "direction": "asc"},
+                {"field": "test2", "direction": "desc"},
+            ],
+            True,
+        ),
+        ({"field": "test", "direction": "desc"}, False),
+        ("test", False),
+    ],
+)
+def test_create_post_request_model_nested_fields(sortby, passes):
+    extensions = [SortExtension()]
+    request_model = create_post_request_model(extensions, BaseSearchPostRequest)
+
+    if not passes:
+        with pytest.raises(ValidationError):
+            model = request_model(sortby=sortby)
+    else:
+        model = request_model(
+            collections=["test1", "test2"],
+            ids=["test1", "test2"],
+            bbox=[0, 0, 1, 1],
+            datetime="2020-01-01T00:00:00Z",
+            limit=10,
+            sortby=sortby,
+        )
+
+        assert model.collections == ["test1", "test2"]
+        if model.sortby is None:
+            assert sortby is None
+        else:
+            assert model.model_dump(mode="json")["sortby"] == sortby

stac_fastapi_api-2.5.5.post1/stac_fastapi/api/version.py

@@ -1,2 +0,0 @@
-"""Library version."""
-__version__ = "2.5.5.post1"