Unit test con Pytest

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.

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.

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:

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.

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:

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.

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.

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.

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.

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?

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!