prep tests fixtures

shahar4499 · shahar4499 · commit 005d54ef0e83 · 2025-04-08T20:31:10.000+03:00
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -1,70 +1,10 @@
-"""
-Configuration file for pytest.
-Contains fixtures and settings for the test suite.
-"""
-
 import sys
 import os
-from typing import Optional, List
-
-from fastapi import FastAPI, Query, Path, Body
-from pydantic import BaseModel
-import pytest
 
-# Add the parent directory to the path so that we can import the local package
+# Add the parent directory to the path
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
-
-class Item(BaseModel):
-    id: int
-    name: str
-    description: Optional[str] = None
-    price: float
-    tags: List[str] = []
-
-
-@pytest.fixture
-def fastapi_app():
-    app = FastAPI(
-        title="Test API",
-        description="A test API app for unit testing",
-        version="0.1.0",
-    )
-
-    @app.get("/items/", response_model=List[Item], tags=["items"], operation_id="list_items")
-    async def list_items(
-        skip: int = Query(0, description="Number of items to skip"),
-        limit: int = Query(10, description="Max number of items to return"),
-        sort_by: Optional[str] = Query(None, description="Field to sort by"),
-    ):
-        """List all items with pagination and sorting options."""
-        return []
-
-    @app.get("/items/{item_id}", response_model=Item, tags=["items"], operation_id="get_item")
-    async def read_item(
-        item_id: int = Path(..., description="The ID of the item to retrieve"),
-        include_details: bool = Query(False, description="Include additional details"),
-    ):
-        """Get a specific item by its ID with optional details."""
-        return {"id": item_id, "name": "Test Item", "price": 10.0}
-
-    @app.post("/items/", response_model=Item, tags=["items"], operation_id="create_item")
-    async def create_item(item: Item = Body(..., description="The item to create")):
-        """Create a new item in the database."""
-        return item
-
-    @app.put("/items/{item_id}", response_model=Item, tags=["items"], operation_id="update_item")
-    async def update_item(
-        item_id: int = Path(..., description="The ID of the item to update"),
-        item: Item = Body(..., description="The updated item data"),
-    ):
-        """Update an existing item."""
-        item.id = item_id
-        return item
-
-    @app.delete("/items/{item_id}", tags=["items"], operation_id="delete_item")
-    async def delete_item(item_id: int = Path(..., description="The ID of the item to delete")):
-        """Delete an item from the database."""
-        return {"message": "Item deleted successfully"}
-
-    return app
+from .fixtures import types  # noqa: F401
+from .fixtures import example_data  # noqa: F401
+from .fixtures import simple_app  # noqa: F401
+from .fixtures import complex_app  # noqa: F401
diff --git a/tests/fixtures/complex_app.py b/tests/fixtures/complex_app.py
@@ -0,0 +1,131 @@
+from typing import Optional, List, Dict, Any, Union
+from uuid import UUID
+
+from fastapi import FastAPI, Query, Path, Body, Header, Cookie
+import pytest
+
+from .types import (
+    Product,
+    Customer,
+    OrderResponse,
+    Address,
+    PaginatedResponse,
+    ProductCategory,
+    OrderRequest,
+    ErrorResponse,
+)
+
+
+@pytest.fixture
+def complex_fastapi_app(
+    example_product: Product,
+    example_customer: Customer,
+    example_order_response: OrderResponse,
+    example_address: Address,
+) -> FastAPI:
+    app = FastAPI(
+        title="Complex E-Commerce API",
+        description="A more complex API with nested models and various schemas",
+        version="1.0.0",
+    )
+
+    @app.get(
+        "/products",
+        response_model=PaginatedResponse,
+        tags=["products"],
+        operation_id="list_products",
+        response_model_exclude_none=True,
+    )
+    async def list_products(
+        category: Optional[ProductCategory] = Query(None, description="Filter by product category"),
+        min_price: Optional[float] = Query(None, description="Minimum price filter", gt=0),
+        max_price: Optional[float] = Query(None, description="Maximum price filter", gt=0),
+        tag: Optional[List[str]] = Query(None, description="Filter by tags"),
+        sort_by: str = Query("created_at", description="Field to sort by"),
+        sort_direction: str = Query("desc", description="Sort direction (asc or desc)"),
+        in_stock_only: bool = Query(False, description="Show only in-stock products"),
+        page: int = Query(1, description="Page number", ge=1),
+        size: int = Query(20, description="Page size", ge=1, le=100),
+        user_agent: Optional[str] = Header(None, description="User agent header"),
+    ):
+        """
+        List products with various filtering, sorting and pagination options.
+        Returns a paginated response of products.
+        """
+        return PaginatedResponse(items=[example_product], total=1, page=page, size=size, pages=1)
+
+    @app.get(
+        "/products/{product_id}",
+        response_model=Product,
+        tags=["products"],
+        operation_id="get_product",
+        responses={
+            404: {"model": ErrorResponse, "description": "Product not found"},
+        },
+    )
+    async def get_product(
+        product_id: UUID = Path(..., description="The ID of the product to retrieve"),
+        include_unavailable: bool = Query(False, description="Include product even if not available"),
+    ):
+        """
+        Get detailed information about a specific product by its ID.
+        Includes all variants, images, and metadata.
+        """
+        # Just returning the example product with the requested ID
+        product_copy = example_product.model_copy()
+        product_copy.id = product_id
+        return product_copy
+
+    @app.post(
+        "/orders",
+        response_model=OrderResponse,
+        tags=["orders"],
+        operation_id="create_order",
+        status_code=201,
+        responses={
+            400: {"model": ErrorResponse, "description": "Invalid order data"},
+            404: {"model": ErrorResponse, "description": "Customer or product not found"},
+            422: {"model": ErrorResponse, "description": "Validation error"},
+        },
+    )
+    async def create_order(
+        order: OrderRequest = Body(..., description="Order details"),
+        user_id: Optional[UUID] = Cookie(None, description="User ID from cookie"),
+        authorization: Optional[str] = Header(None, description="Authorization header"),
+    ):
+        """
+        Create a new order with multiple items, shipping details, and payment information.
+        Returns the created order with full details including status and tracking information.
+        """
+        # Return a copy of the example order response with the customer ID from the request
+        order_copy = example_order_response.model_copy()
+        order_copy.customer_id = order.customer_id
+        order_copy.items = order.items
+        return order_copy
+
+    @app.get(
+        "/customers/{customer_id}",
+        response_model=Union[Customer, Dict[str, Any]],
+        tags=["customers"],
+        operation_id="get_customer",
+        responses={
+            404: {"model": ErrorResponse, "description": "Customer not found"},
+            403: {"model": ErrorResponse, "description": "Forbidden access"},
+        },
+    )
+    async def get_customer(
+        customer_id: UUID = Path(..., description="The ID of the customer to retrieve"),
+        include_orders: bool = Query(False, description="Include customer's order history"),
+        include_payment_methods: bool = Query(False, description="Include customer's saved payment methods"),
+        fields: List[str] = Query(None, description="Specific fields to include in response"),
+    ):
+        """
+        Get detailed information about a specific customer by ID.
+        Can include additional related information like order history.
+        """
+        # Return a copy of the example customer with the requested ID
+        customer_copy = example_customer.model_copy()
+        customer_copy.id = customer_id
+        return customer_copy
+
+    return app
diff --git a/tests/fixtures/example_data.py b/tests/fixtures/example_data.py
@@ -0,0 +1,131 @@
+from datetime import datetime, date
+from uuid import UUID
+
+import pytest
+
+from .types import (
+    Address,
+    ProductVariant,
+    Product,
+    ProductCategory,
+    Customer,
+    CustomerTier,
+    OrderItem,
+    PaymentDetails,
+    OrderRequest,
+    OrderResponse,
+    PaginatedResponse,
+    OrderStatus,
+    PaymentMethod,
+)
+
+
+@pytest.fixture
+def example_address() -> Address:
+    return Address(street="123 Main St", city="Anytown", state="CA", postal_code="12345", country="US", is_primary=True)
+
+
+@pytest.fixture
+def example_product_variant() -> ProductVariant:
+    return ProductVariant(
+        sku="EP-001-BLK", color="Black", stock_count=10, size=None, weight=None, dimensions=None, in_stock=True
+    )
+
+
+@pytest.fixture
+def example_product(example_product_variant) -> Product:
+    return Product(
+        id=UUID("550e8400-e29b-41d4-a716-446655440000"),
+        name="Example Product",
+        description="This is an example product",
+        category=ProductCategory.ELECTRONICS,
+        price=199.99,
+        discount_percent=None,
+        tax_rate=None,
+        rating=None,
+        review_count=0,
+        tags=["example", "new"],
+        image_urls=["https://example.com/image.jpg"],
+        created_at=datetime.now(),
+        variants=[example_product_variant],
+    )
+
+
+@pytest.fixture
+def example_customer(example_address) -> Customer:
+    return Customer(
+        id=UUID("770f9511-f39c-42d5-a860-557654551222"),
+        email="customer@example.com",
+        full_name="John Doe",
+        phone="1234567890",
+        tier=CustomerTier.STANDARD,
+        addresses=[example_address],
+        created_at=datetime.now(),
+        preferences={"theme": "dark", "notifications": True},
+        consent={"marketing": True, "analytics": True},
+    )
+
+
+@pytest.fixture
+def example_order_item() -> OrderItem:
+    return OrderItem(
+        product_id=UUID("550e8400-e29b-41d4-a716-446655440000"),
+        variant_sku="EP-001-BLK",
+        quantity=2,
+        unit_price=199.99,
+        discount_amount=10.00,
+        total=389.98,
+    )
+
+
+@pytest.fixture
+def example_payment_details() -> PaymentDetails:
+    return PaymentDetails(
+        method=PaymentMethod.CREDIT_CARD,
+        transaction_id="txn_12345",
+        status="completed",
+        amount=389.98,
+        currency="USD",
+        paid_at=datetime.now(),
+    )
+
+
+@pytest.fixture
+def example_order_request(example_order_item) -> OrderRequest:
+    return OrderRequest(
+        customer_id=UUID("770f9511-f39c-42d5-a860-557654551222"),
+        items=[example_order_item],
+        shipping_address_id=UUID("880f9511-f39c-42d5-a860-557654551333"),
+        billing_address_id=None,
+        payment_method=PaymentMethod.CREDIT_CARD,
+        notes="Please deliver before 6pm",
+        use_loyalty_points=False,
+    )
+
+
+@pytest.fixture
+def example_order_response(example_order_item, example_address, example_payment_details) -> OrderResponse:
+    return OrderResponse(
+        id=UUID("660f9511-f39c-42d5-a860-557654551111"),
+        customer_id=UUID("770f9511-f39c-42d5-a860-557654551222"),
+        status=OrderStatus.PENDING,
+        items=[example_order_item],
+        shipping_address=example_address,
+        billing_address=example_address,
+        payment=example_payment_details,
+        subtotal=389.98,
+        shipping_cost=10.0,
+        tax_amount=20.0,
+        discount_amount=10.0,
+        total_amount=409.98,
+        tracking_number="TRK123456789",
+        estimated_delivery=date.today(),
+        created_at=datetime.now(),
+        notes="Please deliver before 6pm",
+        metadata={},
+    )
+
+
+@pytest.fixture
+def example_paginated_products(example_product) -> PaginatedResponse:
+    return PaginatedResponse(items=[example_product], total=1, page=1, size=20, pages=1)
diff --git a/tests/fixtures/simple_app.py b/tests/fixtures/simple_app.py
@@ -0,0 +1,53 @@
+from typing import Optional, List
+
+from fastapi import FastAPI, Query, Path, Body
+import pytest
+
+from .types import Item
+
+
+@pytest.fixture
+def simple_fastapi_app() -> FastAPI:
+    app = FastAPI(
+        title="Test API",
+        description="A test API app for unit testing",
+        version="0.1.0",
+    )
+
+    @app.get("/items/", response_model=List[Item], tags=["items"], operation_id="list_items")
+    async def list_items(
+        skip: int = Query(0, description="Number of items to skip"),
+        limit: int = Query(10, description="Max number of items to return"),
+        sort_by: Optional[str] = Query(None, description="Field to sort by"),
+    ):
+        """List all items with pagination and sorting options."""
+        return []
+
+    @app.get("/items/{item_id}", response_model=Item, tags=["items"], operation_id="get_item")
+    async def read_item(
+        item_id: int = Path(..., description="The ID of the item to retrieve"),
+        include_details: bool = Query(False, description="Include additional details"),
+    ):
+        """Get a specific item by its ID with optional details."""
+        return {"id": item_id, "name": "Test Item", "price": 10.0}
+
+    @app.post("/items/", response_model=Item, tags=["items"], operation_id="create_item")
+    async def create_item(item: Item = Body(..., description="The item to create")):
+        """Create a new item in the database."""
+        return item
+
+    @app.put("/items/{item_id}", response_model=Item, tags=["items"], operation_id="update_item")
+    async def update_item(
+        item_id: int = Path(..., description="The ID of the item to update"),
+        item: Item = Body(..., description="The updated item data"),
+    ):
+        """Update an existing item."""
+        item.id = item_id
+        return item
+
+    @app.delete("/items/{item_id}", tags=["items"], operation_id="delete_item")
+    async def delete_item(item_id: int = Path(..., description="The ID of the item to delete")):
+        """Delete an item from the database."""
+        return {"message": "Item deleted successfully"}
+
+    return app
diff --git a/tests/fixtures/types.py b/tests/fixtures/types.py
