FastAPI Backend Development Bootcamp · Lesson

Unit Testing with Pytest

Write effective unit tests for your FastAPI functions and modules using the Pytest framework.

Unit Testing with Pytest is a free FastAPI Backend Development Bootcamp lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the FastAPI Backend Development Bootcamp learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What is Unit Testing?

Welcome to unit testing! This is a fundamental practice in software development that helps ensure your code works correctly.

Unit testing focuses on testing the smallest testable parts of an application, called 'units'.
A 'unit' can be a function, a method, or a class. The goal is to isolate it and verify it behaves as expected.
This helps catch bugs early, makes code easier to refactor, and builds confidence in your application's reliability.

Introducing Pytest

For Python, one of the most popular and powerful testing frameworks is Pytest. It's known for its simplicity and flexibility.

Pytest makes it easy to write simple, yet scalable tests.
It automatically discovers tests, provides detailed failure reports, and supports advanced features like fixtures.
You'll find Pytest widely used in the Python community, including for FastAPI projects.

Installing Pytest

Before we write our first test, we need to install Pytest. It's a standard Python package.

Open your terminal or command prompt and run the following command:

pip install pytest

Your First Function to Test

Let's create a simple Python function that we want to test. We'll put this in a file named utils.py.

This function simply multiplies two numbers. We'll write tests to ensure it always returns the correct product.

def multiply(x, y):
    return x * y

if __name__ == "__main__":
    # This part shows how to use the function directly
    print(f"5 * 3 = {multiply(5, 3)}")
    print(f"10 * 0 = {multiply(10, 0)}")

Crafting Your First Test

Now, let's write tests for our multiply function. Pytest automatically discovers test files that start with test_ (e.g., test_utils.py) and test functions within them that also start with test_.

Create a new file named test_utils.py in the same directory as utils.py:

from utils import multiply # Import the function to test

def test_multiply_positive_numbers():
    # Check if 2 * 3 equals 6
    assert multiply(2, 3) == 6

def test_multiply_by_zero():
    # Check if any number multiplied by zero is zero
    assert multiply(5, 0) == 0

def test_multiply_negative_numbers():
    # Check multiplication with a negative number
    assert multiply(-2, 4) == -8

Executing Your Tests

With both utils.py and test_utils.py saved in the same folder, you can now run your tests!

Open your terminal in that directory and simply type pytest. Pytest will find and execute all tests.

# In your terminal or command prompt:
pytest

Understanding Assertions

The core of any test is the assert statement. It's how you verify that a condition is true. If an assert statement fails, Pytest marks the test as failed.

Here are some common ways to use assert:

assert actual == expected: Checks if two values are equal.
assert actual != unexpected: Checks if two values are not equal.
assert item in collection: Checks if an item exists in a list, set, or string.
assert not condition: Checks if a condition is false.
assert value > 0: Checks for numerical comparisons.

Reusable Test Setup with Fixtures

Sometimes, multiple tests need the same setup (e.g., a temporary file, a configured object). Pytest fixtures provide a way to define reusable setup and teardown logic.

A fixture is a function decorated with @pytest.fixture. Tests can then request the fixture by naming it as an argument.

import pytest

@pytest.fixture
def sample_data():
    # This fixture provides a list of numbers for tests
    print("\nSetting up sample_data") # Runs before tests
    yield [10, 20, 30]
    print("\nTeardown sample_data") # Runs after tests

def test_data_length(sample_data):
    assert len(sample_data) == 3

def test_data_contains_value(sample_data):
    assert 20 in sample_data

Handling Expected Errors

What if your function is supposed to raise an error under certain conditions? Pytest can test for that too, using pytest.raises.

This ensures your error handling logic works correctly by asserting that a specific exception is raised.

# my_processor.py
def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero!")
    return a / b

# test_my_processor.py
import pytest
from my_processor import divide

def test_divide_by_zero_raises_error():
    with pytest.raises(ValueError, match="Cannot divide by zero!"):
        divide(10, 0)

def test_divide_positive_numbers():
    assert divide(10, 2) == 5.0

Pytest Fundamentals Check

Consider the Python function and the Pytest test below:

# calculator.py
def add(a, b):
    return a + b

# test_calculator.py
from calculator import add

def test_add_positive():
    assert add(5, 3) == 8

def test_add_negative_numbers():
    assert add(-2, -4) == -6

def test_add_mixed_numbers():
    assert add(10, -5) == 5

If you run pytest in the terminal, what will be the outcome?

Unit Testing Recap

Great job! You've learned the basics of unit testing with Pytest. This is a crucial skill for building robust applications.

Unit tests verify small, isolated parts of your code.
Pytest is a powerful and easy-to-use framework for writing and running these tests.
You use assert statements to check for expected outcomes.
Fixtures help set up reusable data or resources for your tests.
pytest.raises is used to test that your code correctly raises specific exceptions.

Next, we'll explore how to perform integration testing specifically for your FastAPI endpoints!

Frequently asked questions

Is the “Unit Testing with Pytest” lesson free?

Yes — the full text of “Unit Testing with Pytest” is free to read here on the web, and the FastAPI Backend Development Bootcamp course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the FastAPI Backend Development Bootcamp course, upgrade to CoddyKit PRO.

What will I learn in “Unit Testing with Pytest”?

Write effective unit tests for your FastAPI functions and modules using the Pytest framework. You practise FastAPI Backend Development Bootcamp with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start FastAPI Backend Development Bootcamp?

No prior experience is required. FastAPI Backend Development Bootcamp on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Unit Testing with Pytest” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this FastAPI Backend Development Bootcamp lesson?

Yes. Every FastAPI Backend Development Bootcamp lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to FastAPI Backend Development Bootcamp