the /products/{product_id}/opportunities endpoint is accessible

Author: austin-sidekick

src/stapi_fastapi/main_router.py

@@ -51,7 +51,7 @@ def __init__(
         self.add_api_route(
             "/products",
             self.products,
-            methods=["GET"],
+            methods=["GET","POST"],
             name=f"{self.name}:list-products",
             tags=["Product"],
         )
@@ -134,5 +134,5 @@ async def get_order(self, order_id: str, request: Request) -> Order:
 
     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.include_router(product_router, prefix=f"/products/{product_router.product.id}")
         self.product_routers[product_router.product.id] = product_router

src/stapi_fastapi/products_router.py

@@ -23,10 +23,26 @@ def __init__(
         super().__init__(*args, **kwargs)
         self.product = product
 
-        # TODO: use add_api_route
-        self.post("/opportunities", summary="Search Opportunities for the product")(self.search_opportunities)
-        self.get("/parameters", summary="Get parameters for the product")(self.get_product_parameters)
-        self.post("/order", summary="Create an order for the product")(self.create_order)
+        self.add_api_route(
+            path="/opportunities",
+            endpoint=self.search_opportunities,
+            methods=["POST"],
+            summary="Search Opportunities for the product"
+        )
+
+        self.add_api_route(
+            path="/parameters",
+            endpoint=self.get_product_parameters,
+            methods=["GET"],
+            summary="Get parameters for the product"
+        )
+
+        self.add_api_route(
+            path="/order",
+            endpoint=self.create_order,
+            methods=["POST"],
+            summary="Create an order for the product"
+        )
 
     async def search_opportunities(self: Self, request: Request, search: OpportunityRequest):
         try:

tests/conftest.py

@@ -12,29 +12,32 @@
 from stapi_fastapi.types.datetime_interval import DatetimeInterval
 
 from collections.abc import Iterator
-from fastapi import FastAPI
 from fastapi.testclient import TestClient
-from pydantic import BaseModel
 from stapi_fastapi.products_router import ProductRouter
+from stapi_fastapi.main_router import MainRouter
 
 from .backend import TestBackend
 
+# Define concrete classes for Products to mock
+class UmbraSpotlight(Product):
+    def search_opportunities(self, search, request):
+        return []
+    def create_order(self, search, request):
+        return []
 
-@pytest.fixture(scope="session")
-def base_url() -> Iterator[str]:
-    yield "http://stapiserver"
-
-
-@pytest.fixture
-def stapi_backend() -> Iterator[TestBackend]:
-    yield TestBackend()
+class UmbraSpotlightProperties(OpportunityProperties):
+    datetime: DatetimeInterval
 
 @pytest.fixture
 def mock_product_umbra_spotlight(mock_provider_umbra: Provider) -> Product:
     """Fixture for a mock Umbra Spotlight product."""
+    now = datetime.now(timezone.utc)  # Use timezone-aware datetime
+    start = now
+    end = start + timedelta(days=5)
+    datetime_interval = f"{start.isoformat()}/{end.isoformat()}"
 
-    return Product(
-        id=str(uuid4()),
+    return UmbraSpotlight(
+        id="umbra-spotlight",
         title="Umbra Spotlight Product",
         description="Test product for umbra spotlight",
         license="CC-BY-4.0",
@@ -44,16 +47,27 @@ def mock_product_umbra_spotlight(mock_provider_umbra: Provider) -> Product:
             Link(href="http://example.com", rel="self"),
             Link(href="http://example.com/catalog", rel="parent"),
         ],
-        parameters=UmbraSpotlightProperties
+        parameters=UmbraSpotlightProperties(
+                datetime=datetime_interval,
+                off_nadir=20,
+            )
     )
 
+@pytest.fixture(scope="session")
+def base_url() -> Iterator[str]:
+    yield "http://stapiserver"
+
+
+@pytest.fixture
+def stapi_backend() -> Iterator[TestBackend]:
+    yield TestBackend()
+
 @pytest.fixture
-def stapi_client(stapi_backend, base_url: str) -> Iterator[TestClient]:
-    app = FastAPI()
+def stapi_client(stapi_backend, mock_product_umbra_spotlight, base_url: str) -> Iterator[TestClient]:
+    app = MainRouter(stapi_backend)
 
-    app.include_router(
-        ProductRouter(mock_product_umbra_spotlight),
-        prefix="",
+    app.add_product_router(
+        ProductRouter(mock_product_umbra_spotlight)
     )
 
     yield TestClient(app, base_url=f"{base_url}")
@@ -71,12 +85,14 @@ def url_for(value: str) -> str:
 
 
 @pytest.fixture
-def products() -> Iterator[list[Product]]:
-    class Parameters(BaseModel):
-        pass
+def products(mock_product_umbra_spotlight) -> Iterator[list[Product]]:
+    now = datetime.now(timezone.utc)  # Use timezone-aware datetime
+    start = now
+    end = start + timedelta(days=5)
+    datetime_interval = f"{start.isoformat()}/{end.isoformat()}"
 
     yield [
-        Product(
+        UmbraSpotlight(
             id="mock:standard",
             description="Mock backend's standard product",
             license="CC0-1.0",
@@ -92,7 +108,10 @@ class Parameters(BaseModel):
                     url="http://acme.example.com",
                 )
             ],
-            parameters=Parameters,
+            parameters=UmbraSpotlightProperties(
+                datetime=datetime_interval,
+                off_nadir=20,
+            ),
             links=[],
         )
     ]
@@ -127,7 +146,6 @@ def allowed_payloads(products: list[Product]) -> Iterator[list[OpportunityReques
 
 YieldFixture = Generator[T, None, None]
 
-
 def pytest_addoption(parser: Parser):
     parser.addoption(
         "--stapi-backend",
@@ -162,15 +180,6 @@ def mock_provider_umbra() -> Provider:
         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_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`."""
@@ -190,4 +199,4 @@ def mock_umbra_spotlight_opportunities() -> List[Opportunity]:
                 off_nadir=20,
             ),
         ),
-    ]
+    ]

tests/opportunity_test.py

@@ -8,23 +8,23 @@
 
 from .backend import TestBackend
 
-@pytest.mark.parametrize("product_id", ["umbra-spotlight-1"])
+@pytest.mark.parametrize("product_id", ["umbra-spotlight"])
 def test_search_opportunities_response(
     product_id: str,
-    mock_products: list[Product],
+    products: list[Product],
     mock_umbra_spotlight_opportunities: List[Opportunity],
     stapi_backend: TestBackend,
     stapi_client: TestClient,
 ):
-    stapi_backend._products = mock_products
+    stapi_backend._products = products
     stapi_backend._opportunities = mock_umbra_spotlight_opportunities
 
     now = datetime.now(UTC)
     start = now
     end = start + timedelta(days=5)
 
     # Create mock products and opportunities for the test
-    mock_products[0].id = product_id
+    products[0].id = product_id
 
     # Prepare the request payload
     request_payload = {

tests/product_test.py

@@ -9,6 +9,7 @@
 from .warnings import StapiSpecWarning
 
 
+
 def test_products_response(stapi_client: TestClient):
     res = stapi_client.get("/products")