Fixture organization in FastAPI - Mini Project: Build & Apply

Fixture Organization in FastAPI Testing

📖 Scenario: You are building a simple FastAPI app that manages a list of books. You want to write tests that use fixtures to organize your test data and setup.

🎯 Goal: Create and organize fixtures in FastAPI tests using pytest to provide test data and a test client.

📋 What You'll Learn

Create a fixture for a list of books with exact entries

Create a fixture for a FastAPI test client

Use the fixtures in a test function to check the number of books

Organize fixtures properly for reuse in tests

💡 Why This Matters

🌍 Real World

Organizing fixtures helps keep tests clean and reusable when building APIs with FastAPI.

💼 Career

Understanding fixture organization is essential for writing maintainable automated tests in professional FastAPI projects.

1

Create a fixture with a list of books

Create a fixture function called books that returns a list of dictionaries with these exact entries: {'id': 1, 'title': '1984'}, {'id': 2, 'title': 'Brave New World'}, and {'id': 3, 'title': 'Fahrenheit 451'}. Use the @pytest.fixture decorator.

FastAPI

import pytest

# Create a fixture called books that returns the list of book dictionaries
# Your code here

Hint

Use @pytest.fixture above a function named books that returns the list.

2

Create a fixture for the FastAPI test client

Import FastAPI and TestClient from fastapi and fastapi.testclient. Create a fixture called client that creates a FastAPI app instance and returns a TestClient for it. Use the @pytest.fixture decorator.

FastAPI

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient

@pytest.fixture
def books():
    return [
        {'id': 1, 'title': '1984'},
        {'id': 2, 'title': 'Brave New World'},
        {'id': 3, 'title': 'Fahrenheit 451'}
    ]

# Create a fixture called client that returns a TestClient for a FastAPI app
# Your code here

Hint

Import FastAPI and TestClient. Define client fixture that returns TestClient(app).

3

Write a test function using the fixtures

Write a test function called test_books_count that takes books as a parameter. Inside, assert that the length of books is exactly 3.

FastAPI

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient

@pytest.fixture
def books():
    return [
        {'id': 1, 'title': '1984'},
        {'id': 2, 'title': 'Brave New World'},
        {'id': 3, 'title': 'Fahrenheit 451'}
    ]

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

# Write a test function test_books_count that takes books and asserts len(books) == 3
# Your code here

Hint

Define test_books_count with books parameter and assert length is 3.

4

Add a route to use the fixtures in the app

Add a GET route /books to the FastAPI app inside the client fixture that returns the books list. Modify the client fixture to accept books as a parameter and use it in the route. This completes the fixture organization for testing.

FastAPI

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient

@pytest.fixture
def books():
    return [
        {'id': 1, 'title': '1984'},
        {'id': 2, 'title': 'Brave New World'},
        {'id': 3, 'title': 'Fahrenheit 451'}
    ]

@pytest.fixture
def client(books):
    app = FastAPI()
    # Add a GET /books route that returns books
    # Your code here
    return TestClient(app)

def test_books_count(books):
    assert len(books) == 3

Hint

Modify client fixture to accept books, add @app.get('/books') route returning books.

Practice

1. What is the main purpose of using fixtures in FastAPI testing with pytest?

easy

A. To deploy the FastAPI app to production

B. To prepare resources and keep test code clean

C. To write the main application logic

D. To create database models

Solution

1. Step 1: Understand the role of fixtures

   Fixtures are used to prepare resources like database connections or test clients before tests run.

2. Step 2: Recognize their benefit in test code

   They help keep test code clean by avoiding repeated setup code in each test.

3. Final Answer:

   To prepare resources and keep test code clean -> Option B

4. Quick Check:

   Fixtures = prepare resources + clean tests [OK]

Hint: Fixtures set up test resources to avoid repeating code [OK]

Common Mistakes:

