overhaul the main router as APIRouter, product router not a factory, add product router classmethod to main router

austin-sidekick · austin-sidekick · commit 3139ec478362 · 2024-10-09T14:24:24.000-07:00
diff --git a/conftest.py b/conftest.py
@@ -1,12 +1,20 @@
-from typing import Callable, Generator, TypeVar
+from typing import Callable, Generator, TypeVar, List
 from urllib.parse import urljoin
+from uuid import uuid4
+import pytest
+from datetime import datetime, timezone, timedelta
+from geojson_pydantic import Point
 
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 from pytest import Parser, fixture
 
+from stapi_fastapi.models.product import Product, Provider, ProviderRole
 from stapi_fastapi.main_router import MainRouter
 from stapi_fastapi_test_backend import TestBackend
+from stapi_fastapi.models.shared import Link
+from stapi_fastapi.models.opportunity import OpportunityProperties, Opportunity
+from stapi_fastapi.types.datetime_interval import DatetimeInterval
 
 T = TypeVar("T")
 
@@ -54,3 +62,60 @@ def url_for(value: str) -> str:
         return urljoin(with_trailing_slash(base_url), f"./{value.lstrip('/')}")
 
     yield url_for
+
+@pytest.fixture
+def mock_provider_umbra() -> Provider:
+    return Provider(
+        name="Umbra Provider",
+        description="A provider for Umbra data",
+        roles=[ProviderRole.producer],  # Example role
+        url="https://umbra-provider.example.com"  # Must be a valid URL
+    )
+
+# Define a mock OpportunityProperties class for Umbra
+class UmbraSpotlightProperties(OpportunityProperties):
+    datetime: DatetimeInterval
+
+@pytest.fixture
+def mock_product_umbra_spotlight(mock_provider_umbra: Provider) -> Product:
+    """Fixture for a mock Umbra Spotlight product."""
+
+    return Product(
+        id=str(uuid4()),
+        title="Umbra Spotlight Product",
+        description="Test product for umbra spotlight",
+        license="CC-BY-4.0",
+        keywords=["test", "umbra", "satellite"],
+        providers=[mock_provider_umbra],
+        links=[
+            Link(href="http://example.com", rel="self"),
+            Link(href="http://example.com/catalog", rel="parent"),
+        ],
+        parameters=UmbraSpotlightProperties
+    )
+
+@pytest.fixture
+def mock_products(mock_product_umbra_spotlight: Product) -> List[Product]:
+    """Fixture to return a list of mock products."""
+    return [mock_product_umbra_spotlight]
+
+@pytest.fixture
+def mock_umbra_spotlight_opportunities() -> List[Opportunity]:
+    """Fixture to create mock data for Opportunities for `umbra-spotlight-1`."""
+    now = datetime.now(timezone.utc)  # Use timezone-aware datetime
+    start = now
+    end = start + timedelta(days=5)
+    datetime_interval = f"{start.isoformat()}/{end.isoformat()}"
+
+    # Create a list of mock opportunities for the given product
+    return [
+        Opportunity(
+            id=str(uuid4()),
+            type="Feature",
+            geometry=Point(type="Point", coordinates=[0, 0]),  # Simple point geometry
+            properties=UmbraSpotlightProperties(
+                datetime=datetime_interval,
+                off_nadir=20,
+            ),
+        ),
+    ]
diff --git a/stapi_fastapi/main_router.py b/stapi_fastapi/main_router.py
@@ -1,3 +1,4 @@
+from typing import Self, Optional
 from fastapi import APIRouter, HTTPException, Request, status
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse
@@ -14,91 +15,65 @@
 from stapi_fastapi.models.root import RootResponse
 from stapi_fastapi.models.shared import HTTPException as HTTPExceptionModel
 from stapi_fastapi.models.shared import Link
+from stapi_fastapi.products_router import ProductRouter
 
 """
 /products/{component router} # router for each product added to main router
 /orders # list all orders
 """
-class MainRouter:
-    NAME_PREFIX = "main"
-    backend: StapiBackend
-    openapi_endpoint_name: str
-    docs_endpoint_name: str
-    router: APIRouter
+class MainRouter(APIRouter):
 
     def __init__(
-        self,
+        self: Self,
         backend: StapiBackend,
-        openapi_endpoint_name="openapi",
-        docs_endpoint_name="swagger_ui_html",
+        name: str = "main",
+        openapi_endpoint_name: str = "openapi",
+        docs_endpoint_name: str = "swagger_ui_html",
         *args,
         **kwargs,
     ):
