Testing Your Python Code with pytest

Introduction
Prerequisites
Installing pytest
Writing Test Functions
Running Tests
Assertions
Test Discovery
Test Fixtures
Running Specific Tests
Mocking
Skipping Tests
Code Coverage
Conclusion

Introduction

In software development, testing plays a crucial role in ensuring the correctness and reliability of your code. Testing allows you to verify that your functions and classes work as expected, catch bugs early, and provide confidence when making changes or adding new features.

pytest is a popular testing framework in Python that offers a simple and intuitive way to write and execute tests. In this tutorial, you will learn how to use pytest to test your Python code effectively.

By the end of this tutorial, you will be able to:

Install and set up pytest for your Python projects
Write test functions using pytest syntax
Run tests and interpret the results
Use assertions to validate expected behavior
Discover and organize tests automatically
Create fixtures to set up and tear down test environments
Skip tests for certain conditions
Measure code coverage of your tests

Let’s get started!

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Python programming concepts and have Python installed on your machine. It is also helpful to have some experience with writing functions and classes in Python.

Installing pytest

Before you can start using pytest, you need to install it in your Python environment. Open your terminal or command prompt and run the following command: bash pip install pytest This will install pytest and its dependencies. Once the installation is complete, you can verify that pytest is installed by running pytest --version. You should see the version number printed in the console.

Writing Test Functions

In pytest, tests are written as functions with names starting with test_ or ending with _test. These functions contain assertions that validate the behavior of your code.

Let’s say you have a function called add that adds two numbers together. To test this function, create a new Python file, such as test_math.py, and define a test function inside it: ```python # test_math.py

def test_add():
    assert add(2, 3) == 5
    assert add(0, 0) == 0
    assert add(-1, 1) == 0
``` In this example, we are testing the `add` function with different inputs and asserting that the result is as expected. If any of the assertions fail, `pytest` will report the failure and provide detailed information about what went wrong.

It’s important to note that pytest uses assertions to verify the expected behavior of your code. If the assertion is true, the test passes; otherwise, the test fails.

Running Tests

To run your tests with pytest, navigate to the directory where your test file is located using the terminal or command prompt. Then, run the following command: bash pytest pytest will automatically discover and execute all the test functions defined in files with names starting with test_ or ending with _test in the current directory and its subdirectories. The test results will be displayed in the console.

Assertions

Assertions are statements that check if a condition is true. In pytest, assertions are used to validate the expected behavior of your code.

Here are a few examples of assertions you can use in your test functions:

assert condition: Asserts that the given condition is true.
assert a == b: Asserts that a is equal to b.
assert a != b: Asserts that a is not equal to b.
assert a > b: Asserts that a is greater than b.
assert a < b: Asserts that a is less than b.
assert a in b: Asserts that a is a member of b.

You can combine multiple assertions in a single test function to test different scenarios or edge cases.

Test Discovery

By default, pytest automatically discovers and runs all the test functions in your project. It uses a set of predefined rules to search for test files and test functions.

To leverage this automatic test discovery, make sure your test files follow the naming convention: test_*.py or *_test.py. For example, test_math.py or math_test.py.

Additionally, test functions should follow the naming convention: test_* or *_test. Keeping the test_ prefix or _test suffix ensures that pytest recognizes them as test functions.

Test Fixtures

In testing, a fixture is a baseline or a set of preconditions that are needed for your tests. Fixtures can be used to set up resources, such as database connections or temporary files, before running your tests.

To create a fixture in pytest, you can use the @pytest.fixture decorator. This decorator marks a function as a fixture function, which can be referenced in your test functions.

Here’s an example of a fixture that creates a temporary file: ```python # test_file.py

import pytest
import tempfile

@pytest.fixture
def temp_file():
    file = tempfile.NamedTemporaryFile()
    yield file.name
    file.close()
``` In this example, the `temp_file` fixture uses the `tempfile.NamedTemporaryFile()` function to create a temporary file. The `yield` statement marks the point where the fixture ends. After the test function completes, the file is automatically closed.

