How to generate Allure Reports in Selenium and TestNG?

Test reports are essential for teams to track the health and quality of their software. They show which parts of an application work well and which parts need fixing. Selenium and TestNG are popular tools for automating tests, but without transparent reporting, test results can be hard to interpret.

This is where Allure Reporting helps. Allure is an open-source framework that collects test data from Selenium and TestNG and turns it into interactive, easy-to-understand reports. These reports show the status of each test, provide detailed logs, and help teams identify and resolve issues faster.

This article explains what Allure reporting is, its key components, and how to set it up in Selenium and TestNG projects.

What is Allure Reporting?

Allure Reporting is an open-source reporting tool that integrates with Selenium and TestNG. It collects raw test results and generates reports that present information clearly and interactively.

The reports indicate which tests passed, failed, or were skipped. They include detailed information such as step-by-step execution logs, screenshots, and error messages. This level of detail makes debugging easier.

Advantages of Using Allure Reports with Selenium and TestNG

Allure Reporting improves test automation results by providing:

• Clear Visual Reports: Test outcomes are displayed with colors and charts. This allows quick identification of failures and test coverage.
• Step-by-Step Execution Logs: Test steps can be logged with annotations, helping to understand test flow and pinpoint where failures occur.

• Attachments Support: Screenshots, videos, and logs can be attached to tests for detailed failure analysis.
• Historical Dashboards: Track test performance trends over time to detect recurring issues or improvements.
• CI/CD Integration: Automatically generate and publish reports in your build pipeline without manual intervention.

Setting Up Allure with Selenium and TestNG

Before integrating Allure, ensure the following prerequisites are met:

• Java and Maven are installed and configured on your development machine.
• A working Selenium and TestNG test project exists.
• Your project uses Maven or Gradle as a build tool (the Maven example is shown here).

To add Allure support:

1. Add Allure TestNG Dependency

Add the following to your pom.xml to enable Allure’s TestNG adapter:

<dependency>

  <groupId>io.qameta.allure</groupId>

  <artifactId>allure-testng</artifactId>

  <version>2.13.9</version>

</dependency>

This allows Allure to intercept test events and gather results.

2. Add Allure Maven Plugin

Configure Maven to generate reports after tests finish by adding this plugin:

<build>

  <plugins>

    <plugin>

      <groupId>io.qameta.allure</groupId>

      <artifactId>allure-maven</artifactId>

      <version>2.10.0</version>

      <executions>

        <execution>

          <id>allure-report</id>

          <phase>verify</phase>

          <goals>

            <goal>report</goal>

          </goals>

        </execution>

      </executions>

    </plugin>

  </plugins>

</build>

3. Annotate Tests for Reporting

Use Allure annotations to add descriptions and steps in your TestNG tests and attach files.

Creating Allure-Enabled Test Cases

Enhance your test cases to produce detailed reports by using annotations such as:

• @Description: To add a summary of what the test verifies.
• Allure.step(): To break down the test flow into individual steps.
• Attachment methods: To include screenshots or logs when tests fail.

Example:

import io.qameta.allure.*;

import org.testng.annotations.Test;

import org.testng.Assert;



public class SampleTest {



    @Test

    @Description("Verify the homepage title")

    public void testHomePageTitle() {

        Allure.step("Navigate to homepage");

        driver.get("https://example.com");



        Allure.step("Validate page title");

        String title = driver.getTitle();

        Assert.assertEquals(title, "Example Domain");

    }

}

This example makes the report easy to follow and debug.

Running Tests and Generating Allure Reports

Once tests are annotated and dependencies added, run your tests normally. Test results are stored in the allure-results folder.

To generate the interactive report, you need the Allure command-line tool. Install it using:

• Homebrew on macOS:

brew install allure

• Generate the report:

allure generate allure-results --clean -o allure-report

• Open the report in your browser:

allure open allure-report

The report shows an interactive dashboard with all tests, their statuses, and detailed logs.

Understanding Allure Report Components

Allure reports organize your test results into specific sections that help you quickly identify issues and understand test behavior. Together, these components provide a layered view of your test health, from overview to granular details, making debugging more efficient.

• Overview Dashboard: Summarizes test run status with clear pass/fail counts and percentages. It highlights unstable or flaky tests by tracking retries and failures across runs. This helps you spot unreliable tests that need attention.
• Test Suites and Test Cases: Displays tests grouped by class and method, allowing you to drill down from a broad view into individual test executions. This structure lets you navigate large test sets without losing context.
• Steps and Attachments: Shows detailed steps executed during each test along with attached screenshots, logs, or videos. These artifacts let you pinpoint exactly where and why a failure happened without guessing.
• Graphs and Trends: Provides charts to track test results over time. You can observe improvements or regressions, helping identify patterns like frequent flaky failures or unstable features.
• Behaviors Section: When annotated accordingly, this section groups tests by user stories, features, or modules. This behavior-driven grouping improves report readability and maps tests to business requirements.
• Categories: Enables classification of failures by type, such as assertion errors or setup issues. This classification helps prioritize bug fixes based on failure causes rather than individual test results.
• Retries: Lists tests that were automatically retried after failure and shows their final status. It reveals whether flaky tests are masking intermittent issues or whether retries successfully stabilize test runs.