+        super().__init__(*args, **kwargs)
         self.backend = backend
+        self.name = name
         self.openapi_endpoint_name = openapi_endpoint_name
         self.docs_endpoint_name = docs_endpoint_name
 
-        self.router = APIRouter(*args, **kwargs)
-        self.router.add_api_route(
+        self.product_routers: dict[str, ProductRouter] = {}
+
+        self.add_api_route(
             "/",
             self.root,
             methods=["GET"],
-            name=f"{self.NAME_PREFIX}:root",
+            name=f"{self.name}:root",
             tags=["Root"],
         )
 
-        self.router.add_api_route(
+        self.add_api_route(
             "/products",
             self.products,
             methods=["GET"],
-            name=f"{self.NAME_PREFIX}:list-products",
-            tags=["Product"],
-        )
-
-        self.router.add_api_route(
-            "/products/{product_id}",
-            self.product,
-            methods=["GET"],
-            name=f"{self.NAME_PREFIX}:get-product",
+            name=f"{self.name}:list-products",
             tags=["Product"],
-            responses={status.HTTP_404_NOT_FOUND: {"model": HTTPExceptionModel}},
         )
 
-        self.router.add_api_route(
-            "/opportunities",
-            self.search_opportunities,
-            methods=["POST"],
-            name=f"{self.NAME_PREFIX}:search-opportunities",
-            tags=["Opportunities"],
-        )
-
-        self.router.add_api_route(
-            "/orders",
-            self.create_order,
-            methods=["POST"],
-            name=f"{self.NAME_PREFIX}:create-order",
-            tags=["Orders"],
-            response_model=Order,
-        )
-
-        self.router.add_api_route(
+        self.add_api_route(
             "/orders/{order_id}",
             self.get_order,
             methods=["GET"],
-            name=f"{self.NAME_PREFIX}:get-order",
+            name=f"{self.name}:get-order",
             tags=["Orders"],
         )
 
     def root(self, request: Request) -> RootResponse:
         return RootResponse(
             links=[
                 Link(
-                    href=str(request.url_for(f"{self.NAME_PREFIX}:root")),
+                    href=str(request.url_for(f"{self.name}:root")),
                     rel="self",
                     type=TYPE_JSON,
                 ),
                 Link(
-                    href=str(request.url_for(f"{self.NAME_PREFIX}:list-products")),
+                    href=str(request.url_for(f"{self.name}:list-products")),
                     rel="products",
                     type=TYPE_JSON,
                 ),
@@ -122,7 +97,7 @@ def products(self, request: Request) -> ProductsCollection:
                 Link(
                     href=str(
                         request.url_for(
-                            f"{self.NAME_PREFIX}:get-product", product_id=product.id
+                            f"{self.name}:get-product", product_id=product.id
                         )
                     ),
                     rel="self",
@@ -133,70 +108,13 @@ def products(self, request: Request) -> ProductsCollection:
             products=products,
             links=[
                 Link(
-                    href=str(request.url_for(f"{self.NAME_PREFIX}:list-products")),
+                    href=str(request.url_for(f"{self.name}:list-products")),
                     rel="self",
                     type=TYPE_JSON,
                 )
             ],
         )
 
-    def product(self, product_id: str, request: Request) -> Product:
-        try:
-            product = self.backend.product(product_id, request)
-        except NotFoundException as exc:
-            raise StapiException(
-                status.HTTP_404_NOT_FOUND, "product not found"
-            ) from exc
-        product.links.append(
-            Link(
-                href=str(
-                    request.url_for(
-                        f"{self.NAME_PREFIX}:get-product", product_id=product.id
-                    )
-                ),
-                rel="self",
-                type=TYPE_JSON,
-            )
-        )
-        return product
-
-    async def search_opportunities(
-        self, search: OpportunityRequest, request: Request
-    ) -> OpportunityCollection:
-        """
-        Explore the opportunities available for a particular set of constraints
-        """
-        try:
-            opportunities = await self.backend.search_opportunities(search, request)
-        except ConstraintsException as exc:
-            raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, detail=exc.detail)
-        return JSONResponse(
-            jsonable_encoder(OpportunityCollection(features=opportunities)),
-            media_type=TYPE_GEOJSON,
-        )
-
-    async def create_order(
-        self, search: OpportunityRequest, request: Request
-    ) -> JSONResponse:
-        """
-        Create a new order.
-        """
-        try:
-            order = await self.backend.create_order(search, request)
-        except ConstraintsException as exc:
-            raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, detail=exc.detail)
-
-        location = str(
-            request.url_for(f"{self.NAME_PREFIX}:get-order", order_id=order.id)
-        )
-        order.links.append(Link(href=location, rel="self", type=TYPE_GEOJSON))
-        return JSONResponse(
-            jsonable_encoder(order, exclude_unset=True),
-            status.HTTP_201_CREATED,
-            {"Location": location},
-            TYPE_GEOJSON,
-        )
-
     async def get_order(self, order_id: str, request: Request) -> Order:
         """
         Get details for order with `order_id`.
@@ -213,3 +131,8 @@ async def get_order(self, order_id: str, request: Request) -> Order:
             status.HTTP_200_OK,
             media_type=TYPE_GEOJSON,
         )
+
+    def add_product_router(self, product_router: ProductRouter):
+        # Give the include a prefix from the product router
+        self.include_router(product_router, prefix=product_router.product.id)
+        self.product_routers[product_router.product.id] = product_router
diff --git a/stapi_fastapi/models/opportunity.py b/stapi_fastapi/models/opportunity.py
@@ -20,7 +20,7 @@ class OpportunityRequest(BaseModel):
     geometry: Geometry
     # TODO: validate the CQL2 filter?
     filter: Optional[CQL2Filter] = None
-    # PHILOSOPH: strict?
+    model_config = ConfigDict(strict=True)
 
 # Generic type definition for Opportunity
 P = TypeVar("P", bound=OpportunityProperties)
@@ -30,6 +30,5 @@ class OpportunityRequest(BaseModel):
 class Opportunity(Feature[K, P], Generic[K, P]):
     type: Literal["Feature"] = "Feature"
 
-
-class OpportunityCollection(FeatureCollection[Opportunity]):
+class OpportunityCollection(FeatureCollection[Opportunity[K, P]], Generic[K, P]):
     type: Literal["FeatureCollection"] = "FeatureCollection"
diff --git a/stapi_fastapi/models/product.py b/stapi_fastapi/models/product.py
@@ -1,10 +1,13 @@
 from enum import Enum
 from typing import Literal, Optional
+from abc import ABC, abstractmethod
+from fastapi import Request
 
 from pydantic import AnyHttpUrl, BaseModel, Field
 
 from stapi_fastapi.models.shared import Link
-from stapi_fastapi.types.json_schema_model import JsonSchemaModel
+from stapi_fastapi.models.opportunity import Opportunity, OpportunityProperties, OpportunityRequest
+from stapi_fastapi.models.order import Order
 
 
 class ProviderRole(str, Enum):
@@ -21,7 +24,7 @@ class Provider(BaseModel):
     url: AnyHttpUrl
 
 
-class Product(BaseModel):
+class Product(BaseModel, ABC):
     type: Literal["Product"] = "Product"
     conformsTo: list[str] = Field(default_factory=list)
     id: str
@@ -31,8 +34,28 @@ class Product(BaseModel):
     license: str
     providers: list[Provider] = Field(default_factory=list)
     links: list[Link]
-    parameters: JsonSchemaModel
-
+    parameters: OpportunityProperties
+
+    @abstractmethod
+    def search_opportunities(self, search: OpportunityRequest, request: Request
+    ) -> list[Opportunity]:
+        """
+        Search for ordering opportunities for the  given search parameters.
+
+        Backends must validate search constraints and raise
+        `stapi_fastapi.backend.exceptions.ConstraintsException` if not valid.
+        """
+        ...
+
+    @abstractmethod
+    def create_order(self, search: OpportunityRequest, request: Request) -> Order:
+        """
+        Create a new order.
+
+        Backends must validate order payload and raise
+        `stapi_fastapi.backend.exceptions.ConstraintsException` if not valid.
+        """
+        ...
 
 class ProductsCollection(BaseModel):
     type: Literal["ProductCollection"] = "ProductCollection"
diff --git a/stapi_fastapi/products_router.py b/stapi_fastapi/products_router.py
diff --git a/tests/opportunity_test.py b/tests/opportunity_test.py
