Allure-RS

A comprehensive Rust library for generating Allure test reports with full feature parity to allure-js-commons.

Features

• Test metadata annotations - epic, feature, story, severity, owner, tags
• Test steps - nested step support with timing
• Attachments - text, JSON, binary files
• BDD-style steps - given, when, then, and, but
• Links - issue tracker and test management system links
• Flaky/muted test support
• Environment and categories configuration
• Skip & ignore support - capture skipped tests with reasons
• Parameter privacy controls - hidden/masked/excluded parameters
• Image diff attachments - application/vnd.allure.image.diff helper
• Async test support (tokio-first)
• Framework agnostic - works with #[test], tokio::test, rstest

Installation

Add to your Cargo.toml:

[dev-dependencies]
allure-rs = "0.1"

Requirements

• Rust 1.75 or higher (MSRV)
• Allure CLI (for viewing reports) - Installation Guide

Quick Start

use allure_rs::prelude::*;

// Note: Metadata attributes must come BEFORE #[allure_test]
#[allure_epic("User Management")]
#[allure_feature("Authentication")]
#[allure_severity("critical")]
#[allure_test]
fn test_login() {
    step("Initialize user", || {
        // setup code
    });

    step("Perform login", || {
        // test code
        assert!(true);
    });

    attachment::text("Debug info", "Login successful");
}

BDD Style

use allure_rs::prelude::*;

#[allure_test]
fn test_user_registration() {
    let user = bdd::given("a new user with valid email", || {
        User::new("test@example.com")
    });

    bdd::when("the user submits registration form", || {
        user.register();
    });

    bdd::then("the user account should be created", || {
        assert!(user.is_registered());
    });
}

Configuration

use allure_rs::configure;

// Initialize before running tests
configure()
    .results_dir("allure-results")
    .clean_results(true)
    .init()
    .unwrap();

Environment Info

use allure_rs::environment;

environment()
    .set("rust_version", env!("CARGO_PKG_RUST_VERSION"))
    .set("os", std::env::consts::OS)
    .set_from_env("CI", "CI")
    .write()
    .unwrap();

Supported Annotations

Important: Metadata annotations must be placed BEFORE #[allure_test] due to Rust's proc macro processing order.

Test Organization Hierarchies

Allure provides two hierarchies for organizing tests in reports:

Behavior-Based Hierarchy (Epic → Feature → Story)

This hierarchy aligns with agile/BDD methodologies:

use allure_rs::prelude::*;

#[allure_epic("E-commerce Platform")]
#[allure_feature("Shopping Cart")]
#[allure_story("User can add items to cart")]
#[allure_test]
fn test_add_item_to_cart() {
    // ...
}

In the Allure report, this test appears under: Behaviors → E-commerce Platform → Shopping Cart → User can add items to cart

Suite-Based Hierarchy (Parent Suite → Suite → Sub-Suite)

Alternative organizational structure based on test suites:

use allure_rs::prelude::*;

#[allure_parent_suite("API Tests")]
#[allure_suite_label("User Endpoints")]
#[allure_sub_suite("Authentication")]
#[allure_test]
fn test_user_login() {
    // ...
}

Multiple Values

Use plural macros to assign tests to multiple categories:

use allure_rs::prelude::*;

#[allure_epics("Platform A", "Platform B")]
#[allure_features("Login", "Security")]
#[allure_stories("Valid credentials", "SSO login")]
#[allure_test]
fn test_cross_platform_sso() {
    // ...
}

Viewing Reports

After running tests, generate the HTML report using the Allure CLI:

# Run tests
cargo test

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

# Open report in browser
allure open allure-report

Runtime API

In addition to macros, you can use the runtime API for dynamic metadata:

use allure_rs::prelude::*;

#[allure_test]
fn test_with_runtime_api() {
    // Set metadata dynamically
    epic("User Management");
    feature("Authentication");
    severity(Severity::Critical);
    owner("team@example.com");

    // Add parameters
    parameter("browser", "Chrome");
    parameter("version", "120.0");
    parameter_hidden("user_id", "123"); // hidden from report
    parameter_masked("password", "secret"); // masked in report
    parameter_excluded("timestamp", "1700000000"); // excluded from historyId

    // Create steps
    step("Login step", || {
        // test code
    });

    // Add attachments
    attachment::text("Response", r#"{"status": "ok"}"#);
    // Visual diff payloads
    attachment::image_diff("Diff", br#"{ "expected": "...", "actual": "...", "diff": "..." }"#);
}

Async Tests

Works with tokio::test and other async test frameworks:

use allure_rs::prelude::*;

#[allure_epic("API")]
#[allure_test]
#[tokio::test]
async fn test_async_api() {
    step("Make request", || {
        // test code
    });
}

// Context flows into spawned tokio tasks when the `tokio` feature is enabled
#[tokio::test]
#[allure_test]
async fn test_async_spawned_steps() {
    let handle = tokio::spawn(async move {
        // Steps and attachments here are recorded under the parent test
        step("Inside spawned task", || {});
    });
    handle.await.unwrap();
}

Enable the async feature for async step support:

[dev-dependencies]
allure-rs = { version = "0.1", features = ["async"] }

Feature Flags

Crate Structure

• allure-rs - Main facade crate (re-exports everything)
• allure-core - Core types, model, and runtime
• allure-macros - Procedural macros

License

MIT