TDD Project Part 1 — Library Catalogue

• Drive a small domain model entirely from tests.
• Use a fixture for the catalogue.
• Cover happy paths AND business-rule errors (double-loan).
• Refactor under green at the end of the build.

A Catalogue should:
  - start empty
  - add a book (title) and find it
  - track whether a book is available
  - borrow a book → marks it unavailable
  - return a book → marks it available
  - reject borrowing an already-borrowed book
  - reject borrowing/returning an unknown book

🔴🟢 Step 1 — starts empty

# test_catalogue.py
import pytest
from catalogue import Catalogue

@pytest.fixture
def cat():
    return Catalogue()

def test_starts_empty(cat):
    assert len(cat) == 0

# catalogue.py
class Catalogue:
    def __init__(self):
        self._books = {}        # title -> available?
    def __len__(self):
        return len(self._books)

🔴🟢 Step 2 — add & find

def test_add_book(cat):
    cat.add("Dune")
    assert cat.has("Dune")
    assert len(cat) == 1

    def add(self, title):
        self._books[title] = True       # True = available
    def has(self, title):
        return title in self._books

🔴🟢 Step 3 — availability + borrow

def test_borrow_makes_unavailable(cat):
    cat.add("Dune")
    cat.borrow("Dune")
    assert not cat.is_available("Dune")

    def is_available(self, title):
        return self._books[title]
    def borrow(self, title):
        self._books[title] = False

🔴🟢 Step 4 — business rules (errors)

def test_double_borrow_raises(cat):
    cat.add("Dune"); cat.borrow("Dune")
    with pytest.raises(ValueError, match="already borrowed"):
        cat.borrow("Dune")

def test_borrow_unknown_raises(cat):
    with pytest.raises(KeyError):
        cat.borrow("Ghost")

    def borrow(self, title):
        if title not in self._books:
            raise KeyError(title)
        if not self._books[title]:
            raise ValueError("already borrowed")
        self._books[title] = False

# catalogue.py — emerged from the tests
class Catalogue:
    def __init__(self):
        self._books = {}                  # title -> available (bool)

    def __len__(self):
        return len(self._books)

    def add(self, title):
        self._books[title] = True

    def has(self, title):
        return title in self._books

    def is_available(self, title):
        self._check(title)
        return self._books[title]

    def borrow(self, title):
        self._check(title)
        if not self._books[title]:
            raise ValueError("already borrowed")
        self._books[title] = False

    def return_book(self, title):
        self._check(title)
        self._books[title] = True

    def _check(self, title):              # refactored: shared guard
        if title not in self._books:
            raise KeyError(title)

# test_catalogue.py — the full Part-1 suite
import pytest
from catalogue import Catalogue

@pytest.fixture
def cat():
    return Catalogue()

def test_starts_empty(cat):       assert len(cat) == 0
def test_add(cat):                cat.add("Dune"); assert cat.has("Dune")
def test_new_book_available(cat): cat.add("Dune"); assert cat.is_available("Dune")
def test_borrow(cat):
    cat.add("Dune"); cat.borrow("Dune"); assert not cat.is_available("Dune")
def test_return(cat):
    cat.add("Dune"); cat.borrow("Dune"); cat.return_book("Dune")
    assert cat.is_available("Dune")
def test_double_borrow_raises(cat):
    cat.add("Dune"); cat.borrow("Dune")
    with pytest.raises(ValueError, match="already borrowed"):
        cat.borrow("Dune")
def test_unknown_raises(cat):
    with pytest.raises(KeyError):
        cat.borrow("Ghost")

$ pytest test_catalogue.py -v
7 passed
$ pytest --cov=catalogue
catalogue.py  ...  100%     ← coverage came for free

Read the diff

The _check helper is a refactor done at the end, under green — it removed the duplicated "is it a known title?" guard from three methods. The class was never designed up front; it grew to satisfy seven tests, and hit 100% coverage by construction. Part 2 adds search, filter, and sort the same way.

You built a domain class entirely test-first: each behaviour (add, borrow, return) and each business rule (double-borrow, unknown title) arrived as a failing test, then minimal code. The shared _check guard was a green-bar refactor. Coverage hit 100% naturally. Part 2 extends it with search/filter/sort under the same discipline.