Automating API tests in code

from datetime import datetime, timezone
from typing import Literal
from uuid import uuid4

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 = {m["id"]: m["price"] for m in MENU}
ORDERS: dict[str, dict] = {}

Status = Literal["received", "preparing", "ready", "picked_up", "cancelled"]
NEXT = {
    "received": {"preparing", "cancelled"},
    "preparing": {"ready", "cancelled"},
    "ready": {"picked_up"},
    "picked_up": set(),
    "cancelled": set(),
}


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


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


class OrderOut(BaseModel):
    id: str
    customer_name: str
    phone: str
    items: list[OrderItem]
    total: int
    status: Status
    created_at: str


class StatusIn(BaseModel):
    status: Status


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


@app.post("/orders", status_code=201, response_model=OrderOut)
def create_order(order: OrderIn):
    for line in order.items:
        if line.item_id not in PRICES:
            raise HTTPException(422, f"Unknown item: {line.item_id}")
    record = {
        "id": str(uuid4()),
        **order.model_dump(),
        "total": sum(PRICES[i.item_id] * i.qty for i in order.items),
        "status": "received",
        "created_at": datetime.now(timezone.utc).isoformat(),
    }
    ORDERS[record["id"]] = record
    return record


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


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

import os

import httpx
import pytest

BASE_URL = os.getenv("BASE_URL", "http://127.0.0.1:8000")


@pytest.fixture(scope="session")
def api():
    with httpx.Client(base_url=BASE_URL, timeout=5.0) as client:
        yield client


@pytest.fixture
def order_payload():
    return {
        "customer_name": "Asha",
        "phone": "9876543210",
        "items": [{"item_id": "espresso", "qty": 2}, {"item_id": "croissant", "qty": 1}],
    }


@pytest.fixture
def created_order(api, order_payload):
    response = api.post("/orders", json=order_payload)
    assert response.status_code == 201
    return response.json()

import pytest


def test_menu_returns_items(api):
    response = api.get("/menu")

    assert response.status_code == 200
    menu = response.json()
    assert len(menu) >= 1
    for item in menu:
        assert {"id", "name", "category", "price"} <= item.keys()
        assert item["price"] > 0


def test_create_order_computes_total_on_server(api, order_payload):
    response = api.post("/orders", json=order_payload)

    assert response.status_code == 201
    body = response.json()
    assert body["total"] == 120 * 2 + 150  # espresso x2 + croissant
    assert body["status"] == "received"
    assert body["id"]


def test_client_cannot_set_total(api, order_payload):
    order_payload["total"] = 1
    response = api.post("/orders", json=order_payload)

    assert response.status_code == 201
    assert response.json()["total"] == 390


def test_get_order_returns_what_was_created(api, created_order):
    response = api.get(f"/orders/{created_order['id']}")

    assert response.status_code == 200
    assert response.json() == created_order


def test_unknown_order_is_404(api):
    response = api.get("/orders/does-not-exist")

    assert response.status_code == 404


@pytest.mark.parametrize(
    "change",
    [
        {"customer_name": ""},
        {"phone": "12345"},
        {"items": []},
        {"items": [{"item_id": "espresso", "qty": 0}]},
        {"items": [{"item_id": "espresso", "qty": 21}]},
        {"items": [{"item_id": "pizza", "qty": 1}]},
    ],
    ids=["empty-name", "short-phone", "no-items", "qty-zero", "qty-too-high", "unknown-item"],
)
def test_invalid_orders_are_rejected(api, order_payload, change):
    order_payload.update(change)
    response = api.post("/orders", json=order_payload)

    assert response.status_code == 422


def test_order_follows_status_flow(api, created_order):
    url = f"/orders/{created_order['id']}/status"

    for status in ["preparing", "ready", "picked_up"]:
        response = api.patch(url, json={"status": status})
        assert response.status_code == 200
        assert response.json()["status"] == status


def test_cannot_skip_a_status(api, created_order):
    response = api.patch(f"/orders/{created_order['id']}/status", json={"status": "ready"})

    assert response.status_code == 409
    assert api.get(f"/orders/{created_order['id']}").json()["status"] == "received"

pytest -v

BASE_URL=https://staging.example.com pytest -q

$env:BASE_URL = "https://staging.example.com"
pytest -q

@pytest.fixture(scope="session")
def api():
    headers = {"Authorization": f"Bearer {os.environ['API_TOKEN']}"}
    with httpx.Client(base_url=BASE_URL, timeout=5.0, headers=headers) as client:
        yield client

You are an SDET who writes pytest + httpx API tests.

Write tests for this endpoint. Use a fixture called `api` (an httpx.Client with base_url set) and follow Arrange, Act, Assert. One behaviour per test, clear test names.

Endpoint: [METHOD and path, e.g. POST /orders]
Request body rules: [fields, types, limits]
Responses: [status codes and what each means]
Business rules: [e.g. total is computed by the server]

Cover: the happy path, each validation rule (use pytest.mark.parametrize), a missing resource, and one state or business rule. After the code, list any case you were unsure about.