stac-fastapi.api 3.0.0a2__tar.gz → 3.0.0a4__tar.gz

{stac_fastapi_api-3.0.0a2 → stac_fastapi_api-3.0.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0a2
+Version: 3.0.0a4
 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.0a2 → stac_fastapi_api-3.0.0a4}/stac_fastapi/api/app.py

@@ -439,11 +439,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.
 
@@ -458,10 +453,6 @@ class StacApi:
         self.client.title = self.title
         self.client.description = self.description
 
-        fields_ext = self.get_extension(FieldsExtension)
-        if fields_ext:
-            self.settings.default_includes = fields_ext.default_includes
-
         Settings.set(self.settings)
         self.app.state.settings = self.settings
 
@@ -487,8 +478,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.0a2 → stac_fastapi_api-3.0.0a4}/stac_fastapi/api/config.py

@@ -18,6 +18,7 @@ class ApiExtensions(enum.Enum):
     query = "query"
     sort = "sort"
     transaction = "transaction"
+    aggregation = "aggregation"
 
 
 class AddOns(enum.Enum):

{stac_fastapi_api-3.0.0a2 → stac_fastapi_api-3.0.0a4}/stac_fastapi/api/routes.py

@@ -1,5 +1,6 @@
 """Route factories."""
 
+import copy
 import functools
 import inspect
 import warnings
