stac-fastapi.api 3.0.0a3__tar.gz → 3.0.0b1__tar.gz

{stac_fastapi_api-3.0.0a3 → stac_fastapi_api-3.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0a3
+Version: 3.0.0b1
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering

{stac_fastapi_api-3.0.0a3 → stac_fastapi_api-3.0.0b1}/stac_fastapi/api/app.py

@@ -18,18 +18,15 @@ from starlette.responses import JSONResponse, Response
 from stac_fastapi.api.errors import DEFAULT_STATUS_CODES, add_exception_handlers
 from stac_fastapi.api.middleware import CORSMiddleware, ProxyHeaderMiddleware
 from stac_fastapi.api.models import (
+    APIRequest,
     CollectionUri,
     EmptyRequest,
     GeoJSONResponse,
     ItemCollectionUri,
     ItemUri,
-    create_request_model,
 )
 from stac_fastapi.api.openapi import update_openapi
 from stac_fastapi.api.routes import Scope, add_route_dependencies, create_async_endpoint
-
-# TODO: make this module not depend on `stac_fastapi.extensions`
-from stac_fastapi.extensions.core import FieldsExtension, TokenPaginationExtension
 from stac_fastapi.types.config import ApiSettings, Settings
 from stac_fastapi.types.core import AsyncBaseCoreClient, BaseCoreClient
 from stac_fastapi.types.extension import ApiExtension
@@ -108,7 +105,10 @@ class StacApi:
     search_post_request_model: Type[BaseSearchPostRequest] = attr.ib(
         default=BaseSearchPostRequest
     )
-    pagination_extension = attr.ib(default=TokenPaginationExtension)
+    collections_get_request_model: Type[APIRequest] = attr.ib(default=EmptyRequest)
+    collection_get_request_model: Type[APIRequest] = attr.ib(default=CollectionUri)
+    items_get_request_model: Type[APIRequest] = attr.ib(default=ItemCollectionUri)
+    item_get_request_model: Type[APIRequest] = attr.ib(default=ItemUri)
     response_class: Type[Response] = attr.ib(default=JSONResponse)
     middlewares: List[Middleware] = attr.ib(
         default=attr.Factory(
@@ -211,7 +211,9 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.get_item, ItemUri),
+            endpoint=create_async_endpoint(
+                self.client.get_item, self.item_get_request_model
+            ),
         )
 
     def register_post_search(self):
@@ -220,15 +222,12 @@ class StacApi:
         Returns:
             None
         """
-        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(
-                (api.ItemCollection if not fields_ext else None)
-                if self.settings.enable_response_models
-                else None
-            ),
+            response_model=api.ItemCollection
+            if self.settings.enable_response_models
+            else None,
             responses={
                 200: {
                     "content": {
@@ -252,15 +251,12 @@ class StacApi:
         Returns:
             None
         """
-        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(
-                (api.ItemCollection if not fields_ext else None)
-                if self.settings.enable_response_models
-                else None
-            ),
+            response_model=api.ItemCollection
+            if self.settings.enable_response_models
+            else None,
             responses={
                 200: {
                     "content": {
@@ -302,7 +298,9 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.all_collections, EmptyRequest),
+            endpoint=create_async_endpoint(
+                self.client.all_collections, self.collections_get_request_model
+            ),
         )
 
     def register_get_collection(self):
@@ -329,7 +327,9 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.get_collection, CollectionUri),
+            endpoint=create_async_endpoint(
+                self.client.get_collection, self.collection_get_request_model
+            ),
         )
 
     def register_get_item_collection(self):
