Learn how to use Pytest for testing Python code

Testing is a crucial part of any software development process. It helps ensure that your code works as expected and catches bugs early. If you’re a Python developer, you’re in luck because Python offers an easy-to-use testing framework called pytest. In this article, we will learn how to use pytest to test Python code and walk through some programming examples.

Learn Also: Python Scheduler: Automate Your Tasks

What is Pytest?

It is a testing framework for Python that makes it easy to write simple and scalable test cases. Whether you’re testing small functions or complex applications, pytest simplifies the whole process. One of the best things about this framework is that you don’t need to write a lot of code to get started with testing.

Pytest Benefits

• Easy to write: It lets you write test cases with minimal code.
• Auto-discovery: It automatically discovers test files and functions based on naming conventions, so you don’t have to specify which tests to run.
• Detailed reports: When a test fails, pytest provides detailed reports that make debugging easier.
• Supports fixtures: You can reuse setup code (like database connections) across multiple tests using fixtures.
• Extensible: You can enhance pytest with plugins like pytest-cov for test coverage and pytest-mock for mocking.

Installation

Use the following command to install pytest on your machine.

pip install pytest

Here is the documentation.

Writing Your First Pytest Test

Let’s start with a simple example. Suppose you have a function that calculates the factorial of a number.

Example 1: Testing a Function with Pytest

# factorial.py
def factorial(n):
    if n == 0 or n == 1:
        return 1
    elif n > 1:
        return n * factorial(n - 1)
    else:
        raise ValueError("Factorial is not defined for negative numbers")

Now, let’s write a test for this function:

# test_factorial.py
import pytest
from factorial import factorial

def test_factorial():
    assert factorial(5) == 120
    assert factorial(0) == 1
    assert factorial(1) == 1

def test_factorial_negative():
    with pytest.raises(ValueError):
        factorial(-3)

In this test, we check if the factorial function returns the correct result for valid inputs like 5, 0, and 1. We also check that it raises a ‘ValueError‘ for negative numbers.

To run the test, simply run ‘pytest‘ in the terminal:

pytest

It will find the test file and run the tests automatically.

Example 2: Testing a Class and Its Methods

Let’s say you have a Calculator class with some basic methods like add, subtract, and divide.

# calculator.py
class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b
    
    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

Here’s how you can test the methods of this class:

# test_calculator.py
import pytest
from calculator import Calculator

def test_add():
    calc = Calculator()
    assert calc.add(4, 3) == 7
    assert calc.add(-1, 1) == 0

def test_subtract():
    calc = Calculator()
    assert calc.subtract(5, 3) == 2

def test_divide():
    calc = Calculator()
    assert calc.divide(10, 2) == 5
    with pytest.raises(ValueError):
        calc.divide(10, 0)

In this test, we check the behavior of the add, subtract, and divide methods. We also ensure that dividing by zero raises a ‘ValueError‘.

Example 3: Using Pytest Fixtures

Fixtures are a way to manage the setup and teardown of resources, such as database connections or files. Here’s a simple example using a fixture to simulate a database connection:

# db.py
class Database:
    def connect(self):
        return "Connected to the database"
    
    def disconnect(self):
        return "Disconnected from the database"

We can create a pytest fixture that sets up and tears down the database connection:

# test_db.py
import pytest
from db import Database

@pytest.fixture
def db():
    db = Database()
    db.connect()
    yield db  # Provide the fixture to the test
    db.disconnect()  # Teardown after test

def test_db_connection(db):
    assert db.connect() == "Connected to the database"
    assert db.disconnect() == "Disconnected from the database"

In this test, the ‘db‘ fixture sets up the connection before each test and tears it down afterward.

Example 4: Parameterized Tests

Sometimes, you need to test a function with multiple sets of inputs. pytest makes this easy with parameterized tests.

# math_utils.py
def multiply(a, b):
    return a * b

Here’s how you can write a parameterized test for the multiply function:

# test_math_utils.py
import pytest
from math_utils import multiply

@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 6),
    (1, 5, 5),
    (0, 10, 0),
    (-1, 5, -5),
])
def test_multiply(a, b, expected):
    assert multiply(a, b) == expected

This test will run four times, once for each combination of a, b, and expected values.

Example 5: Testing API Requests (Using ‘pytest-mock’)

You may want to test functions that make external API requests. You can mock these requests using ‘pytest-mock‘.

# api_request.py
import requests

def get_status_code(url):
    response = requests.get(url)
    return response.status_code

Here’s how to mock the ‘requests.get‘ method and test the function:

# test_api_request.py
import pytest
import requests
from api_request import get_status_code

def test_get_status_code(mocker):
    # Mock the requests.get method
    mock_response = mocker.Mock()
    mock_response.status_code = 200
    mocker.patch('requests.get', return_value=mock_response)

    assert get_status_code('https://example.com') == 200

By using ‘mocker.patch‘, you can simulate the API response without actually making a request.

Example 6: Testing File I/O

If your code involves reading from or writing to files, pytest can help you test those scenarios. In this example, we’ll write a function to write and read content from a file.

# file_io.py
def write_to_file(filename, content):
    with open(filename, 'w') as f:
        f.write(content)

def read_from_file(filename):
    with open(filename, 'r') as f:
        return f.read()

Here’s how to test these functions using pytest’s ‘tmp_path‘ fixture for temporary files:

# test_file_io.py
import pytest
from file_io import write_to_file, read_from_file

def test_write_read_file(tmp_path):
    test_file = tmp_path / "test_file.txt"
    content = "Hello, Pytest!"

    write_to_file(test_file, content)
    assert read_from_file(test_file) == content

Example 7: Testing Asynchronous Functions

pytest can also test asynchronous code using the ‘pytest-asyncio‘ plugin.

# async_example.py
import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data received"

You can test this asynchronous function as follows:

# test_async_example.py
import pytest
from async_example import fetch_data

@pytest.mark.asyncio
async def test_fetch_data():
    result = await fetch_data()
    assert result == "data received"

Conclusion

Pytest isn’t just a tool; it’s a game-changer for Python developers. Whether you’re just starting out or building complex applications, it offers a straightforward yet powerful way to ensure your code works as intended.

From simple unit tests to intricate API simulations, Pytest has you covered. Its flexibility and ease of use make it a must-have for anyone serious about writing quality Python code. By catching bugs early and ensuring your code behaves as expected, this Python framework helps you build more reliable and robust software.