Python PyTest Scripting

Written by Brian McCarthy

Project Summary

Table of Contents

Languages Used

Tools and Frameworks

Project File Links

File Structure

Python-PyTest-Scripting/
|
|-- README.md
|
|-- course_scripts/
|   |-- 01_10/
|   |-- 02_01/
|   |-- 02_02/
|   |-- 02_03/
|   |-- 02_04/
|   |-- 02_06/
|   |-- 03_03/
|   |-- 03_04/
|   |-- 03_06/
|   |-- 04_02/
|   |-- 04_03/
|   |-- 04_04/
|   |-- 04_05/
|   |-- 04_07/
|   `-- 04_09/
|
`-- gig_tracker/
    |-- app.py
    |-- security.py
    |-- pyproject.toml
    |-- poetry.lock
    |
    |-- routes/
    |   |-- client_routes.py
    |   |-- gig_routes.py
    |   |-- ui_routes.py
    |   |-- user_routes.py
    |   `-- venue_routes.py
    |
    |-- schema/
    |   |-- base.py
    |   |-- client.py
    |   |-- gig.py
    |   |-- user.py
    |   `-- venue.py
    |
    |-- static/
    |   `-- css/
    |       `-- main.css
    |
    `-- templates/
        |-- index.html
        |-- gigs.html
        |-- clients.html
        |-- venue.html
        |-- search.html
        `-- snippets/

gig_tracker/
`-- tests/
    |-- conftest.py
    |-- test_auth.py
    |-- test_gigs_api.py
    |-- test_clients_api.py
    |-- test_venues_api.py
    |-- test_users_api.py
    |-- test_ui_routes.py
    |-- test_security.py
    `-- test_database_seed.py

Application Architecture

Main Application Layer

Route Layer

Schema / Model Layer

Security Layer

Current Function and Route Inventory

Main App Functions

lifespan(app: FastAPI)

@asynccontextmanager
async def lifespan(app: FastAPI):
    create_db_and_tables()
    seed_db()
    yield
    drop_db_and_tables()

login(session, form_data)

Database and Seed Functions

def get_session():
    with Session(engine) as session:
        yield session

def seed_db():
    with Session(engine) as session:
        venue_ids = create_venues(session)
        create_user(session)
        client_ids = create_clients(session)
        create_gigs(session, venue_ids, client_ids)

Gig API Routes

@gig_router.post("/gigs", response_model=GigPublic, status_code=201)
def create_gig(request: Request, gig: GigCreate, session: SessionDep):
    db_gig = Gig.model_validate(gig)
    session.add(db_gig)
    session.commit()
    session.refresh(db_gig)
    return db_gig

Client API Routes

Venue API Routes

@venue_router.get("/venues/{venue_id}", response_model=VenuePublic)
def get_venue(venue_id: int, session: SessionDep):
    venue = session.get(Venue, venue_id)
    if not venue:
        raise HTTPException(status_code=404, detail="Venue not found")
    return venue

User API Routes

UI Routes

@ui_router.post("/search", include_in_schema=False)
def search(request: Request, session: SessionDep, search: Annotated[str, Form()]):
    search_results = session.exec(
        select(Gig).where(col(Gig.name).contains(search))
    ).all()
    return templates.TemplateResponse(
        "search.html", {"request": request, "search_results": search_results}
    )

Detailed Test Inventory

Current Test Status

Recommended PyTest Test Suite

Test 1: Root Page Loads

from fastapi.testclient import TestClient

from gig_tracker.app import app

client = TestClient(app)


def test_root_page_loads():
    response = client.get("/")

    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]

Test 2: Invalid Login Returns 401

def test_token_login_rejects_invalid_credentials():
    response = client.post(
        "/token",
        data={"username": "invalid-user", "password": "invalid-value"},
    )

    assert response.status_code == 401
    assert response.json()["detail"] == "Incorrect username or password"

Test 3: Password Hashing Can Be Verified

from gig_tracker.security import hash_password, verify_password


def test_hash_password_can_be_verified():
    value = "sample-test-value"
    hashed_value = hash_password(value)

    assert hashed_value != value
    assert verify_password(value, hashed_value.decode("utf-8")) is True

Test 4: Access Token Can Be Created and Verified

from gig_tracker.security import create_access_token, verify_token


def test_create_access_token_can_be_verified():
    token = create_access_token({"sub": "sample-user"})

    assert isinstance(token, str)
    assert verify_token(token) is True

Test 5: Get Venues Returns a List

def test_get_venues_returns_list():
    response = client.get("/api/venues")

    assert response.status_code == 200
    assert isinstance(response.json(), list)

Test 6: Create Venue Returns 201

def test_create_venue_returns_201():
    payload = {
        "name": "QA Test Venue",
        "address": "123 Test Street",
        "contact_number": "555-0100",
        "contact_email": "[email protected]",
        "capacity": 250,
        "notes": "Created by pytest",
    }

    response = client.post("/api/venues", json=payload)

    assert response.status_code == 201
    body = response.json()
    assert body["name"] == "QA Test Venue"
    assert "id" in body

Test 7: Missing Venue Returns 404

