Allure Reporting: Rich Test Reports for API Test Results

# Install Allure CLI
# macOS:
brew install allure

# Linux:
# Download from https://github.com/allure-framework/allure2/releases
# Add allure/bin to PATH

# Python package (for pytest integration)
pip install allure-pytest

# Node.js package (for Mocha/Jest)
npm install --save-dev allure-mocha

# Java package (for REST Assured/JUnit)
# Gradle: testCompile 'io.qameta.allure:allure-junit5:2.27.0'
# Maven: add allure-junit5 dependency

import pytest
import allure

@allure.epic("User Management")
@allure.feature("User CRUD")
@allure.story("Create User")
@allure.severity(allure.severity_level.CRITICAL)
@allure.tag("smoke", "regression")
@allure.parent_suite("API Tests")
@allure.suite("Users Module")
def test_create_user(api_client):
    """Create a new user with valid data."""

    with allure.step("Prepare test data"):
        user_data = {
            "email": "allure-test@example.com",
            "name": "Allure Test User",
            "password": "SecurePass123!"
        }

    with allure.step("Send POST request to /users"):
        response = api_client.post("/users", json=user_data)

    with allure.step("Verify response status is 201"):
        assert response.status_code == 201

    with allure.step("Verify user was created correctly"):
        data = response.json()
        assert data["email"] == user_data["email"]
        assert "id" in data

    allure.attach(
        response.text,
        name="Response Body",
        attachment_type=allure.attachment_type.JSON
    )


@allure.feature("User CRUD")
@allure.story("Get User")
@allure.severity(allure.severity_level.NORMAL)
@pytest.mark.parametrize("user_id, expected_status", [
    (1, 200),
    (99999, 404),
    (-1, 400),
])
def test_get_user_various(api_client, user_id, expected_status):
    response = api_client.get(f"/users/{user_id}")

    with allure.step(f"Verify status is {expected_status}"):
        assert response.status_code == expected_status

    allure.attach(
        f"Request: GET /users/{user_id}",
        name="Request Info",
        attachment_type=allure.attachment_type.TEXT
    )

import io.qameta.allure.*;
import org.junit.jupiter.api.Test;

@Epic("Payment Processing")
@Feature("Stripe Payment")
public class PaymentApiTest {

    @Test
    @Story("Successful Payment")
    @Severity(SeverityLevel.BLOCKER)
    @Description("Process a valid payment through Stripe integration")
    @Link(name = "Stripe Docs", url = "https://stripe.com/docs/api")
    @Owner("Payment Team")
    public void testCreatePayment() {
        // REST Assured test with Allure integration
        given()
            .contentType(ContentType.JSON)
            .body("{\"amount\": 2999, \"currency\": \"usd\"}")
        .when()
            .post("/api/payments")
        .then()
            .statusCode(200);
    }
}

import allure
import json

class AllureApiClient:
    """API client that attaches all HTTP data to Allure reports."""

    def _attach_request(self, method, url, kwargs):
        request_info = f"{method} {url}\n"
        if "json" in kwargs:
            request_info += f"Body: {json.dumps(kwargs['json'], indent=2)}\n"
        if "headers" in kwargs:
            request_info += f"Headers: {json.dumps(dict(kwargs['headers']), indent=2)}\n"
        allure.attach(
            request_info,
            name=f"Request: {method} {url}",
            attachment_type=allure.attachment_type.TEXT
        )

    def _attach_response(self, response):
        response_info = (
            f"Status: {response.status_code}\n"
            f"Time: {response.elapsed.total_seconds()*1000:.0f}ms\n"
            f"Headers: {json.dumps(dict(response.headers), indent=2)}\n"
        )
        allure.attach(
            response_info,
            name=f"Response: {response.status_code}",
            attachment_type=allure.attachment_type.TEXT
        )

        try:
            allure.attach(
                response.text,
                name="Response Body",
                attachment_type=allure.attachment_type.JSON
            )
        except Exception:
            allure.attach(
                response.text,
                name="Response Body",
                attachment_type=allure.attachment_type.TEXT
            )

    def request(self, method, url, **kwargs):
        self._attach_request(method, url, kwargs)
        response = super().request(method, url, **kwargs)
        self._attach_response(response)
        return response

# Run tests with Allure output
pytest tests/ \
  --alluredir=allure-results \
  --clean-alluredir \
  -v

# Generate HTML report
allure generate allure-results -o allure-report --clean

# Open report in browser
allure open allure-report

# Expected output:
# Report successfully generated to allure-report
# Starting web server at http://localhost:5678

# CI integration - serve reports
allure generate allure-results -o allure-report
# Deploy allure-report directory to static hosting (S3, Netlify, GitHub Pages)

# Or use Allure Server (Docker):
# docker run -p 5050:5050 \
#   -v $(pwd)/allure-results:/app/allure-results \
#   frankescobar/allure-docker-service

# environment.properties - add to allure-results directory
# Creates environment info banner in report
"""
Environment.Staging
Browser.Chrome
API.Version.v2
Database.PostgreSQL 16
Deployment.Kubernetes
"""

# categories.json - create custom failure categories
# Place in allure-results directory
"""
[
  {
    "name": "Ignored tests",
    "messageRegex": ".*ignored.*",
    "matchedStatuses": ["skipped"]
  },
  {
    "name": "Infrastructure problems",
    "messageRegex": ".*ConnectionError.*",
    "matchedStatuses": ["broken"]
  },
  {
    "name": "Assertion failures",
    "messageRegex": ".*AssertionError.*",
    "matchedStatuses": ["failed"]
  },
  {
    "name": "Test defects",
    "messageRegex": ".*",
    "matchedStatuses": ["broken"]
  }
]
"""

# Keep history between runs
# Copy allure-report/history to allure-results/history before generation
# import shutil
# shutil.copytree("allure-report/history", "allure-results/history", dirs_exist_ok=True)