• Confusing fixtures with app logic
• Thinking fixtures deploy the app
• Using fixtures to define database models

2. Which of the following is the correct way to declare a fixture in pytest for FastAPI tests?

easy

A. class MyFixture: pass

B. def my_fixture(): return client

C. @app.get('/test')
def my_fixture(): return client

D. @pytest.fixture
def my_fixture(): yield client

Solution

1. Step 1: Identify pytest fixture syntax

   Fixtures require the decorator @pytest.fixture before the function.

2. Step 2: Recognize yield usage for setup/teardown

   Using yield allows setup before and teardown after the test.

3. Final Answer:

   @pytest.fixture\ndef my_fixture(): yield client -> Option D

4. Quick Check:

   Use @pytest.fixture and yield for fixtures [OK]

Hint: Use @pytest.fixture decorator and yield inside function [OK]

Common Mistakes:

• Missing @pytest.fixture decorator
• Using FastAPI route decorators instead
• Declaring fixture as a class without decorator

3. Given this conftest.py fixture code:

import pytest

@pytest.fixture
def client():
    from fastapi.testclient import TestClient
    from myapp.main import app
    with TestClient(app) as c:
        yield c

What will client.get('/items') return inside a test?

medium

A. A TestClient response object for the '/items' endpoint

B. A syntax error because yield is used incorrectly

C. An exception because app is not imported

D. None, because the fixture does not return anything

Solution

1. Step 1: Analyze the fixture setup

   The fixture creates a TestClient instance for the FastAPI app and yields it for use in tests.

2. Step 2: Understand what client.get('/items') does

   Calling client.get('/items') sends a test HTTP GET request to the '/items' route and returns a response object.

3. Final Answer:

   A TestClient response object for the '/items' endpoint -> Option A

4. Quick Check:

   Fixture yields TestClient, so client.get returns response [OK]

Hint: Fixture yields TestClient; get() returns response object [OK]

Common Mistakes:

• Thinking yield causes syntax error
• Assuming fixture returns None
• Forgetting to import app in fixture

4. Consider this fixture code in conftest.py:

import pytest

@pytest.fixture
def db():
    connection = connect_to_db()
    yield connection
    connection.close()

When running tests, you get an error: NameError: name 'connect_to_db' is not defined. How do you fix it?

medium

A. Import or define the function connect_to_db before using it

B. Remove yield and return connection instead

C. Change fixture to a class instead of a function

D. Rename the fixture to database()

Solution

1. Step 1: Identify cause of NameError

   The error means the function connect_to_db is not defined or imported in the file.

2. Step 2: Fix by importing or defining connect_to_db

   To fix, add the proper import statement or define the function before using it in the fixture.

3. Final Answer:

   Import or define the function connect_to_db before using it -> Option A

4. Quick Check:

   NameError means missing import or definition [OK]

Hint: NameError means missing import or definition [OK]

Common Mistakes:

• Removing yield does not fix NameError
• Changing fixture name won't fix missing function
• Converting to class does not solve missing import

5. You want to share a database fixture across multiple test files in FastAPI. Which is the best way to organize it?

hard

A. Put the fixture inside the main FastAPI app file

B. Copy the fixture code into every test file

C. Define the fixture in conftest.py at the root test folder

D. Define the fixture inside each test function

Solution

1. Step 1: Understand fixture sharing in pytest

   Fixtures defined in conftest.py are automatically discovered and shared across test files in the same folder or subfolders.

2. Step 2: Recognize why other options are poor

   Copying code duplicates it, defining inside test functions prevents reuse, and putting fixtures in app files mixes concerns.

3. Final Answer:

   Define the fixture in conftest.py at the root test folder -> Option C

4. Quick Check:

   conftest.py shares fixtures across tests [OK]

Hint: Use conftest.py to share fixtures across test files [OK]

Common Mistakes:

• Duplicating fixture code in every test file
• Defining fixtures inside test functions
• Mixing fixtures with app code