Limitations of Allure Reports for Selenium and TestNG Users

While Allure is powerful, it has constraints that can affect complex test automation projects:

• No automatic flaky test detection: Allure shows retries but does not flag flaky tests explicitly. Developers must manually analyze retry patterns to identify instability.

• Limited failure categorization: Error grouping and prioritization require manual categorization or external tools. This slows down triage for large test suites.
• No built-in support for test reruns from reports: Developers cannot directly trigger failed test reruns via Allure UI, slowing down debugging cycles.
• Fragmented log consolidation: Logs and environment data come from separate sources. Allure does not consolidate these for unified failure analysis.
• No built-in test health metrics or quality gates: Teams must build custom dashboards or CI steps to enforce minimum quality standards based on test results.
• Reports require manual setup and maintenance: Configuring Allure with Selenium and TestNG, especially in CI environments, requires ongoing effort and troubleshooting.

Why is BrowserStack the Best Alternative to Allure Test Reporting?

While Allure provides a solid foundation for visualizing test executions and attaching artifacts, it often requires significant manual effort to effectively identify flaky tests, group failures, and correlate logs across multiple test environments.

BrowserStack fills these gaps by offering an end-to-end test reporting, failure RCA, and analytics solution. It combines automated stability analysis, intelligent failure grouping, and seamless rerun capabilities directly within its dashboard.

Here are some ways BrowserStack Test Reporting and Analytics improve test reporting:

• Real Device Cloud: Tests run on actual mobile and desktop devices hosted by BrowserStack. Combined with advanced reporting, this exposes platform-specific issues that Allure alone might miss.
• Automatic flaky test detection: BrowserStack tracks test stability trends and automatically flags flaky tests. Alerts notify developers immediately, reducing wasted debugging time.
• AI-powered error categorization: Failures are grouped by root cause using machine learning. This prioritizes bugs that impact the most users or block release pipelines.
• Built-in test rerun capabilities: Developers can rerun failed tests directly from the BrowserStack dashboard on real devices or browsers, speeding up verification without leaving the tool.
• Detailed test analytics: Get insights into quality metrics like failure rate, performance, and top unique errors.
• Timeline debugging with event sequencing: The dashboard shows step-by-step test execution timelines across browsers and devices, allowing teams to track exactly when failures happen.
• Quality gates: Teams configure widgets and build quality gates to monitor test health continuously. Failed gates can block merges, improving release confidence.

Talk to an Expert

Best Practices for Using Allure Reports with Selenium and TestNG

To leverage Allure’s full potential in your Selenium-TestNG workflow, follow these developer-centric practices:

• Annotate tests thoroughly: Use @Description, @Step, and @Attachment annotations to add contextual information. Clear step names and detailed descriptions help when reviewing reports or sharing with teammates.
• Attach screenshots and logs selectively: Capture screenshots at failure points and attach logs only when relevant to avoid report bloat. This balances information richness with report size and load time.
• Structure tests with clear logical steps: Break complex tests into atomic steps using Allure.step(). This clarifies test flows and simplifies root cause analysis for failures.
• Integrate with CI/CD pipelines: Automate Allure report generation after each test run in your build system. This ensures up-to-date reporting and faster feedback on code changes.

• Monitor flaky tests actively: Track retries and failures in reports and investigate unstable tests promptly. Flaky tests reduce confidence and waste developer time.
• Group tests by features or modules: Use labels or annotations to organize tests by functionality. This makes it easier to track test coverage and focus on problem areas.
• Keep reports clean and performant: Limit excessive attachments and verbose logging. Extensive reports slow down loading and reduce usability.

Conclusion

Allure Reports provide a clear and interactive way to visualize test results from Selenium and TestNG. They offer detailed test steps, attachments like screenshots and logs, and useful dashboards that help teams understand their test outcomes better. This makes Allure a strong choice for many test automation projects.

However, Allure lacks features like flaky test detection, error analysis, and deep real device testing integration. For teams that need faster insights, BrowserStack fills these gaps by providing advanced test analytics, enhanced debugging features, and seamless cloud-based testing infrastructure, helping teams deliver higher-quality software more efficiently.

Try BrowserStack for Free