Unit Testing with Pytest: Unit Tests, Fixtures, Parameterization.

In this post I will highlight the most important features of unit testing with Pytest, Python's most popular testing framework!

What is Unit Testing and Why does it Matter?

Unit testing is a software development process in which the smallest units of code are tested for proper operation. The smallest units of code in Python are typically functions. Ensuring the proper operation of functions will decrease the number of bugs throughout a codebase. Unit testing also forces you to write testable code and when code is testable it is generally cleaner. Functions are more likely to adhere to the principle of doing one thing & one thing only and the codebase will be more readable. Unit testing is a process that every development team should practice!

What is Pytest?

Pytest is Python's most popular testing framework. Before you can start writing unit tests with Pytest, you must download and install Pytest as a package in your project. Pytest can be installed from PyPI by entering the following command into your terminal pip install pytest.

Create a Unit Test:

Once installed you can start writing unit tests! Below is an example of a Python Projects directory structure: Inside geometry.py there is the following method is_triangle. This method determines if 3 side lengths can form a triangle:

class Geometry:

    def is_triangle(side_1: int, side_2: int, side_3: int) -> bool:
        """
        Given 3 side lengths, determine if the sides can create a triangle.

        :param side_1: A side of a potential triangle
        :param side_2: A side of a potential triangle
        :param side_3: A side of a potential triangle
        """
        is_triangle = False

        if (side_1 + side_2 > side_3) and (side_1 + side_3 > side_2) and (side_2 + side_3 > side_1):
            is_triangle = True

        return is_triangle

We now want to test that this method behaves as expected. We will want to ensure that this method returns True or False for valid or invalid side lengths. Since we are testing for both valid and invalid triangles, we will make 2 separate unit tests inside test_geometry.py:

from src.geometry import Geometry

def test_is_a_triangle():
    """Ensure that given a valid set of triangle sides the is_triangle method will return True."""
    assert Geometry.is_triangle(6,6,6)

def test_is_not_a_triangle():
    """Ensure that given an invalid set of triangle sides the is_triangle method will return False."""
    assert not Geometry.is_triangle(0, 1, 2)

Within these tests you will notice the assert keyword. In order for a test to pass, the assert keyword must be followed by the boolean value True. In the first test, we expect Geometry.is_triangle(6,6,6) to return True and thus we write assert Geometry.is_triangle(6,6,6). In the second test, we expect Geometry.is_triangle(0, 1, 2) to return False and thus we write assert not Geometry.is_triangle(0, 1, 2). (Note - Unit Tests can contain multiple assert statements).

In addition to how these tests are written, notice how the test module is prefixed with test_ (test_geometry.py) and the test functions are prefixed with test_ (test_is_a triangle). This is not personal preference, Pytest requires this naming convention in order to recognize which tests to collect and run. When the pytest command is entered into the terminal, Pytest will search the current directory for modules prefixed with test_ and functions, within those modules, prefixed with test_. Once Pytest has identified and collected all these tests, it will run them! Below is an image of me running the unit tests:

In the image above, the 2 green dots represent the 2 tests that were found in the test_geometry.py module. They are colored green which represents that they have passed. If a test fails, the test will be marked with a red F instead of a green dot. Helpful debug information will also be displayed in the terminal to show you where and why the test failed.

Create a Fixture:

As a test suit grows, you may find yourself duplicating data throughout tests. One way to combat duplication is through the use of Pytest Fixtures.

Fixtures are functions that provide data to setup your tests. They are decorated with @pytest.fixture and they return a value. Once a fixture has been made, it can be used as an argument in unit test functions. Unit tests, that have a fixture as an argument, will have access to the return value of the fixture. Below is an example of 3 new functions that calculate volumes of 3D shapes; below that is a fixture and the corresponding unit tests:

Functions:

    def volume_rectangular_prism(length: float, width: float, height: float) -> float:
        return length * width * height

    def volume_rhombic_prism(long_diagonal: float, short_diagonal, length: float) -> float:
        return long_diagonal * short_diagonal * length * 0.5

    def volume_rectangular_pyramid(length: float, width: float, height: float) -> float:
        return length * width * height / 3

Fixture and Unit Tests:

import pytest
from src.geometry import Geometry

@pytest.fixture
def dimension() -> list[float]:
    return [1.0, 2.0, 3.0]

def test_volume_rectangular_prism(dimension):
    """Ensure that the rectangular_prism function calculates the volume correctly."""
    assert Geometry.volume_rectangular_prism(dimension[0], dimension[1], dimension[2]) == 6.0

def test_volume_rhombic_prism(dimension):
    """Ensure that the rhombic_prism function calculates the volume correctly."""
    assert Geometry.volume_rhombic_prism(dimension[0], dimension[1], dimension[2]) == 3.0

def test_volume_rectangular_pyramid(dimension):
    """Ensure that the rectangular_pyramid function calculates the volume correctly."""
    assert Geometry.volume_rectangular_pyramid(dimension[0], dimension[1], dimension[2]) == 2.0

The fixtures name is dimension and it is used as an argument in all 3 test functions. The dimension values are then accessed through list indices. While this isn't the most practical use case of a fixture (we could've just written the numbers into each test), hopefully you can see how duplication across a test suit can be minimized when fixtures are used.

Parameterize a Unit Test:

The last concept that is frequently used in unit testing is parameterization. Parameterization allows you to write 1 unit test that can be run multiple times with different parameters. For example, when we tested the is_triangle method we only tested the side lengths (6, 6, 6), an equilateral triangle. But we may want to test other combinations of numbers for the other types of triangles (isosceles and scalene). Without parameterization we'd have to write 3 separate unit tests:

def test_is_an_equilateral_triangle():
    """Ensure that given a valid set of equilateral triangle sides, the is_triangle method will return True."""
    assert Geometry.is_triangle(6,6,6)

def test_is_an_isosceles_triangle():
    """Ensure that given a valid set of isosceles triangle sides, the is_triangle method will return True."""
    assert Geometry.is_triangle(4,4,6)

def test_is_an_scalene_triangle():
    """Ensure that given a valid set of scalene triangle sides, the is_triangle method will return True."""
    assert Geometry.is_triangle(4,5,6)

With Pytest Parameterization we can condense these 3 unit tests into 1. A parameterized unit test will be decorated with @pytest.mark.parametrize(). This decorator will accept a string argument, which will be the variables name, followed by an argument that is a list of values that the variable will take on for each iteration of the unit test. In the code below, the variable that will be parameterized is named side and this variable will take on the values [6, 6, 6], [4, 4, 6] & [4, 5, 6] as the unit test is iterated over 3 times:

@pytest.mark.parametrize('side', [[6, 6, 6], [4, 4, 6], [4, 5, 6]])
def test_is_a_triangle(side):
    """Ensure that given a valid set of equilateral/isosceles/scalene triangle sides, is_triangle will return True."""
    assert Geometry.is_triangle(side[0], side[1], side[2])

When the test is run, you can see that 3 tests were run (represented by the 3 green dots) even though only 1 test was written!

Conclusion:

Unit testing is a critical part of software development. In Python, Pytest is the best unit testing framework. Pytest is equipped with all the tools you need for any unit testing concept you'd like to exercise [fixtures, parameterization, mocking, etc.]. If you wish to learn more about Pytest and its capabilities, below are some links to other great resources!

Additional Resources:

Great Article That Goes More In-Depth - Real Python Pytest

Official Documentation - Pytest Official Documentation

Mitchell Daddario's - Python Blog