Project: a full test suite for a coffee shop API

fastapi
uvicorn
httpx
pytest

from itertools import count
from typing import Literal

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field

app = FastAPI(title="Brew & Bean API")

MENU = [
    {"id": "espresso", "name": "Espresso", "category": "coffee", "price": 120},
    {"id": "cappuccino", "name": "Cappuccino", "category": "coffee", "price": 180},
    {"id": "cold-brew", "name": "Cold Brew", "category": "coffee", "price": 220},
    {"id": "filter-coffee", "name": "Filter Coffee", "category": "coffee", "price": 80},
    {"id": "masala-chai", "name": "Masala Chai", "category": "tea", "price": 90},
    {"id": "croissant", "name": "Butter Croissant", "category": "bakery", "price": 150},
    {"id": "banana-bread", "name": "Banana Bread", "category": "bakery", "price": 130},
    {"id": "veg-sandwich", "name": "Veg Grilled Sandwich", "category": "food", "price": 160},
]
PRICES = {item["id"]: item["price"] for item in MENU}

# An order may move only along these edges.
TRANSITIONS = {
    "received": {"preparing", "cancelled"},
    "preparing": {"ready", "cancelled"},
    "ready": {"picked_up"},
    "picked_up": set(),
    "cancelled": set(),
}

ORDERS: dict[str, dict] = {}
_ids = count(1)


class OrderItem(BaseModel):
    item_id: str
    qty: int = Field(ge=1, le=10)


class OrderIn(BaseModel):
    customer_name: str = Field(min_length=1, max_length=50)
    phone: str = Field(pattern=r"^[6-9][0-9]{9}$")
    items: list[OrderItem] = Field(min_length=1)


class StatusIn(BaseModel):
    status: Literal["preparing", "ready", "picked_up", "cancelled"]


def calculate_total(items: list[dict]) -> int:
    """Total in rupees. Raises KeyError for an unknown item id."""
    return sum(PRICES[i["item_id"]] * i["qty"] for i in items)


def reset_state() -> None:
    """Used by tests to start every test from an empty shop."""
    global _ids
    ORDERS.clear()
    _ids = count(1)


@app.get("/menu")
def get_menu():
    return MENU


@app.post("/orders", status_code=201)
def create_order(body: OrderIn):
    items = [i.model_dump() for i in body.items]
    try:
        total = calculate_total(items)
    except KeyError as err:
        raise HTTPException(status_code=400, detail=f"Unknown item: {err.args[0]}")
    order_id = f"ord_{next(_ids)}"
    order = {
        "id": order_id,
        "customer_name": body.customer_name,
        "phone": body.phone,
        "items": items,
        "total": total,
        "status": "received",
    }
    ORDERS[order_id] = order
    return order


@app.get("/orders/{order_id}")
def get_order(order_id: str):
    if order_id not in ORDERS:
        raise HTTPException(status_code=404, detail="Order not found")
    return ORDERS[order_id]


@app.patch("/orders/{order_id}/status")
def update_status(order_id: str, body: StatusIn):
    order = ORDERS.get(order_id)
    if order is None:
        raise HTTPException(status_code=404, detail="Order not found")
    if body.status not in TRANSITIONS[order["status"]]:
        raise HTTPException(
            status_code=409,
            detail=f"Cannot move from {order['status']} to {body.status}",
        )
    order["status"] = body.status
    return order

You are a senior QA engineer. Here are the requirements of a small ordering API:

[paste the requirements from Stage 0]

List test cases I may have missed, as a table: Scenario, Input, Expected status code. Focus on negative, boundary and state-transition cases. Do not write code yet.

[pytest]
pythonpath = .
testpaths = tests

import pytest
from fastapi.testclient import TestClient

from main import app, reset_state


@pytest.fixture(autouse=True)
def clean_shop():
    reset_state()
    yield


@pytest.fixture
def client():
    return TestClient(app)


@pytest.fixture
def make_order(client):
    """Factory: create an order with sensible defaults; override what a test cares about."""

    def _make(**overrides):
        payload = {
            "customer_name": "Asha",
            "phone": "9876543210",
            "items": [{"item_id": "espresso", "qty": 2}],
        }
        payload.update(overrides)
        return client.post("/orders", json=payload)

    return _make

def test_menu_returns_eight_items(client):
    response = client.get("/menu")
    assert response.status_code == 200
    assert len(response.json()) == 8


def test_every_menu_item_has_the_expected_fields(client):
    for item in client.get("/menu").json():
        assert set(item) == {"id", "name", "category", "price"}
        assert isinstance(item["price"], int) and item["price"] > 0


def test_menu_ids_are_unique(client):
    ids = [item["id"] for item in client.get("/menu").json()]
    assert len(ids) == len(set(ids))

import pytest

from main import calculate_total


@pytest.mark.parametrize(
    "items, expected",
    [
        ([{"item_id": "espresso", "qty": 1}], 120),
        ([{"item_id": "espresso", "qty": 2}], 240),
        ([{"item_id": "masala-chai", "qty": 1}, {"item_id": "croissant", "qty": 1}], 240),
        ([{"item_id": "filter-coffee", "qty": 10}], 800),
    ],
)
def test_calculate_total(items, expected):
    assert calculate_total(items) == expected


