test_smoke.py

import pytest
from fastapi.testclient import TestClient
from src.api.server import app

client = TestClient(app)

def test_smoke_flow():
    # 1. Add Product
    res = client.post("/api/products", json={
        "name": "Smoke Item",
        "priceCents": 500,
        "stock": 10
    })
    assert res.status_code == 201
    product = res.json()
    pid = product["id"]

    # 2. Add to Cart
    res = client.post("/api/cart/items", json={
        "userId": "user_dev",
        "productId": pid,
        "quantity": 2
    })
    assert res.status_code == 200
    cart = res.json()
    assert len(cart["items"]) == 1

    # 3. Create Order
    res = client.post("/api/orders", json={
        "userId": "user_dev"
    })
    assert res.status_code == 201
    order = res.json()
    assert order["totalCents"] == 1000
    assert order["status"] == "PENDING_PAYMENT"

    # 4. Verify Stock Deducted
    # Note: In real integration test we might check GET /products or GET /products/:id
    # Here we just rely on previous steps success


def test_out_of_stock():
    user_id = "user_2"
    # Add product with stock of 5
    res = client.post("/api/products", json={
        "name": "Limited Item",
        "priceCents": 200,
        "stock": 5
    })
    assert res.status_code == 201
    product = res.json()
    pid = product["id"]

    # Try to add 6 units (exceeds stock of 5)
    client.post("/api/cart/items", json={
        "userId": user_id,
        "productId": pid,
        "quantity": 6
    })

    # Verify 409 is returned
    resp = client.post("/api/orders", json={"userId": user_id})
    assert resp.status_code == 409
    assert "out of stock" in resp.json()["detail"].lower()


def test_cart_query_and_remove():
    user_id = "user_cart_crud"
    # Add two products
    ids = []
    for name, price in [("Cart Item A", 100), ("Cart Item B", 200)]:
        res = client.post("/api/products", json={"name": name, "priceCents": price, "stock": 10})
        assert res.status_code == 201
        ids.append(res.json()["id"])

    # Query empty cart (lazy-created for a fresh user)
    res = client.get("/api/cart/items", params={"userId": user_id})
    assert res.status_code == 200
    assert res.json()["items"] == []

    # Add both products
    for pid in ids:
        res = client.post("/api/cart/items", json={"userId": user_id, "productId": pid, "quantity": 1})
        assert res.status_code == 200

    # Query returns both items
    res = client.get("/api/cart/items", params={"userId": user_id})
    assert res.status_code == 200
    cart = res.json()
    assert len(cart["items"]) == 2

    # Remove one: only the target item is removed
    res = client.delete(f"/api/cart/items/{ids[0]}", params={"userId": user_id})
    assert res.status_code == 200
    cart = res.json()
    assert len(cart["items"]) == 1
    assert cart["items"][0]["productId"] == ids[1]

    # Remove the same item again -> 404
    res = client.delete(f"/api/cart/items/{ids[0]}", params={"userId": user_id})
    assert res.status_code == 404
    assert "Cart item not found" in res.json()["detail"]


def test_order_list_query():
    # Add product with enough stock
    res = client.post("/api/products", json={"name": "Order List Item", "priceCents": 100, "stock": 10})
    assert res.status_code == 201
    pid = res.json()["id"]

    def order_once(user_id):
        r = client.post("/api/cart/items", json={"userId": user_id, "productId": pid, "quantity": 1})
        assert r.status_code == 200
        r = client.post("/api/orders", json={"userId": user_id})
        assert r.status_code == 201
        order = r.json()
        # userId field is present and aligned with Node implementation
        assert order["userId"] == user_id
        return order

    order_once("user_oa")
    order_once("user_oa")
    order_once("user_ob")

    # user_oa has exactly 2 orders, others not mixed in
    res = client.get("/api/orders", params={"userId": "user_oa"})
    assert res.status_code == 200
    orders = res.json()
    assert len(orders) == 2
    assert all(o["userId"] == "user_oa" for o in orders)

    # User with no orders -> empty array
    res = client.get("/api/orders", params={"userId": "nobody"})
    assert res.status_code == 200
    assert res.json() == []

    # Missing userId -> 400 MISSING_USER_ID
    res = client.get("/api/orders")
    assert res.status_code == 400
    assert "Missing userId" in res.json()["detail"]


