pytest, Factories & Browser Tests

from django.conf import settings
from django.core.validators import MaxValueValidator, MinValueValidator
from django.db import models
from django.urls import reverse


class Author(models.Model):
    name = models.CharField(max_length=200)

    def __str__(self):
        return self.name


class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name="books")
    isbn = models.CharField(max_length=13, unique=True)
    published = models.DateField()
    is_published = models.BooleanField(default=True)
    cover_url = models.URLField(blank=True)

    def __str__(self):
        return self.title

    def get_absolute_url(self):
        return reverse("catalog:book-detail", args=[self.pk])


class Review(models.Model):
    book = models.ForeignKey(Book, on_delete=models.CASCADE, related_name="reviews")
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    rating = models.PositiveSmallIntegerField(
        validators=[MinValueValidator(1), MaxValueValidator(5)]
    )
    text = models.TextField()

# catalog/forms.py
from django import forms

from .models import Review


class ReviewForm(forms.ModelForm):
    class Meta:
        model = Review
        fields = ["rating", "text"]
        widgets = {"rating": forms.NumberInput(attrs={"min": 1, "max": 5})}


# catalog/views.py
from django.contrib.auth.decorators import login_required
from django.shortcuts import get_object_or_404, redirect, render
from django.views.decorators.http import require_POST

from .forms import ReviewForm
from .models import Book


def book_list(request):
    books = Book.objects.filter(is_published=True).select_related("author").order_by("title")
    return render(request, "catalog/book_list.html", {"books": books})


def book_detail(request, pk):
    book = get_object_or_404(Book.objects.select_related("author"), pk=pk, is_published=True)
    return render(request, "catalog/book_detail.html", {"book": book, "form": ReviewForm()})


@login_required
@require_POST
def add_review(request, pk):
    book = get_object_or_404(Book, pk=pk, is_published=True)
    form = ReviewForm(request.POST)
    if form.is_valid():
        review = form.save(commit=False)
        review.book, review.user = book, request.user
        review.save()
        return redirect(book)
    return render(request, "catalog/book_detail.html", {"book": book, "form": form}, status=400)

import json
from urllib.request import urlopen

OPEN_LIBRARY = "https://openlibrary.org/isbn/{isbn}.json"


def fetch_cover_url(isbn: str) -> str:
    """Ask Open Library for the cover of a book; return "" when it has none."""
    with urlopen(OPEN_LIBRARY.format(isbn=isbn), timeout=5) as response:
        data = json.load(response)
    covers = data.get("covers") or []
    return f"https://covers.openlibrary.org/b/id/{covers[0]}-M.jpg" if covers else ""


def refresh_cover(book) -> bool:
    """Store the Open Library cover on the book; network errors keep the old value."""
    try:
        url = fetch_cover_url(book.isbn)
    except OSError:
        return False
    book.cover_url = url
    book.save(update_fields=["cover_url"])
    return True

python -m pip install pytest pytest-django

[tool.pytest.ini_options]
DJANGO_SETTINGS_MODULE = "config.settings"
python_files = ["test_*.py", "*_tests.py"]
addopts = "--strict-markers --reuse-db"
markers = [
    "browser: end-to-end tests that drive a real browser",
]

$ python -m pytest -q
............................                                             [100%]
28 passed in 3.32s
$ python -m pytest -q -m "not browser"
.........................                                                [100%]
25 passed, 3 deselected in 0.64s

import pytest
from django.urls import reverse

from catalog.tests.factories import BookFactory


def test_list_shows_only_published_books(client, db):
    BookFactory(title="Dune")
    BookFactory(title="Secret draft", draft=True)

    response = client.get(reverse("catalog:book-list"))

    assert response.status_code == 200
    assert [b.title for b in response.context["books"]] == ["Dune"]
    assert "Secret draft" not in response.content.decode()


@pytest.mark.django_db
def test_create_saves_the_whole_graph():
    ...

import pytest

from catalog.tests.factories import BookFactory, UserFactory


@pytest.fixture
def book(db):
    return BookFactory(title="Dune")