def test_get_missing_venue_returns_404():
    response = client.get("/api/venues/999999")

    assert response.status_code == 404
    assert response.json()["detail"] == "Venue not found"

Test 8: Create Gig Returns 201

def test_create_gig_returns_201():
    gig_payload = {
        "date": "2026-06-01",
        "time": "19:30:00",
        "name": "QA Automation Gig",
        "venue_id": 1,
        "client_id": 1,
    }

    response = client.post("/api/gigs", json=gig_payload)

    assert response.status_code == 201
    assert response.json()["name"] == "QA Automation Gig"

Test 9: UI Gig Filter Returns HTML

def test_filter_gigs_returns_html_snippet():
    response = client.get("/filter_gigs?filter=past")

    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]

Test 10: Search Route Returns HTML

def test_search_route_returns_html():
    response = client.post("/search", data={"search": "test"})

    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]

Code Methodology Summary

FastAPI Router Separation

SQLModel Schema Design

Dependency Injection

SessionDep = Annotated[Session, Depends(get_session)]

Authentication Coverage

Rate Limiting

@limiter.limit("5/minute")

Seed Data

Sample Code From the Project

FastAPI Application Setup

app = FastAPI(lifespan=lifespan)
app.state.limiter = limiter
app.add_exception_handler(429, _rate_limit_exceeded_handler)
app.add_middleware(SlowAPIMiddleware)

Router Registration

app.include_router(ui_router)
app.include_router(gig_router)
app.include_router(user_router)
app.include_router(client_router)
app.include_router(venue_router)

Static File Mounting

app.mount("/static", StaticFiles(directory="./static"), name="static")

SQLModel Create Pattern

db_venue = Venue.model_validate(venue)
session.add(db_venue)
session.commit()
session.refresh(db_venue)
return db_venue

Update Pattern

venue_data = venue.model_dump(exclude_unset=True)
db_venue.sqlmodel_update(venue_data)
session.add(db_venue)
session.commit()
session.refresh(db_venue)

More Example PyTest Code

Recommended conftest.py

import pytest
from fastapi.testclient import TestClient

from gig_tracker.app import app


@pytest.fixture
def client():
    with TestClient(app) as test_client:
        yield test_client

Using the Fixture

def test_get_venues_returns_list(client):
    response = client.get("/api/venues")

    assert response.status_code == 200
    assert isinstance(response.json(), list)

Parametrized UI Status Test

import pytest


@pytest.mark.parametrize(
    "path, expected_status",
    [
        ("/", 200),
        ("/gigs", 200),
        ("/clients", 200),
        ("/venues", 200),
    ],
)
def test_ui_pages_load(client, path, expected_status):
    response = client.get(path)

    assert response.status_code == expected_status

Validation Error Test

def test_create_venue_requires_name(client):
    response = client.post(
        "/api/venues",
        json={"address": "123 Missing Name Street"},
    )

    assert response.status_code == 422

Tutorial and Setup Guide

1. Clone the Repository

git clone https://github.com/BrianGator/Python-PyTest-Scripting.git
cd Python-PyTest-Scripting

2. Go to the App Folder

cd gig_tracker

3. Confirm Python Version

python --version

4. Install Poetry

pip install poetry

5. Install Dependencies

poetry install

6. Run the FastAPI App

poetry run fastapi dev app.py

poetry run uvicorn gig_tracker.app:app --reload

7. Run PyTest

poetry run pytest

8. Run a Single Test File

poetry run pytest tests/test_venues_api.py

9. Run a Single Test

poetry run pytest tests/test_venues_api.py::test_get_venues_returns_list

10. Run With Verbose Output

poetry run pytest -v

11. Run Ruff Linting

poetry run ruff check .

12. Run Mypy Type Checking

poetry run mypy .

PyTest Automation Tips

Use Fixtures for Setup

@pytest.fixture
def venue_payload():
    return {
        "name": "QA Venue",
        "address": "123 Test Street",
    }

Keep Tests Independent

Test Positive and Negative Paths

Use Descriptive Test Names

def test_get_missing_venue_returns_404():

def test_1():

Assert Status Code and Body

assert response.status_code == 200
body = response.json()
assert isinstance(body, list)

Avoid Hardcoded Secrets

Use Parametrization

@pytest.mark.parametrize("path", ["/", "/gigs", "/clients", "/venues"])
def test_pages_load(client, path):
    assert client.get(path).status_code == 200

Separate Unit, API, and UI Tests

tests/unit/
tests/api/
tests/ui/

Recommended Improvements

1. Add Committed PyTest Tests

gig_tracker/tests/

2. Add Test Database Isolation

3. Move Secrets to Environment Variables

4. Add CI Workflow

.github/workflows/python-tests.yml

name: Python PyTest

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

      - name: Install Poetry
        run: pip install poetry

      - name: Install dependencies
        working-directory: gig_tracker
        run: poetry install

      - name: Run tests
        working-directory: gig_tracker
        run: poetry run pytest -v

5. Add Coverage Reporting

poetry add --group dev pytest-cov
poetry run pytest --cov=gig_tracker --cov-report=term-missing

6. Add API Contract Tests

7. Add Rate Limit Tests

8. Add Browser UI Tests Later

Author