def test_get_product_by_id():
    # Add product
    res = client.post("/api/products", json={
        "name": "Test Product",
        "priceCents": 300,
        "stock": 5
    })
    assert res.status_code == 201
    pid = res.json()["id"]

    # Query existing product
    res = client.get(f"/api/products/{pid}")
    assert res.status_code == 200
    assert res.json()["name"] == "Test Product"
    assert res.json()["priceCents"] == 300

    # Query non-existent product
    res = client.get("/api/products/non-existent")
    assert res.status_code == 404
    assert "Product not found" in res.json()["detail"]


def test_search_and_sort():
    # Add products
    for name, price in [("iPhone 15", 5999), ("iPad Pro", 7999), ("MacBook", 9999)]:
        client.post("/api/products", json={"name": name, "priceCents": price, "stock": 5})

    # Search by name (case-insensitive)
    res = client.get("/api/products", params={"name": "ipad"})
    assert res.status_code == 200
    assert len(res.json()) == 1
    assert res.json()[0]["name"] == "iPad Pro"

    # No params -> all products (shared app instance: previous tests also added products)
    res = client.get("/api/products")
    assert res.status_code == 200
    all_products = res.json()
    assert len(all_products) >= 3
    names = {p["name"] for p in all_products}
    assert {"iPhone 15", "iPad Pro", "MacBook"} <= names

    # No results
    res = client.get("/api/products", params={"name": "nonexistent"})
    assert res.status_code == 200
    assert res.json() == []

    # Sort ascending
    res = client.get("/api/products", params={"sort": "price_asc"})
    prices = [p["priceCents"] for p in res.json()]
    assert prices == sorted(prices)

    # Sort descending
    res = client.get("/api/products", params={"sort": "price_desc"})
    prices = [p["priceCents"] for p in res.json()]
    assert prices == sorted(prices, reverse=True)

    # Invalid sort value -> natural order, still 200
    res = client.get("/api/products", params={"sort": "invalid"})
    assert res.status_code == 200
    assert len(res.json()) >= 3

    # Search + sort combination
    res = client.get("/api/products", params={"name": "a", "sort": "price_desc"})
    prices = [p["priceCents"] for p in res.json()]
    assert prices == sorted(prices, reverse=True)
    assert all("a" in p["name"].lower() for p in res.json())


def test_order_get_by_id():
    user_id = "user_order_detail"

    # Create product -> cart -> order
    res = client.post("/api/products", json={
        "name": "Order Detail Item",
        "priceCents": 300,
        "stock": 5
    })
    assert res.status_code == 201
    pid = res.json()["id"]

    res = client.post("/api/cart/items", json={
        "userId": user_id,
        "productId": pid,
        "quantity": 2
    })
    assert res.status_code == 200

    res = client.post("/api/orders", json={"userId": user_id})
    assert res.status_code == 201
    order = res.json()

    # Query existing order -> 200 with camelCase fields
    res = client.get(f"/api/orders/{order['id']}")
    assert res.status_code == 200
    fetched = res.json()
    assert fetched["id"] == order["id"]
    assert fetched["userId"] == user_id
    assert fetched["status"] == "PENDING_PAYMENT"
    assert fetched["totalCents"] == 600
    assert fetched["items"][0]["productId"] == pid
    assert fetched["items"][0]["priceCents"] == 300

    # Query non-existent order -> 404
    res = client.get("/api/orders/order_does_not_exist")
    assert res.status_code == 404
    assert "Order not found" in res.json()["detail"]