@pytest.fixture
def reader(db):
    return UserFactory(username="ana")


@pytest.fixture
def reader_client(client, reader):
    client.force_login(reader)
    return client


@pytest.fixture(autouse=True)
def _fast_passwords(settings):
    settings.PASSWORD_HASHERS = ["django.contrib.auth.hashers.MD5PasswordHasher"]

import pytest

pytestmark = [pytest.mark.browser, pytest.mark.django_db(transaction=True)]

import datetime
import secrets

import factory
from django.contrib.auth import get_user_model

from catalog.models import Author, Book, Review

TEST_PASSWORD = secrets.token_urlsafe(16)  # random per run, never a literal


class UserFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = get_user_model()
        django_get_or_create = ("username",)

    username = factory.Sequence(lambda n: f"reader{n}")
    email = factory.LazyAttribute(lambda o: f"{o.username}@example.com")
    password = factory.django.Password(TEST_PASSWORD)


class AuthorFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Author

    name = factory.Faker("name")


class BookFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Book

    title = factory.Faker("sentence", nb_words=3)
    author = factory.SubFactory(AuthorFactory)
    isbn = factory.Faker("isbn13", separator="")
    published = factory.Faker("date_between", start_date="-30y", end_date="today")
    is_published = True

    class Params:
        draft = factory.Trait(is_published=False)
        classic = factory.Trait(published=datetime.date(1925, 4, 10))


class ReviewFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Review

    book = factory.SubFactory(BookFactory)
    user = factory.SubFactory(UserFactory)
    rating = factory.Faker("pyint", min_value=1, max_value=5)
    text = factory.Faker("paragraph")

import datetime

import pytest

from catalog.models import Author, Book
from catalog.tests.factories import BookFactory, ReviewFactory


def test_build_does_not_touch_the_database():
    book = BookFactory.build()          # no "db" fixture needed
    assert book.pk is None
    assert book.author.pk is None
    assert len(book.isbn) == 13


@pytest.mark.django_db
def test_create_saves_the_whole_graph():
    review = ReviewFactory(rating=4)
    assert review.pk and review.book.pk and review.book.author.pk and review.user.pk
    assert Book.objects.count() == Author.objects.count() == 1


@pytest.mark.django_db
def test_traits_and_overrides():
    draft = BookFactory(draft=True)
    classic = BookFactory(classic=True, author__name="F. Scott Fitzgerald")
    assert draft.is_published is False
    assert classic.published == datetime.date(1925, 4, 10)
    assert classic.author.name == "F. Scott Fitzgerald"


@pytest.mark.django_db
def test_batches_share_one_author():
    author = BookFactory().author
    BookFactory.create_batch(3, author=author)
    assert author.books.count() == 4

from model_bakery import baker

from catalog.models import Book, Review


@pytest.mark.django_db
def test_model_bakery_fills_required_fields():
    review = baker.make(Review, rating=5)
    assert review.book.author.name          # random but valid
    books = baker.make(Book, _quantity=3)
    assert len({b.isbn for b in books}) == 3


def test_model_bakery_prepare_is_unsaved():
    book = baker.prepare(Book, title="Dune")
    assert book.pk is None

from model_bakery.recipe import Recipe, foreign_key, seq

from catalog.models import Author, Book

tolkien = Recipe(Author, name="J. R. R. Tolkien")
book = Recipe(Book, title=seq("Volume "), author=foreign_key(tolkien), is_published=True)
draft = book.extend(is_published=False)

@pytest.mark.django_db
def test_model_bakery_recipes():
    first, second = baker.make_recipe("catalog.book", _quantity=2)
    draft = baker.make_recipe("catalog.draft")
    assert first.title.startswith("Volume ") and first.title != second.title
    assert first.author.name == "J. R. R. Tolkien"
    assert draft.is_published is False

import io
import json
from unittest import mock

import pytest

from catalog import covers
from catalog.tests.factories import BookFactory


def fake_response(payload):
    return io.BytesIO(json.dumps(payload).encode())


