Writing Test Cases in Python Using Pytest

by

Writing Test Cases in Python Using Pytest. Testing is an essential part of software development to ensure code quality and prevent bugs. Python developers commonly use the Pytest framework for its simplicity, scalability, and robust feature set. This guide walks you through writing test cases using Pytest, covering various scenarios with example code and explanations.

Writing Test Cases in Python Using Pytest

What is Pytest?

Pytest is a powerful testing framework in Python. It allows you to write simple unit tests as well as complex functional test suites. Its features include:

  • Support for fixtures.
  • Parameterized testing.
  • Detailed assertion introspection.
  • Plugin extensibility.

To install Pytest, use:

pip install pytest

Writing Your First Python Test Case

A basic Pytest test case is a function whose name starts with test_. Pytest will automatically discover and execute these functions.

Example:

# test_sample.py

def test_addition():
    assert 1 + 1 == 2

Explanation:

  1. The function test_addition is a test case.
  2. assert checks if the expression evaluates to True. If it doesn’t, the test fails.

To run the test:

pytest test_sample.py

Pytest will provide a detailed output of passed and failed tests.

Organizing Test Files in Python

Pytest automatically discovers test files and test functions. Follow these conventions:

  • Test files should start with test_ or end with _test.py.
  • Test functions should start with test_.

Python Directory Structure Example:

project/
  src/
    math_operations.py
    string_operations.py
 tests/
    test_math.py
    test_string.py

Using Assertions in Pytest

Assertions form the backbone of testing. Pytest enhances Python’s built-in assert to provide better error messages.

Example:

# test_math.py

def test_subtraction():
    result = 5 - 3
    assert result == 2, "Subtraction failed"

If the assertion fails, Pytest displays the expected vs. actual values.

Using Fixtures in Python

Fixtures are reusable components that help set up and tear down test environments. Use the @pytest.fixture decorator to create a fixture.

Example:

# test_fixture.py
import pytest

@pytest.fixture
def sample_data():
    return {"name": "John", "age": 30}

def test_data_content(sample_data):
    assert sample_data["name"] == "John"
    assert sample_data["age"] == 30

Explanation:

  1. sample_data is a fixture that provides test data.
  2. The test function test_data_content uses the fixture by including it as a parameter.

Parameterized Testing using Pytest Python

Parameterized tests allow you to run a test function with different input values and expected outcomes. Use the @pytest.mark.parametrize decorator.

Example:

# test_parametrize.py
import pytest

@pytest.mark.parametrize("input,expected", [(1, 2), (2, 3), (3, 4)])
def test_increment(input, expected):
    assert input + 1 == expected

Explanation:

  1. The test test_increment runs three times with different (input, expected) pairs.
  2. Pytest provides a detailed report for each parameter set.

Handling Exceptions

Use the pytest.raises context manager to test if specific exceptions are raised.

Example:

# test_exceptions.py
import pytest

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

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

Explanation:

  1. pytest.raises verifies that the ValueError is raised.
  2. The match parameter ensures the error message matches the expected text.

Mocking in Pytest

Use the unittest.mock library to mock dependencies in your tests. Pytest also integrates with pytest-mock for enhanced mocking support.

Example:

# test_mocking.py
from unittest.mock import MagicMock

def fetch_data(api):
    return api.get("/data")

def test_fetch_data():
    mock_api = MagicMock()
    mock_api.get.return_value = {"key": "value"}

    result = fetch_data(mock_api)
    assert result == {"key": "value"}

Explanation:

  1. MagicMock creates a mock object.
  2. The test verifies that fetch_data works with the mocked API.

Running Tests in Parallel

To speed up test execution, use the pytest-xdist plugin to run tests in parallel:

pip install pytest-xdist
pytest -n 4

This command runs tests across 4 CPU cores.

Generating Test Reports in Python

Use the pytest-html plugin to generate HTML reports:

pip install pytest-html
pytest --html=report.html

This generates a detailed HTML report of the test results.

Conclusion

Pytest is a versatile framework suitable for various testing needs. You can write efficient and maintainable test suites by leveraging its features like fixtures, parameterization, and plugins.

Summary:

  • Start with simple assertions.
  • Use fixtures for reusable test setups.
  • Parameterize tests for multiple inputs.
  • Test exceptions and integrate mocking where needed.

With Pytest, testing becomes more approachable and reliable, ensuring your code is production-ready. Happy testing!

See Also

Leave a Comment