Using Pytest Assertions and Allure Reports for API Automation Testing

In the field of API automation testing, Pytest serves as a powerful testing framework, and when combined with the Allure reporting tool it enables efficient assertion handling and comprehensive test report generation.

1. Pytest Assertion Handling

Basic Assertions

Pytest provides a concise assertion syntax that uses Python's built‑in assert statement. For example:

def test_example():
    a = 5
    b = 3
    assert a + b == 8

When the assertion fails, Pytest automatically captures and reports the error.

Custom Assertion Messages

To make failure information clearer, Pytest allows adding a custom error message:

def test_example():
    a = 5
    b = 3
    assert a + b == 10, "Assertion failed, actual result is 8"

The custom message appears in the report, helping developers locate issues quickly.

Using Assertion Libraries

For more complex logic, third‑party assertion libraries such as pytest‑check can be used. After installing the library, multiple assertions can be performed without stopping the test on the first failure:

from pytest_check import check

def test_example():
    a = 5
    b = 3
    with check:
        assert a + b == 8
    with check:
        assert a - b == 2

2. Allure Report Generation

Installation

Install the Allure command‑line tool via pip:

pip install allure-pytest

After installation, the allure command can be used to generate and view reports.

Generating Test Reports

Run Pytest with the --alluredir option to store results:

pytest --alluredir=./results

Then generate the HTML report:

allure generate ./results -o ./report --clean

The report can be opened in a browser by loading index.html from the output directory.

Report Features

Allure provides detailed test case information, statistical analysis, and step visualization. Test steps can be defined with the @allure.step decorator:

import allure

@allure.step("Execute addition")
def add(a, b):
    return a + b

def test_example():
    result = add(5, 3)
    assert result == 8

Attachments such as logs or screenshots can be added using allure.attach :

import allure

def test_example():
    with open("example.log", "r") as f:
        log_content = f.read()
    allure.attach(log_content, name="Log File", attachment_type=allure.attachment_type.TEXT)

3. Combining Pytest and Allure for an API Automation Framework

Project Structure

project/
├── api/                 # API request code
│   ├── __init__.py
│   └── requests.py
├── conf/                # Configuration files
│   ├── __init__.py
│   └── config.yaml
├── report/              # Test reports
├── testcase/            # Test cases
│   ├── __init__.py
│   └── test_example.py
├── utils/               # Utility classes
│   ├── __init__.py
│   └── common.py
├── conftest.py          # Pytest configuration
├── pytest.ini           # Pytest configuration file
└── requirements.txt    # Project dependencies

This layout clearly separates different parts of the project, facilitating management and maintenance.

Writing Test Cases

A typical test case uses Pytest fixtures to initialize request and configuration objects, and Allure decorators to describe features and stories:

import pytest
import allure
from api.requests import ApiRequests
from conf.config import Config

@pytest.fixture(scope="session")
def api():
    return ApiRequests()

@pytest.fixture(scope="session")
def config():
    return Config()

@allure.feature("User Module")
@allure.story("User Login")
def test_user_login(api, config):
    url = config.get_base_url() + "/user/login"
    data = {"username": "testuser", "password": "testpass"}
    response = api.post(url, data)
    assert response.status_code == 200
    assert response.json()["message"] == "登录成功"

The fixtures provide reusable objects, while Allure annotations enrich the report with contextual information.

Running Tests and Generating the Report

Execute the tests with Allure output:

pytest --alluredir=./results

Then create the HTML report:

allure generate ./results -o ./report --clean

Open the generated index.html in a browser to view the detailed report.

4. Conclusion

By combining Pytest's straightforward assertion capabilities with Allure's rich reporting features, developers can build an efficient and transparent API automation testing framework. Pytest handles simple to complex assertions, while Allure offers extensive visualization and analysis, together significantly improving testing efficiency and quality.