@@ -338,16 +338,6 @@ class StacApi:
         Returns:
             None
         """
-        pagination_extension = self.get_extension(self.pagination_extension)
-        if pagination_extension is not None:
-            mixins = [pagination_extension.GET]
-        else:
-            mixins = None
-        request_model = create_request_model(
-            "ItemCollectionURI",
-            base_model=ItemCollectionUri,
-            mixins=mixins,
-        )
         self.router.add_api_route(
             name="Get ItemCollection",
             path="/collections/{collection_id}/items",
@@ -366,7 +356,9 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.item_collection, request_model),
+            endpoint=create_async_endpoint(
+                self.client.item_collection, self.items_get_request_model
+            ),
         )
 
     def register_core(self):
@@ -439,11 +431,6 @@ 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.
 
@@ -483,8 +470,11 @@ class StacApi:
         self.app.openapi = self.customize_openapi
 
         # add middlewares
+        if self.middlewares and self.app.middleware_stack is not None:
+            raise RuntimeError("Cannot add middleware after an application has started")
+
         for middleware in self.middlewares:
-            self.add_middleware(middleware)
+            self.app.user_middleware.insert(0, middleware)
 
         # customize route dependencies
         for scopes, dependencies in self.route_dependencies:

{stac_fastapi_api-3.0.0a3 → stac_fastapi_api-3.0.0b1}/stac_fastapi/api/models.py

@@ -1,12 +1,12 @@
 """Api request/response models."""
 
-import importlib.util
+from dataclasses import dataclass, make_dataclass
 from typing import List, Optional, Type, Union
 
-import attr
-from fastapi import Path
+from fastapi import Path, Query
 from pydantic import BaseModel, create_model
 from stac_pydantic.shared import BBox
+from typing_extensions import Annotated
 
 from stac_fastapi.types.extension import ApiExtension
 from stac_fastapi.types.rfc3339 import DateTimeType
@@ -18,6 +18,12 @@ from stac_fastapi.types.search import (
     str_to_interval,
 )
 
+try:
+    import orjson  # noqa
+    from fastapi.responses import ORJSONResponse as JSONResponse
+except ImportError:  # pragma: nocover
+    from starlette.responses import JSONResponse
+
 
 def create_request_model(
     model_name="SearchGetRequest",
@@ -37,11 +43,11 @@ def create_request_model(
 
     mixins = mixins or []
 
-    models = [base_model] + extension_models + mixins
+    models = extension_models + mixins + [base_model]
 
     # Handle GET requests
     if all([issubclass(m, APIRequest) for m in models]):
-        return attr.make_class(model_name, attrs={}, bases=tuple(models))
+        return make_dataclass(model_name, [], bases=tuple(models))
 
     # Handle POST requests
     elif all([issubclass(m, BaseModel) for m in models]):
@@ -80,85 +86,52 @@ def create_post_request_model(
     )
 
 
-@attr.s  # type:ignore
+@dataclass
 class CollectionUri(APIRequest):
     """Get or delete collection."""
 
-    collection_id: str = attr.ib(default=Path(..., description="Collection ID"))
+    collection_id: Annotated[str, Path(description="Collection ID")]
 
 
-@attr.s
-class ItemUri(CollectionUri):
+@dataclass
+class ItemUri(APIRequest):
     """Get or delete item."""
 
-    item_id: str = attr.ib(default=Path(..., description="Item ID"))
+    collection_id: Annotated[str, Path(description="Collection ID")]
+    item_id: Annotated[str, Path(description="Item ID")]
 
 
-@attr.s
+@dataclass
 class EmptyRequest(APIRequest):
     """Empty request."""
 
     ...
 
 
-@attr.s
-class ItemCollectionUri(CollectionUri):
+@dataclass
+class ItemCollectionUri(APIRequest):
     """Get item collection."""
 
-    limit: int = attr.ib(default=10)
-    bbox: Optional[BBox] = attr.ib(default=None, converter=str2bbox)
-    datetime: Optional[DateTimeType] = attr.ib(default=None, converter=str_to_interval)
-
-
-class POSTTokenPagination(BaseModel):
-    """Token pagination model for POST requests."""
-
-    token: Optional[str] = None
-
-
-@attr.s
-class GETTokenPagination(APIRequest):
-    """Token pagination for GET requests."""
-
-    token: Optional[str] = attr.ib(default=None)
-
-
-class POSTPagination(BaseModel):
-    """Page based pagination for POST requests."""
+    collection_id: Annotated[str, Path(description="Collection ID")]
+    limit: Annotated[int, Query()] = 10
+    bbox: Annotated[Optional[BBox], Query()] = None
+    datetime: Annotated[Optional[DateTimeType], Query()] = None
 
-    page: Optional[str] = None
+    def __post_init__(self):
+        """convert attributes."""
+        if self.bbox:
+            self.bbox = str2bbox(self.bbox)  # type: ignore
+        if self.datetime:
+            self.datetime = str_to_interval(self.datetime)  # type: ignore
 
 
-@attr.s
-class GETPagination(APIRequest):
-    """Page based pagination for GET requests."""
-
-    page: Optional[str] = attr.ib(default=None)
-
-
-# Test for ORJSON and use it rather than stdlib JSON where supported
-if importlib.util.find_spec("orjson") is not None:
-    from fastapi.responses import ORJSONResponse
-
-    class GeoJSONResponse(ORJSONResponse):
-        """JSON with custom, vendor content-type."""
-
-        media_type = "application/geo+json"
-
-    class JSONSchemaResponse(ORJSONResponse):
-        """JSON with custom, vendor content-type."""
-
-        media_type = "application/schema+json"
-
-else:
-    from starlette.responses import JSONResponse
+class GeoJSONResponse(JSONResponse):
+    """JSON with custom, vendor content-type."""
 
-    class GeoJSONResponse(JSONResponse):
-        """JSON with custom, vendor content-type."""
+    media_type = "application/geo+json"
 
-        media_type = "application/geo+json"
 
-    class JSONSchemaResponse(JSONResponse):
-        """JSON with custom, vendor content-type."""
+class JSONSchemaResponse(JSONResponse):
+    """JSON with custom, vendor content-type."""
 
-        media_type = "application/schema+json"
+    media_type = "application/schema+json"

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

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

{stac_fastapi_api-3.0.0a3 → stac_fastapi_api-3.0.0b1}/stac_fastapi.api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0a3
+Version: 3.0.0b1
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering

{stac_fastapi_api-3.0.0a3 → stac_fastapi_api-3.0.0b1}/tests/test_api.py

@@ -2,6 +2,7 @@ from fastapi import Depends, HTTPException, security, status
 from starlette.testclient import TestClient
 
 from stac_fastapi.api.app import StacApi
+from stac_fastapi.api.models import ItemCollectionUri, create_request_model
 from stac_fastapi.extensions.core import (
     TokenPaginationExtension,
     TransactionExtension,
@@ -13,6 +14,13 @@ class TestRouteDependencies:
     @staticmethod
     def _build_api(**overrides):
         settings = config.ApiSettings()
+
+        items_get_request_model = create_request_model(
+            "ItemCollectionURI",
+            base_model=ItemCollectionUri,
+            mixins=[TokenPaginationExtension().GET],
+        )
+
         return StacApi(
             **{
                 "settings": settings,
@@ -23,6 +31,7 @@ class TestRouteDependencies:
                     ),
                     TokenPaginationExtension(),
                 ],
+                "items_get_request_model": items_get_request_model,
                 **overrides,
             }
         )

stac_fastapi_api-3.0.0b1/tests/test_app.py

@@ -0,0 +1,388 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional, Union
+
+import pytest
+from fastapi import Path, Query
+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 (
+    APIRequest,
+    JSONResponse,
+    create_get_request_model,
+    create_post_request_model,
+)
+from stac_fastapi.extensions.core import FieldsExtension, FilterExtension
+from stac_fastapi.types import stac
+from stac_fastapi.types.config import ApiSettings
+from stac_fastapi.types.core import BaseCoreClient, 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"]
+
+
+@pytest.mark.parametrize("validate", [True, False])
+def test_filter_extension(validate, 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(enable_response_models=validate),
+        client=FilterClient(post_request_model=post_request_model),
+        search_get_request_model=create_get_request_model([FilterExtension()]),
+        search_post_request_model=post_request_model,
+        extensions=[FilterExtension()],
+    )
+
+    with TestClient(test_app.app) as client:
+        landing = client.get("/")
+        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 landing.status_code == 200, landing.text
+    assert get_search.status_code == 200, get_search.text
+    assert post_search.status_code == 200, post_search.text
+
+
+@pytest.mark.parametrize("validate", [True, False])
+def test_fields_extension(validate, TestCoreClient, item_dict):
+    """Test if fields Parameters are passed correctly."""
+
+    class BadCoreClient(BaseCoreClient):
+        def post_search(
+            self, search_request: BaseSearchPostRequest, **kwargs
+        ) -> stac.ItemCollection:
+            resp = {"not": "a proper stac item"}
+
+            # if `fields` extension is enabled, then we return a JSONResponse
+            # to avoid Item validation
+            if getattr(search_request, "fields", None):
+                return JSONResponse(content=resp)
+
+            return resp
+
+        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,
+            **kwargs,
+        ) -> stac.ItemCollection:
+            resp = {"not": "a proper stac item"}
+
+            # if `fields` extension is enabled, then we return a JSONResponse
+            # to avoid Item validation
+            if "fields" in kwargs:
+                return JSONResponse(content=resp)
+
+            return resp
+
+        def get_item(self, item_id: str, collection_id: str, **kwargs) -> stac.Item:
+            raise NotImplementedError
+
+        def all_collections(self, **kwargs) -> stac.Collections:
+            raise NotImplementedError
+
+        def get_collection(self, collection_id: str, **kwargs) -> stac.Collection:
+            raise NotImplementedError
+
+        def item_collection(
+            self,
+            collection_id: str,
+            bbox: Optional[List[Union[float, int]]] = None,
+            datetime: Optional[Union[str, datetime]] = None,
+            limit: int = 10,
+            token: str = None,
+            **kwargs,
+        ) -> stac.ItemCollection:
+            raise NotImplementedError
+
+    # With FieldsExtension
+    test_app = app.StacApi(
+        settings=ApiSettings(enable_response_models=validate),
+        client=BadCoreClient(),
+        search_get_request_model=create_get_request_model([FieldsExtension()]),
+        search_post_request_model=create_post_request_model([FieldsExtension()]),
+        extensions=[FieldsExtension()],
+    )
+
+    with TestClient(test_app.app) as client:
+        get_search = client.get(
+            "/search",
+            params={"fields": "properties.datetime"},
+        )
+        post_search = client.post(
+            "/search",
+            json={
+                "collections": ["test"],
+                "fields": {
+                    "include": ["properties.datetime"],
+                    "exclude": [],
+                },
+            },
+        )
+
+    # With or without validation, /search endpoints will always return 200
+    # because we have the `FieldsExtension` enabled, so the endpoint
+    # will avoid the model validation (by returning JSONResponse)
+    assert get_search.status_code == 200, get_search.text
+    assert post_search.status_code == 200, post_search.text
+
+    # Without FieldsExtension
+    test_app = app.StacApi(
+        settings=ApiSettings(enable_response_models=validate),
+        client=BadCoreClient(),
+        search_get_request_model=create_get_request_model([]),
+        search_post_request_model=create_post_request_model([]),
+        extensions=[],
+    )
+
+    with TestClient(test_app.app) as client:
+        get_search = client.get(
+            "/search",
+            params={"fields": "properties.datetime"},
+        )
+        post_search = client.post(
+            "/search",
+            json={
+                "collections": ["test"],
+                "fields": {
+                    "include": ["properties.datetime"],
+                    "exclude": [],
+                },
+            },
+        )
+
+    if validate:
+        # NOTE: the `fields` options will be ignored by fastAPI because it's
+        # not part of the request model, so the client should not by-pass the validation
+        assert get_search.status_code == 500, (
+            get_search.json()["code"] == "ResponseValidationError"
+        )
+        assert post_search.status_code == 500, (
+            post_search.json()["code"] == "ResponseValidationError"
+        )
+    else:
+        assert get_search.status_code == 200, get_search.text
+        assert post_search.status_code == 200, post_search.text
+
+
+def test_request_model(AsyncTestCoreClient):
+    """Test if request models are passed correctly."""
+
+    @dataclass
+    class CollectionsRequest(APIRequest):
+        user: str = Query(...)
+
+    @dataclass
+    class CollectionRequest(APIRequest):
+        collection_id: str = Path(description="Collection ID")
+        user: str = Query(...)
+
+    @dataclass
+    class ItemsRequest(APIRequest):
+        collection_id: str = Path(description="Collection ID")
+        user: str = Query(...)
+
+    @dataclass
+    class ItemRequest(APIRequest):
+        collection_id: str = Path(description="Collection ID")
+        item_id: str = Path(description="Item ID")
+        user: str = Query(...)
+
+    test_app = app.StacApi(
+        settings=ApiSettings(),
+        client=AsyncTestCoreClient(),
+        collections_get_request_model=CollectionsRequest,
+        collection_get_request_model=CollectionRequest,
+        items_get_request_model=ItemsRequest,
+        item_get_request_model=ItemRequest,
+        extensions=[],
+    )
+
+    with TestClient(test_app.app) as client:
+        resp = client.get("/collections")
+        assert resp.status_code == 400
+
+        resp = client.get("/collections", params={"user": "Luke"})
+        assert resp.status_code == 200
+
+        resp = client.get("/collections/test_collection")
+        assert resp.status_code == 400
+
+        resp = client.get("/collections/test_collection", params={"user": "Leia"})
+        assert resp.status_code == 200
+
+        resp = client.get("/collections/test_collection/items")
+        assert resp.status_code == 400
+
+        resp = client.get(
+            "/collections/test_collection/items", params={"user": "Obi-Wan"}
+        )
+        assert resp.status_code == 200
+
+        resp = client.get("/collections/test_collection/items/test_item")
+        assert resp.status_code == 400
+
+        resp = client.get(
+            "/collections/test_collection/items/test_item", params={"user": "Chewbacca"}
+        )
+        assert resp.status_code == 200

{stac_fastapi_api-3.0.0a3 → stac_fastapi_api-3.0.0b1}/tests/test_middleware.py

@@ -1,6 +1,8 @@
 from unittest import mock
 
 import pytest
+from fastapi import Request
+from fastapi.responses import JSONResponse
 from starlette.applications import Starlette
 from starlette.testclient import TestClient
 
@@ -166,3 +168,31 @@ def test_cors_middleware(test_client):
     resp = test_client.get("/_mgmt/ping", headers={"Origin": "http://netloc"})
     assert resp.status_code == 200
     assert resp.headers["access-control-allow-origin"] == "*"
+
+
+def test_middleware_stack():
+    stac_api = StacApi(
+        settings=ApiSettings(), client=mock.create_autospec(BaseCoreClient)
+    )
+
+    def exception_handler(request: Request, exc: Exception) -> JSONResponse:
+        return JSONResponse(
+            status_code=400,
+            content={"customerrordetail": "yoo", "body": "yo"},
+        )
+
+    class CustomException(Exception):
+        "Custom Exception"
+
+        pass
+
+    stac_api.app.add_exception_handler(CustomException, exception_handler)
+
+    @stac_api.app.get("/error")
+    def error_endpoint():
+        raise CustomException("got you!")
+
+    with TestClient(stac_api.app) as client:
+        resp = client.get("/error")
+        assert resp.status_code == 400
+        assert resp.json()["customerrordetail"] == "yoo"

{stac_fastapi_api-3.0.0a3 → stac_fastapi_api-3.0.0b1}/tests/test_models.py

@@ -1,6 +1,8 @@
 import json
 
 import pytest
+from fastapi import Depends, FastAPI
+from fastapi.testclient import TestClient
 from pydantic import ValidationError
 
 from stac_fastapi.api.models import create_get_request_model, create_post_request_model
@@ -26,13 +28,33 @@ def test_create_get_request_model():
         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"},
+        filter_crs="epsg:4326",
+        filter_lang="cql2-text",
     )
 
     assert model.collections == ["test1", "test2"]
-    # assert model.filter_crs == "epsg:4326"
+    assert model.filter_crs == "epsg:4326"
+
+    app = FastAPI()
+
+    @app.get("/test")
+    def route(model=Depends(request_model)):
+        return model
+
+    with TestClient(app) as client:
+        resp = client.get(
+            "/test",
+            params={
+                "collections": "test1,test2",
+                "filter-crs": "epsg:4326",
+                "filter-lang": "cql2-text",
+            },
+        )
+        assert resp.status_code == 200
+        response_dict = resp.json()
+        assert response_dict["collections"] == ["test1", "test2"]
+        assert response_dict["filter_crs"] == "epsg:4326"
+        assert response_dict["filter_lang"] == "cql2-text"
 
 
 @pytest.mark.parametrize(

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

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

stac_fastapi_api-3.0.0a3/tests/test_app.py

@@ -1,192 +0,0 @@
-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"]
-
-
-@pytest.mark.parametrize("validate", [True, False])
-def test_filter_extension(validate, 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(enable_response_models=validate),
-        client=FilterClient(post_request_model=post_request_model),
-        search_get_request_model=create_get_request_model([FilterExtension()]),
-        search_post_request_model=post_request_model,
-        extensions=[FilterExtension()],
-    )
-
-    with TestClient(test_app.app) as client:
-        landing = client.get("/")
-        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 landing.status_code == 200, landing.text
-    assert get_search.status_code == 200, get_search.text
-    assert post_search.status_code == 200, post_search.text