@@ -100,15 +101,28 @@ def add_route_dependencies(
     Allows a developer to add dependencies to a route after the route has been
     defined.
 
+    "*" can be used for path or method to match all allowed routes.
+
     Returns:
         None
     """
     for scope in scopes:
+        _scope = copy.deepcopy(scope)
         for route in routes:
-            match, _ = route.matches({"type": "http", **scope})
+            if scope["path"] == "*":
+                _scope["path"] = route.path
+
+            if scope["method"] == "*":
+                _scope["method"] = list(route.methods)[0]
+
+            match, _ = route.matches({"type": "http", **_scope})
             if match != Match.FULL:
                 continue
 
+            # Ignore paths without dependants, e.g. /api, /api.html, /docs/oauth2-redirect
+            if not hasattr(route, "dependant"):
+                continue
+
             # Mimicking how APIRoute handles dependencies:
             # https://github.com/tiangolo/fastapi/blob/1760da0efa55585c19835d81afa8ca386036c325/fastapi/routing.py#L408-L412
             for depends in dependencies[::-1]:

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

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

{stac_fastapi_api-3.0.0a2 → stac_fastapi_api-3.0.0a4}/stac_fastapi.api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0a2
+Version: 3.0.0a4
 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.0a4/tests/test_api.py

@@ -0,0 +1,447 @@
+from fastapi import Depends, HTTPException, security, status
+from starlette.testclient import TestClient
+
+from stac_fastapi.api.app import StacApi
+from stac_fastapi.extensions.core import (
+    TokenPaginationExtension,
+    TransactionExtension,
+)
+from stac_fastapi.types import config, core
+
+
+class TestRouteDependencies:
+    @staticmethod
+    def _build_api(**overrides):
+        settings = config.ApiSettings()
+        return StacApi(
+            **{
+                "settings": settings,
+                "client": DummyCoreClient(),
+                "extensions": [
+                    TransactionExtension(
+                        client=DummyTransactionsClient(), settings=settings
+                    ),
+                    TokenPaginationExtension(),
+                ],
+                **overrides,
+            }
+        )
+
+    @staticmethod
+    def _assert_dependency_applied(api, routes):
+        with TestClient(api.app) as client:
+            for route in routes:
+                response = getattr(client, route["method"].lower())(route["path"])
+                assert (
+                    response.status_code == 401
+                ), "Unauthenticated requests should be rejected"
+                assert response.json() == {"detail": "Not authenticated"}
+
+                path = route["path"].format(
+                    collectionId="test_collection", itemId="test_item"
+                )
+                response = client.request(
+                    method=route["method"].lower(),
+                    url=path,
+                    auth=("bob", "dobbs"),
+                    content=route["payload"],
+                    headers={"content-type": "application/json"},
+                )
+                assert (
+                    200 <= response.status_code < 300
+                ), "Authenticated requests should be accepted"
+                assert response.json() == "dummy response"
+
+    @staticmethod
+    def _assert_dependency_not_applied(api, routes):
+        with TestClient(api.app) as client:
+            for route in routes:
+                path = route["path"].format(
+                    collectionId="test_collection", itemId="test_item"
+                )
+                response = client.request(
+                    method=route["method"].lower(),
+                    url=path,
+                    content=route["payload"],
+                    headers={"content-type": "application/json"},
+                )
+                assert (
+                    200 <= response.status_code < 300
+                ), "Authenticated requests should be accepted"
+                assert response.json() == "dummy response"
+
+    def test_openapi_content_type(self):
+        api = self._build_api()
+        with TestClient(api.app) as client:
+            response = client.get(api.settings.openapi_url)
+            assert (
+                response.headers["content-type"]
+                == "application/vnd.oai.openapi+json;version=3.0"
+            )
+
+    def test_build_api_with_route_dependencies(self, collection, item):
+        routes = [
+            {"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, collection, item):
+        routes = [
+            {"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)])
+        self._assert_dependency_applied(api, routes)
+
+    def test_build_api_with_default_route_dependencies(self, collection, item):
+        routes = [{"path": "*", "method": "*"}]
+        test_routes = [
+            {"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, test_routes)
+
+    def test_build_api_with_default_path_route_dependencies(self, collection, item):
+        routes = [{"path": "*", "method": "POST"}]
+        test_routes = [
+            {
+                "path": "/collections",
+                "method": "POST",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}/items",
+                "method": "POST",
+                "payload": item,
+            },
+        ]
+        test_not_routes = [
+            {
+                "path": "/collections/{collectionId}",
+                "method": "PUT",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}",
+                "method": "DELETE",
+                "payload": "",
+            },
+            {
+                "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, test_routes)
+        self._assert_dependency_not_applied(api, test_not_routes)
+
+    def test_build_api_with_default_method_route_dependencies(self, collection, item):
+        routes = [
+            {
+                "path": "/collections/{collectionId}",
+                "method": "*",
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "*",
+            },
+        ]
+        test_routes = [
+            {
+                "path": "/collections/{collectionId}",
+                "method": "PUT",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}",
+                "method": "DELETE",
+                "payload": "",
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "PUT",
+                "payload": item,
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "DELETE",
+                "payload": "",
+            },
+        ]
+        test_not_routes = [
+            {
+                "path": "/collections",
+                "method": "POST",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}/items",
+                "method": "POST",
+                "payload": item,
+            },
+        ]
+        dependencies = [Depends(must_be_bob)]
+        api = self._build_api(route_dependencies=[(routes, dependencies)])
+        self._assert_dependency_applied(api, test_routes)
+        self._assert_dependency_not_applied(api, test_not_routes)
+
+    def test_add_default_route_dependencies_after_building_api(self, collection, item):
+        routes = [{"path": "*", "method": "*"}]
+        test_routes = [
+            {
+                "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)])
+        self._assert_dependency_applied(api, test_routes)
+
+    def test_add_default_path_route_dependencies_after_building_api(
+        self, collection, item
+    ):
+        routes = [{"path": "*", "method": "POST"}]
+        test_routes = [
+            {
+                "path": "/collections",
+                "method": "POST",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}/items",
+                "method": "POST",
+                "payload": item,
+            },
+        ]
+        test_not_routes = [
+            {
+                "path": "/collections/{collectionId}",
+                "method": "PUT",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}",
+                "method": "DELETE",
+                "payload": "",
+            },
+            {
+                "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)])
+        self._assert_dependency_applied(api, test_routes)
+        self._assert_dependency_not_applied(api, test_not_routes)
+
+    def test_add_default_method_route_dependencies_after_building_api(
+        self, collection, item
+    ):
+        routes = [
+            {
+                "path": "/collections/{collectionId}",
+                "method": "*",
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "*",
+            },
+        ]
+        test_routes = [
+            {
+                "path": "/collections/{collectionId}",
+                "method": "PUT",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}",
+                "method": "DELETE",
+                "payload": "",
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "PUT",
+                "payload": item,
+            },
+            {
+                "path": "/collections/{collectionId}/items/{itemId}",
+                "method": "DELETE",
+                "payload": "",
+            },
+        ]
+        test_not_routes = [
+            {
+                "path": "/collections",
+                "method": "POST",
+                "payload": collection,
+            },
+            {
+                "path": "/collections/{collectionId}/items",
+                "method": "POST",
+                "payload": item,
+            },
+        ]
+        api = self._build_api()
+        api.add_route_dependencies(scopes=routes, dependencies=[Depends(must_be_bob)])
+        self._assert_dependency_applied(api, test_routes)
+        self._assert_dependency_not_applied(api, test_not_routes)
+
+
+class DummyCoreClient(core.BaseCoreClient):
+    def all_collections(self, *args, **kwargs):
+        ...
+
+    def get_collection(self, *args, **kwargs):
+        ...
+
+    def get_item(self, *args, **kwargs):
+        ...
+
+    def get_search(self, *args, **kwargs):
+        ...
+
+    def post_search(self, *args, **kwargs):
+        ...
+
+    def item_collection(self, *args, **kwargs):
+        ...
+
+
+class DummyTransactionsClient(core.BaseTransactionsClient):
+    """Defines a pattern for implementing the STAC transaction extension."""
+
+    def create_item(self, *args, **kwargs):
+        return "dummy response"
+
+    def update_item(self, *args, **kwargs):
+        return "dummy response"
+
+    def delete_item(self, *args, **kwargs):
+        return "dummy response"
+
+    def create_collection(self, *args, **kwargs):
+        return "dummy response"
+
+    def update_collection(self, *args, **kwargs):
+        return "dummy response"
+
+    def delete_collection(self, *args, **kwargs):
+        return "dummy response"
+
+
+def must_be_bob(
+    credentials: security.HTTPBasicCredentials = Depends(security.HTTPBasic()),
+):
+    if credentials.username == "bob":
+        return True
+
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="You're not Bob",
+        headers={"WWW-Authenticate": "Basic"},
+    )

{stac_fastapi_api-3.0.0a2 → stac_fastapi_api-3.0.0a4}/tests/test_app.py

@@ -8,10 +8,10 @@ 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.extensions.core import FieldsExtension, 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.core import BaseCoreClient, NumType
 from stac_fastapi.types.search import BaseSearchPostRequest
 
 
@@ -190,3 +190,107 @@ def test_filter_extension(validate, TestCoreClient, item_dict):
     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:
+            return {"not": "a proper stac item"}
+
+        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:
+            return {"not": "a proper stac item"}
+
+        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
+
+    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": [],
+                },
+            },
+        )
+
+    assert get_search.status_code == 200, get_search.text
+    assert post_search.status_code == 200, post_search.text
+
+    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=[],
+    )
+
+    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:
+        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

{stac_fastapi_api-3.0.0a2 → stac_fastapi_api-3.0.0a4}/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.0a2/stac_fastapi/api/version.py

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

stac_fastapi_api-3.0.0a2/tests/test_api.py

@@ -1,172 +0,0 @@
-from fastapi import Depends, HTTPException, security, status
-from starlette.testclient import TestClient
-
-from stac_fastapi.api.app import StacApi
-from stac_fastapi.extensions.core import TokenPaginationExtension, TransactionExtension
-from stac_fastapi.types import config, core
-
-
-class TestRouteDependencies:
-    @staticmethod
-    def _build_api(**overrides):
-        settings = config.ApiSettings()
-        return StacApi(
-            **{
-                "settings": settings,
-                "client": DummyCoreClient(),
-                "extensions": [
-                    TransactionExtension(
-                        client=DummyTransactionsClient(), settings=settings
-                    ),
-                    TokenPaginationExtension(),
-                ],
-                **overrides,
-            }
-        )
-
-    @staticmethod
-    def _assert_dependency_applied(api, routes):
-        with TestClient(api.app) as client:
-            for route in routes:
-                response = getattr(client, route["method"].lower())(route["path"])
-                assert (
-                    response.status_code == 401
-                ), "Unauthenticated requests should be rejected"
-                assert response.json() == {"detail": "Not authenticated"}
-
-                path = route["path"].format(
-                    collectionId="test_collection", itemId="test_item"
-                )
-                response = client.request(
-                    method=route["method"].lower(),
-                    url=path,
-                    auth=("bob", "dobbs"),
-                    content=route["payload"],
-                    headers={"content-type": "application/json"},
-                )
-                assert (
-                    200 <= response.status_code < 300
-                ), "Authenticated requests should be accepted"
-                assert response.json() == "dummy response"
-
-    def test_openapi_content_type(self):
-        api = self._build_api()
-        with TestClient(api.app) as client:
-            response = client.get(api.settings.openapi_url)
-            assert (
-                response.headers["content-type"]
-                == "application/vnd.oai.openapi+json;version=3.0"
-            )
-
-    def test_build_api_with_route_dependencies(self, collection, item):
-        routes = [
-            {"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, collection, item):
-        routes = [
-            {"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)])
-        self._assert_dependency_applied(api, routes)
-
-
-class DummyCoreClient(core.BaseCoreClient):
-    def all_collections(self, *args, **kwargs):
-        ...
-
-    def get_collection(self, *args, **kwargs):
-        ...
-
-    def get_item(self, *args, **kwargs):
-        ...
-
-    def get_search(self, *args, **kwargs):
-        ...
-
-    def post_search(self, *args, **kwargs):
-        ...
-
-    def item_collection(self, *args, **kwargs):
-        ...
-
-
-class DummyTransactionsClient(core.BaseTransactionsClient):
-    """Defines a pattern for implementing the STAC transaction extension."""
-
-    def create_item(self, *args, **kwargs):
-        return "dummy response"
-
-    def update_item(self, *args, **kwargs):
-        return "dummy response"
-
-    def delete_item(self, *args, **kwargs):
-        return "dummy response"
-
-    def create_collection(self, *args, **kwargs):
-        return "dummy response"
-
-    def update_collection(self, *args, **kwargs):
-        return "dummy response"
-
-    def delete_collection(self, *args, **kwargs):
-        return "dummy response"
-
-
-def must_be_bob(
-    credentials: security.HTTPBasicCredentials = Depends(security.HTTPBasic()),
-):
-    if credentials.username == "bob":
-        return True
-
-    raise HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="You're not Bob",
-        headers={"WWW-Authenticate": "Basic"},
-    )