def test_fetch_cover_url_builds_the_cover_link():
    with mock.patch.object(covers, "urlopen", return_value=fake_response({"covers": [42]})) as urlopen:
        assert covers.fetch_cover_url("9780441013593") == "https://covers.openlibrary.org/b/id/42-M.jpg"
    urlopen.assert_called_once_with("https://openlibrary.org/isbn/9780441013593.json", timeout=5)


@pytest.mark.django_db
def test_refresh_cover_saves_the_url():
    book = BookFactory(cover_url="")
    with mock.patch("catalog.covers.fetch_cover_url", return_value="https://img.test/1.jpg"):
        assert covers.refresh_cover(book) is True
    book.refresh_from_db()
    assert book.cover_url == "https://img.test/1.jpg"


@pytest.mark.django_db
def test_refresh_cover_survives_network_errors():
    book = BookFactory(cover_url="https://img.test/old.jpg")
    with mock.patch.object(covers, "urlopen", side_effect=TimeoutError("slow partner")):
        assert covers.refresh_cover(book) is False
    book.refresh_from_db()
    assert book.cover_url == "https://img.test/old.jpg"


def test_monkeypatch_variant(monkeypatch):
    monkeypatch.setattr(covers, "urlopen", lambda url, timeout: fake_response({}))
    assert covers.fetch_cover_url("0000000000000") == ""

[tool.coverage.run]
source = ["catalog", "config"]
branch = true
omit = ["*/migrations/*", "*/tests/*", "config/asgi.py", "config/wsgi.py"]

[tool.coverage.report]
show_missing = true
skip_covered = true
fail_under = 90

$ python -m pip install coverage pytest-cov
$ coverage run -m pytest -q -m "not browser"
.........................                                                [100%]
25 passed, 3 deselected in 0.97s
$ coverage report
Name                 Stmts   Miss Branch BrPart  Cover   Missing
----------------------------------------------------------------
catalog/models.py       24      1      0      0    96%   23
config/settings.py      24      1      2      1    92%   139
----------------------------------------------------------------
TOTAL                  109      2      4      1    97%

9 files skipped due to complete coverage.
$ coverage html            # browsable report in htmlcov/index.html
$ python -m pytest --cov --cov-report=term -q -m "not browser"
...
Required test coverage of 90.0% reached. Total coverage: 97.35%
25 passed, 3 deselected in 1.01s

python -m pip install pytest-playwright
python -m playwright install chromium        # once per machine; CI adds --with-deps

import os

import pytest
from playwright.sync_api import Page, expect

from catalog.tests.factories import TEST_PASSWORD, BookFactory, UserFactory

# pytest-playwright runs an event loop in the test thread; let the ORM run there.
os.environ.setdefault("DJANGO_ALLOW_ASYNC_UNSAFE", "true")

pytestmark = [pytest.mark.browser, pytest.mark.django_db(transaction=True)]


def test_reader_logs_in_and_reviews_a_book(page: Page, live_server):
    book = BookFactory(title="Dune")
    UserFactory(username="ana")

    page.goto(f"{live_server.url}/accounts/login/?next=/books/{book.pk}/")
    page.get_by_label("Username").fill("ana")
    page.get_by_label("Password").fill(TEST_PASSWORD)
    page.get_by_role("button", name="Log in").click()

    expect(page.get_by_role("heading", name="Dune")).to_be_visible()
    page.get_by_label("Rating").fill("5")
    page.get_by_label("Text").fill("Still the best desert planet.")
    page.get_by_role("button", name="Post review").click()

    expect(page.locator("#reviews li")).to_have_text("5/5 -- Still the best desert planet.")

$ python -m pytest -m browser -q
...                                                                      [100%]
3 passed, 25 deselected in 3.89s

import os

import pytest
from django.contrib.staticfiles.testing import StaticLiveServerTestCase
from playwright.sync_api import expect, sync_playwright

from catalog.tests.factories import BookFactory