To use the fixture in a test function, you simply include it as an input parameter: ```python # test_file.py

def test_file_size(temp_file):
    with open(temp_file, 'w') as file:
        file.write('Hello, world!')

    assert os.path.getsize(temp_file) == 13
``` In this example, the `test_file_size` function takes `temp_file` as a parameter. The fixture is automatically executed before the test function, providing the file name as the input parameter.

Running Specific Tests

Sometimes, you may only want to run specific tests instead of all the tests in your project. pytest provides several options to select and run specific tests.

To run a specific test file, you can specify the file path as an argument to pytest. For example: bash pytest test_math.py This will run all the tests defined in test_math.py.

To run a specific test function, you can use the -k option followed by the test function name: bash pytest -k test_add This will run only the test_add function and any other test functions that contain the substring test_add in their names.

Mocking

Sometimes, your tests may depend on external resources that are not available or difficult to set up for testing, such as a web API or a database. pytest provides a mock library that allows you to mock these external dependencies and simulate their behavior.

To use the mock library in pytest, you need to install it separately. Run the following command to install pytest-mock: bash pip install pytest-mock Once installed, you can use the @pytest.mark.mocker decorator to indicate that a test function requires mocking. In the test function, you can use the mocker fixture to access the mocking capabilities. Here’s an example: ```python # test_api.py

import pytest
import requests

def get_data():
    response = requests.get('https://api.example.com')
    return response.json()

@pytest.mark.mocker
def test_get_data(mocker):
    expected_data = {'message': 'Mocked Data'}
    
    mocker.patch('requests.get', return_value=expected_data)
    
    data = get_data()
    
    assert data == expected_data
``` In this example, the `test_get_data` function is marked with `@pytest.mark.mocker`, indicating that mocking will be used. The `mocker` fixture is passed as a parameter to the test function.

Inside the test function, the mocker.patch method is used to mock the requests.get function. It replaces the original implementation with the return_value specified. This way, when get_data calls the requests.get function, it receives the mocked data instead of making an actual HTTP request.

Skipping Tests

There may be situations where you want to temporarily skip certain tests, for example, when a feature is not yet implemented or when a test is known to be failing.

To skip a test in pytest, you can use the @pytest.mark.skip decorator. Here’s an example: ```python # test_skip.py

import pytest

@pytest.mark.skip
def test_functionality():
    # Test code here
    pass
``` In this example, the `test_functionality` test is marked with `@pytest.mark.skip`. When you run your tests, `pytest` will skip this test and mark it as a skipped test.

You can also skip tests conditionally by using @pytest.mark.skipif decorator with a condition. For example: ```python # test_skip.py

import pytest
import sys

@pytest.mark.skipif(sys.version_info < (3, 7), reason='Requires Python 3.7+')
def test_functionality():
    # Test code here
    pass
``` In this example, the test will be skipped if the condition `sys.version_info < (3, 7)` evaluates to true.

Code Coverage

Code coverage measures the percentage of your code that is covered by tests. It helps you identify untested or under-tested parts of your codebase.

To measure code coverage with pytest, you need to install the pytest-cov plugin. Run the following command to install it: bash pip install pytest-cov Once installed, you can run your tests with code coverage using the --cov option followed by the target directory or module: bash pytest --cov=my_module This will run your tests and generate a code coverage report for the specified module or directory. The report will show which lines of code are covered by tests and which are not.

Code coverage is a valuable metric to ensure the effectiveness of your tests and identify areas that need more testing.

Conclusion

In this tutorial, you have learned how to use pytest to test your Python code effectively. You have seen how to write test functions, run tests, use assertions, discover and organize tests automatically, create test fixtures, run specific tests, mock external dependencies, skip tests, and measure code coverage.

By writing thorough and reliable tests, you can improve the quality and maintainability of your codebase. With pytest as your testing framework, you have a powerful tool to help you achieve this.

Continue practicing with pytest and exploring its advanced features to become a proficient tester and deliver high-quality Python applications.

Remember, testing is an essential part of the software development process. Happy testing!

Published: 18 January 2021