def test_unknown_item_raises_key_error():
    with pytest.raises(KeyError):
        calculate_total([{"item_id": "pizza", "qty": 1}])

Write pytest tests for POST /orders using FastAPI's TestClient. I already have a `client` fixture and a `make_order(**overrides)` factory fixture that returns the response. Rules: customer_name 1 to 50 chars; phone is 10 digits starting 6 to 9; items non-empty; qty 1 to 10; total is computed by the server; unknown item_id gives 400; invalid data gives 422. Use pytest.mark.parametrize for qty boundaries and phone numbers. Test names must describe behaviour.

import pytest


def test_create_order_computes_total_on_the_server(make_order):
    response = make_order(
        items=[
            {"item_id": "cappuccino", "qty": 2},
            {"item_id": "banana-bread", "qty": 1},
        ]
    )
    assert response.status_code == 201
    body = response.json()
    assert body["total"] == 2 * 180 + 130
    assert body["status"] == "received"
    assert body["id"].startswith("ord_")


def test_client_cannot_set_the_total(client):
    payload = {
        "customer_name": "Asha",
        "phone": "9876543210",
        "items": [{"item_id": "espresso", "qty": 1}],
        "total": 1,
    }
    response = client.post("/orders", json=payload)
    assert response.status_code == 201
    assert response.json()["total"] == 120


def test_created_order_can_be_fetched(client, make_order):
    order_id = make_order().json()["id"]
    response = client.get(f"/orders/{order_id}")
    assert response.status_code == 200
    assert response.json()["customer_name"] == "Asha"


def test_unknown_order_returns_404(client):
    assert client.get("/orders/ord_999").status_code == 404


@pytest.mark.parametrize("qty, expected", [(0, 422), (1, 201), (10, 201), (11, 422)])
def test_quantity_boundaries(make_order, qty, expected):
    response = make_order(items=[{"item_id": "espresso", "qty": qty}])
    assert response.status_code == expected


@pytest.mark.parametrize(
    "phone, expected",
    [
        ("9876543210", 201),
        ("6000000000", 201),
        ("5876543210", 422),
        ("987654321", 422),
        ("98765432100", 422),
        ("98765abcde", 422),
    ],
)
def test_phone_validation(make_order, phone, expected):
    assert make_order(phone=phone).status_code == expected


@pytest.mark.parametrize(
    "overrides",
    [
        {"customer_name": ""},
        {"items": []},
        {"items": [{"item_id": "espresso"}]},
        {"items": [{"item_id": "espresso", "qty": "two"}]},
    ],
)
def test_invalid_orders_are_rejected(make_order, overrides):
    assert make_order(**overrides).status_code == 422


def test_unknown_menu_item_is_a_400(make_order):
    response = make_order(items=[{"item_id": "pizza", "qty": 1}])
    assert response.status_code == 400
    assert "pizza" in response.json()["detail"]


def test_missing_body_is_rejected(client):
    assert client.post("/orders").status_code == 422

def set_status(client, order_id, status):
    return client.patch(f"/orders/{order_id}/status", json={"status": status})


def test_happy_path_through_every_status(client, make_order):
    order_id = make_order().json()["id"]
    for status in ["preparing", "ready", "picked_up"]:
        response = set_status(client, order_id, status)
        assert response.status_code == 200
        assert response.json()["status"] == status


def test_cannot_skip_a_step(client, make_order):
    order_id = make_order().json()["id"]
    assert set_status(client, order_id, "ready").status_code == 409


def test_cancelled_order_cannot_be_revived(client, make_order):
    order_id = make_order().json()["id"]
    assert set_status(client, order_id, "cancelled").status_code == 200
    assert set_status(client, order_id, "preparing").status_code == 409


def test_cannot_cancel_after_ready(client, make_order):
    order_id = make_order().json()["id"]
    set_status(client, order_id, "preparing")
    set_status(client, order_id, "ready")
    assert set_status(client, order_id, "cancelled").status_code == 409


def test_unknown_status_value_is_422(client, make_order):
    order_id = make_order().json()["id"]
    assert set_status(client, order_id, "teleported").status_code == 422


def test_status_change_on_missing_order_is_404(client):
    assert set_status(client, "ord_404", "preparing").status_code == 404


def test_status_change_is_visible_on_next_get(client, make_order):
    order_id = make_order().json()["id"]
    set_status(client, order_id, "preparing")
    assert client.get(f"/orders/{order_id}").json()["status"] == "preparing"

def test_openapi_lists_every_endpoint(client):
    paths = client.get("/openapi.json").json()["paths"]
    assert "get" in paths["/menu"]
    assert "post" in paths["/orders"]
    assert "get" in paths["/orders/{order_id}"]
    assert "patch" in paths["/orders/{order_id}/status"]

name: tests

on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
          cache: pip
      - run: pip install -r requirements.txt
      - run: pytest -v --junitxml=report.xml
      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: junit-report
          path: report.xml

Act as a strict reviewer of an automated API test suite. Below are my requirements and my test files. Find: (1) requirements with no test, (2) tests with weak assertions, (3) tests that depend on each other or on execution order, (4) unclear test names. Give a numbered list with the file and function for each issue, and do not rewrite the whole suite.

--- requirements ---
[paste]
--- tests ---
[paste]