@pytest.mark.browser
class PlaywrightReviewTests(StaticLiveServerTestCase):
    @classmethod
    def setUpClass(cls):
        os.environ["DJANGO_ALLOW_ASYNC_UNSAFE"] = "true"
        super().setUpClass()
        cls.playwright = sync_playwright().start()
        cls.browser = cls.playwright.chromium.launch()

    @classmethod
    def tearDownClass(cls):
        cls.browser.close()
        cls.playwright.stop()
        super().tearDownClass()

    def test_book_list(self):
        BookFactory(title="Dune")
        page = self.browser.new_page()
        page.goto(f"{self.live_server_url}/")
        expect(page.get_by_role("link", name="Dune")).to_be_visible()
        page.close()

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait

from catalog.tests.factories import TEST_PASSWORD, BookFactory, UserFactory


@pytest.mark.browser
class SeleniumReviewTests(StaticLiveServerTestCase):
    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        options = webdriver.ChromeOptions()
        options.add_argument("--headless=new")
        cls.selenium = webdriver.Chrome(options=options)
        cls.wait = WebDriverWait(cls.selenium, timeout=5)

    @classmethod
    def tearDownClass(cls):
        cls.selenium.quit()
        super().tearDownClass()

    def test_login_and_review(self):
        book = BookFactory(title="Dune")
        UserFactory(username="ana")
        self.selenium.get(f"{self.live_server_url}/accounts/login/?next=/books/{book.pk}/")
        self.selenium.find_element(By.NAME, "username").send_keys("ana")
        self.selenium.find_element(By.NAME, "password").send_keys(TEST_PASSWORD)
        self.selenium.find_element(By.CSS_SELECTOR, "button[type=submit]").click()
        rating = self.wait.until(EC.presence_of_element_located((By.NAME, "rating")))
        rating.send_keys("4")
        self.selenium.find_element(By.NAME, "text").send_keys("Dense but rewarding.")
        self.selenium.find_element(By.XPATH, "//button[text()='Post review']").click()
        self.wait.until(
            EC.text_to_be_present_in_element((By.ID, "reviews"), "4/5 -- Dense but rewarding.")
        )

$ python manage.py test catalog.tests.test_browser_live_server
Found 2 test(s).
System check identified no issues (0 silenced).
..
----------------------------------------------------------------------
Ran 2 tests in 2.785s

OK

import os

SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]  # no fallback: a missing key fails at start-up

# ...

# CI: switch to PostgreSQL when the workflow provides it
if os.environ.get("POSTGRES_DB"):
    DATABASES["default"] = {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": os.environ["POSTGRES_DB"],
        "USER": os.environ.get("POSTGRES_USER", "postgres"),
        "PASSWORD": os.environ.get("POSTGRES_PASSWORD", ""),
        "HOST": os.environ.get("POSTGRES_HOST", "localhost"),
        "PORT": os.environ.get("POSTGRES_PORT", "5432"),
    }

Django==6.1.1
psycopg[binary]==3.3.6
pytest==9.1.1
pytest-django==4.14.0
pytest-cov==7.1.0
pytest-xdist==3.8.0
factory-boy==3.3.3
model-bakery==1.24.1
pytest-playwright==0.9.0
selenium==4.50.0

name: tests

on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ["3.12", "3.13", "3.14"]

    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_DB: bookshelf
          POSTGRES_HOST_AUTH_METHOD: trust   # throwaway CI container, no secret to leak
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    env:
      POSTGRES_DB: bookshelf
      POSTGRES_HOST: localhost

    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-python@v7
        with:
          python-version: ${{ matrix.python-version }}
          cache: pip
          cache-dependency-path: requirements-dev.txt
      - run: python -m pip install -r requirements-dev.txt
      - name: Generate a throw-away SECRET_KEY for this job
        run: |
          key="$(python -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())')"
          echo "::add-mask::$key"
          echo "DJANGO_SECRET_KEY=$key" >> "$GITHUB_ENV"
      - run: python manage.py check
      - run: python manage.py makemigrations --check --dry-run
      - run: python -m playwright install --with-deps chromium
      - run: python -m pytest --cov --cov-report=xml -n auto -m "not browser"
      - run: python -m pytest -m browser --tracing=retain-on-failure
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: playwright-traces-${{ matrix.python-version }}
          path: test-results/