Skip to content
Allure report logoAllure Report
Main Navigation MódulosDocumentaciónStart

Español

English

Español

English

Appearance

Sidebar Navigation

Introducción

Instalación y Actualización

Instalación para Windows

Instalación para macOS

Instalación para Linux

Instalación para Node.js

Actualización

Primeros pasos

Cómo ver un informe

Mejorar la legibilidad de informes

Mejorar la navegación en informe

Funcionalidades

Pasos de prueba

Adjuntos

Estados de prueba

Ordenar y filtrar

Categorías de defectos

Análisis visual

Análisis de estabilidad de prueba

Historial y reintentos

Cronología

Exportar a CSV

Exportar métricas

Guías

Parametrización JUnit 5

JUnit 5 & Selenide: capturas de pantalla y adjuntos

JUnit 5 & Selenium: capturas de pantalla y adjuntos

Configurar JUnit 5 con GitHub Actions

Parametrización en Pytest

Pytest & Selenium: capturas de pantalla y adjuntos

Pytest & Playwright: capturas de pantalla y adjuntos

Pytest & Playwright: videos

Parametrización en Playwright

Cómo funciona

Visión general

Archivo de resultados de prueba

Archivo de contenedor

Archivo de categorías

Archivo de entorno

Archivo de ejecutor

Archivos de historial

Integraciones

Azure DevOps

Bamboo

GitHub Actions

Jenkins

IDEs de JetBrains

TeamCity

Visual Studio Code

Frameworks

Behat

Empezando

Configuración

Referencia

Behave

Empezando

Configuración

Referencia

Codeception

Empezando

Configuración

Referencia

CodeceptJS

Empezando

Configuración

Referencia

Cucumber.js

Empezando

Configuración

Referencia

Cucumber-JVM

Empezando

Configuración

Referencia

Cucumber.rb

Empezando

Configuración

Referencia

Cypress

Empezando

Configuración

Referencia

Jasmine

Empezando

Configuración

Referencia

JBehave

Empezando

Configuración

Referencia

Jest

Empezando

Configuración

Referencia

JUnit 4

Empezando

Configuración

Referencia

JUnit 5

Empezando

Configuración

Referencia

Mocha

Empezando

Configuración

Referencia

Newman

Empezando

Configuración

Referencia

NUnit

Empezando

Configuración

Referencia

PHPUnit

Empezando

Configuración

Referencia

Playwright

Empezando

Configuración

Referencia

pytest

Empezando

Configuración

Referencia

Pytest-BDD

Empezando

Configuración

Referencia

Reqnroll

Empezando

Configuración

Referencia

REST Assured

Empezando

Configuración

Robot Framework

Empezando

Configuración

Referencia

RSpec

Empezando

Configuración

Referencia

SpecFlow

Empezando

Configuración

Referencia

Spock

Empezando

Configuración

Referencia

TestNG

Empezando

Configuración

Referencia

Vitest

Empezando

Configuración

Referencia

WebdriverIO

Empezando

Configuración

Referencia

xUnit.net

Empezando

Configuración

Referencia

On this page

Introducción a Allure con JUnit 4 ​

Última versión de Allure JUnit 4

Genera hermosos informes HTML utilizando Allure Report y tus pruebas con JUnit 4.

Ejemplo de Allure Report JUnit 4

INFO

Consulta los proyectos de ejemplo en github.com/allure-examples para ver Allure JUnit 4 en acción.

Configuración ​

Para integrar Allure en un proyecto existente de JUnit 4, necesitas:

  1. Agregar las dependencias de Allure a tu proyecto.
  2. Configurar AspectJ.
  3. Designar una ubicación para el almacenamiento de los resultados de Allure.

Agregar dependencias de Allure ​

xml
<!-- Define la versión de Allure que deseas utilizar mediante la propiedad allure.version -->
<properties>
    <allure.version>2.25.0</allure.version>
</properties>

<!-- Añade allure-bom a la gestión de dependencias para garantizar que se utilizan las versiones correctas de todas las dependencias -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.qameta.allure</groupId>
            <artifactId>allure-bom</artifactId>
            <version>${allure.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- Añade las dependencias necesarias de Allure a la sección de dependencias -->
<dependencies>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-junit4</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
kts
// Define la versión de Allure que deseas utilizar mediante la propiedad allureVersion
val allureVersion = "2.25.0"
// ...
dependencies {
    // Importa allure-bom para garantizar que se utilizan las versiones correctas de todas las dependencias
    testImplementation(platform("io.qameta.allure:allure-bom:$allureVersion"))
    // Añade las dependencias necesarias de Allure a la sección de dependencias
    testImplementation("io.qameta.allure:allure-junit4")
}
groovy
// Define la versión de Allure que deseas utilizar mediante la propiedad allureVersion
def allureVersion = "2.25.0"

dependencies {
    // Importa allure-bom para garantizar que se utilizan las versiones correctas de todas las dependencias
    testImplementation platform("io.qameta.allure:allure-bom:$allureVersion")
    // Añade las dependencias necesarias de Allure a la sección de dependencias
    testImplementation "io.qameta.allure:allure-junit4"
}

Configurar AspectJ ​

AspectJ es necesario para registrar Allure JUnit 4 como un listener de eventos que ocurren durante la ejecución de las pruebas. Además, Allure y algunos otros frameworks (como allure-assertj) utilizan AspectJ para diversas integraciones, incluyendo las anotaciones @Step y @Attachment.

xml
<!-- Define la versión de AspectJ -->
<properties>
    <aspectj.version>1.9.21</aspectj.version>
</properties>

<!-- Añade las siguientes opciones a tu maven-surefire-plugin -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.2.3</version>
    <configuration>
        <testFailureIgnore>false</testFailureIgnore>
        <argLine>
            -Dfile.encoding=${project.build.sourceEncoding}
            -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
        </argLine>
        <properties>
            <property>
                <name>listener</name>
                <value>io.qameta.allure.junit4.AllureJunit4</value>
            </property>
        </properties>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
        <dependency>
            <groupId>io.qameta.allure</groupId>
            <artifactId>allure-junit4-aspect</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</plugin>
kts
// Define la versión de AspectJ
val aspectJVersion = "1.9.21"

// Define la configuración del agente AspectJ
val agent: Configuration by configurations.creating {
    isCanBeConsumed = true
    isCanBeResolved = true
}

dependencies {
    // Añade la dependencia de aspectjweaver
    agent("org.aspectj:aspectjweaver:${aspectJVersion}")

    // Añade integración AspectJ para Allure
    testImplementation("io.qameta.allure:allure-junit4-aspect")
}

// Configura javaagent para la ejecución de pruebas
tasks.test {
    useJUnit()
    jvmArgs = listOf(
        "-javaagent:${agent.singleFile}"
    )
}
groovy
// Define la versión de AspectJ
def aspectJVersion = '1.9.21'

// Define la configuración del agente AspectJ
configurations {
    agent {
        canBeResolved = true
        canBeConsumed = true
    }
}

dependencies {
    // Añade la dependencia de aspectjweaver
    agent "org.aspectj:aspectjweaver:$aspectJVersion"

    // Añade integración AspectJ para Allure
    testImplementation "io.qameta.allure:allure-junit4-aspect"
}

// Configura javaagent para la ejecución de pruebas
test {
    useJUnit()
    jvmArgs = [ "-javaagent:${configurations.agent.singleFile}" ]
}

Especificar la ubicación de los resultados de Allure ​

De forma predeterminada, Allure guarda los resultados de las pruebas en el directorio raíz del proyecto.
Sin embargo, se recomienda almacenar los resultados en el directorio de salida del build.

Para configurar esto, crea un archivo allure.properties y colócalo en el directorio de recursos de prueba de tu proyecto, que normalmente se encuentra en src/test/resources:

properties
allure.results.directory=target/allure-results
properties
allure.results.directory=build/allure-results
properties
allure.results.directory=build/allure-results

Ejecutar pruebas ​

Ejecuta tus pruebas de JUnit 4 de la misma manera en que lo harías normalmente. Por ejemplo:

Para Gradle:

bash
./gradlew test
bash
gradlew test

Para Maven:

bash
./mvnw verify
bash
mvnw verify

Después de ejecutar las pruebas, Allure recopilará los datos de ejecución de las pruebas y los almacenará en el directorio allure-results.
Luego podrás generar un informe HTML a partir de estos resultados utilizando las herramientas de generación de informes de Allure.

Generar un informe ​

Finalmente, convierte los resultados de las pruebas en un informe HTML. Esto se puede hacer con uno de los siguientes comandos:

  • allure generate procesa los resultados de las pruebas y guarda un informe HTML en el directorio allure-report. Para ver el informe, utiliza el comando allure open.

    Usa este comando si necesitas guardar el informe para referencias futuras o para compartirlo con colegas.

  • allure serve crea el mismo informe que allure generate, pero lo coloca en un directorio temporal y arranca un servidor web local configurado para mostrar el contenido de ese directorio. El comando luego abre automáticamente la página principal del informe en un navegador web.

    Usa este comando si necesitas ver el informe tú mismo y no necesitas guardarlo.

Escribir pruebas ​

El adaptador Allure JUnit 4 no solo recopila los datos proporcionados por las características estándar de JUnit 4, sino que también ofrece funciones adicionales para escribir pruebas aún mejores. Esta sección enumera las formas más destacadas de mejorar tus pruebas, utilizando tanto las características de JUnit 4 como las de Allure JUnit 4.

Con Allure JUnit 4, puedes:

  • proporcionar descripción, enlaces y otros metadatos,
  • organizar pruebas en jerarquías,
  • dividir la prueba en pasos más pequeños y fáciles de leer pasos de prueba,
  • describir los parámetros utilizados al ejecutar pruebas parametrizadas,
  • hacer que la prueba guarde capturas de pantalla y otros archivos durante la ejecución,
  • seleccionar qué pruebas ejecutar mediante un archivo de plan de pruebas,
  • proporcionar información arbitraria del entorno para todo el informe de pruebas.

Especificar descripción, enlaces y otros metadatos ​

Puedes agregar muchos metadatos a cada prueba para que aparezcan en el informe. Consulta la referencia para más detalles.

Para cada campo de metadatos, hay dos formas de asignarlo: mediante una anotación antes de un método de prueba o mediante una llamada a un método dentro del cuerpo del método de prueba. La segunda forma se llama “dinámica”, porque permite construir cadenas de texto y otros valores en tiempo de ejecución antes de pasarlos a los métodos. Sin embargo, se recomienda encarecidamente asignar todos los metadatos lo antes posible. De lo contrario, existe el riesgo de que la prueba falle antes de que se establezcan todos los metadatos, lo cual afecta negativamente la legibilidad del informe de prueba.

java
import io.qameta.allure.Description;
import io.qameta.allure.Issue;
import io.qameta.allure.Link;
import io.qameta.allure.Owner;
import io.qameta.allure.Severity;
import io.qameta.allure.TmsLink;
import io.qameta.allure.junit4.DisplayName;
import org.junit.Test;

import static io.qameta.allure.SeverityLevel.*;

public class TestMyWebsite {

    @Test
    @DisplayName("Test Authentication")
    @Description("This test attempts to log into the website using a login and a password. Fails if any error happens.\n\nNote that this test does not test 2-Factor Authentication.")
    @Severity(CRITICAL)
    @Owner("John Doe")
    @Link(name = "Website", url = "https://dev.example.com/")
    @Issue("AUTH-123")
    @TmsLink("TMS-456")
    public void testAuthentication() {
        // ...
    }
}
java
import io.qameta.allure.Allure;
import org.junit.Test;

import static io.qameta.allure.SeverityLevel.*;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.getLifecycle().updateTestCase(result -> result.setName("Test Authentication"));
        Allure.description("This test attempts to log into the website using a login and a password. Fails if any error happens.\n\nNote that this test does not test 2-Factor Authentication.");
        Allure.label("severity", "critical");
        Allure.label("owner", "John Doe");
        Allure.link("Website", "https://dev.example.com/");
        Allure.issue("AUTH-123", "https://example.com/issues/AUTH-123");
        Allure.tms("TMS-456", "https://example.com/tms/TMS-456");
        // ...
    }
}

Organizar pruebas ​

Como se describe en Mejorar la navegación en tu informe de prueba, Allure admite múltiples formas de organizar pruebas en estructuras jerárquicas. Allure JUnit 4 proporciona funciones para asignar los campos relevantes a las pruebas, ya sea mediante anotaciones o de forma “dinámica” (igual que con los campos de metadatos).

Para especificar la ubicación de una prueba en la jerarquía basada en el comportamiento:

java
import io.qameta.allure.Epic;
import io.qameta.allure.Feature;
import io.qameta.allure.Story;
import org.junit.Test;

public class TestMyWebsite {

    @Test
    @Epic("Web interface")
    @Feature("Essential features")
    @Story("Authentication")
    public void testAuthentication() {
        // ...
    }
}
java
import io.qameta.allure.Allure;
import org.junit.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.epic("Web interface");
        Allure.feature("Essential features");
        Allure.story("Authentication");
        // ...
    }
}

Para especificar la ubicación de una prueba en la jerarquía basada en suites:

java
import io.qameta.allure.Allure;
import org.junit.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.label("parentSuite", "Tests for web interface");
        Allure.suite("Tests for essential features");
        Allure.label("subSuite", "Tests for authentication");
        // ...
    }
}

La ubicación de una prueba en la jerarquía basada en paquetes se define por los nombres completamente calificados de las clases en las que se declaran, mostrando los prefijos comunes como paquetes principales.

Dividir una prueba en pasos ​

Allure JUnit 4 proporciona tres formas de crear pasos y subpasos: “pasos anotados”, “pasos lambda” y “pasos no operativos” (no-op steps). Consulta la referencia.

java
import io.qameta.allure.Param;
import io.qameta.allure.Step;
import org.junit.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        testAuthenticationWith("https://1.example.com/", "alice", "qwerty");
        testAuthenticationWith("https://2.example.com/", "bob", "asdfgh");
        testAuthenticationWith("https://3.example.com/", "charlie", "zxcvbn");
    }

    @Step("Authenticate on {url}")
    void testAuthenticationWith(String url, String login, String password) {
        openWebPage(url);
        enterCredentials(login, password);
        checkIfLoggedInAs(login);
    }

    @Step("Visit {url}")
    void openWebPage(@Param("URL") String url) {
        // ...
    }

    @Step("Enter credentials")
    void enterCredentials(
            @Param("Login") String login,
            @Param("Password") String password
    ) {
        // ...
    }

    @Step("Check if I am logged in")
    void checkIfLoggedInAs(
            @Param("Login") String login
    ) {
        // ...
    }
}
java
import io.qameta.allure.Allure;
import org.junit.Test;

public class TestMyWebsite {

    private static final String[][] authenticationData = new String[][]{
            {"https://1.example.com/", "alice", "qwerty"},
            {"https://2.example.com/", "bob", "asdfgh"},
            {"https://3.example.com/", "charlie", "zxcvbn"},
    };

    @Test
    public void testAuthentication() {

        for (String[] data : authenticationData) {
            String url = data[0];
            String login = data[1];
            String password = data[2];

            Allure.step("Authenticate on %s".formatted(url), () -> {

                Allure.step("Visit %s".formatted(url), stepContext -> {
                    stepContext.parameter("URL", url);
                    // ...
                });

                Allure.step("Enter credentials", stepContext -> {
                    stepContext.parameter("Login", login);
                    stepContext.parameter("Password", password);
                    // ...
                });

                Allure.step("Check if I am logged in", stepContext -> {
                    stepContext.parameter("Login", login);
                    // ...
                });
            });
        }
    }
}
java
import io.qameta.allure.Allure;
import io.qameta.allure.model.Status;
import org.junit.Test;

public class TestMyWebsite {

    private static final String[][] authenticationData = new String[][]{
            {"https://1.example.com/", "alice", "qwerty"},
            {"https://2.example.com/", "bob", "asdfgh"},
            {"https://3.example.com/", "charlie", "zxcvbn"},
    };

    @Test
    public void testAuthentication() {

        for (String[] data : authenticationData) {
            String url = data[0];
            String login = data[1];
            String password = data[2];

            Allure.step("Begin testing %s...".formatted(url));
            try {
                // ...
                Allure.step("Visited %s.".formatted(url));

                // ...
                Allure.step("Entered credentials.");

                // ...
                Allure.step("I am logged in!");

            } catch (Exception e) {
                Allure.step("Failed!", Status.FAILED);
            }
        }
    }
}

Describir pruebas parametrizadas ​

Al usar el patrón de pruebas parametrizadas, utiliza el método parameter() de Allure JUnit 4 para agregar los parámetros al informe. Consulta la referencia.

java
import io.qameta.allure.Allure;
import org.junit.Test;

public class TestMyWebsite {

    @Test
    public void testAuthenticationWithUsername() {
        Allure.parameter("login", "johndoe");
        // ...
    }

    @Test
    public void testAuthenticationWithEmail() {
        Allure.parameter("login", "[email protected]");
        // ...
    }
}

Adjuntar capturas de pantalla y otros archivos ​

Puedes adjuntar cualquier tipo de archivos a tu informe de Allure. Por ejemplo, una forma popular de hacer que un informe sea más comprensible es adjuntar una captura de pantalla de la interfaz de usuario en un momento específico.

Allure JUnit 4 proporciona varias formas de crear un adjunto, ya sea desde archivos existentes o generados dinámicamente. Consulta la referencia.

java
import io.qameta.allure.Allure;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;

public class TestMyWebsite {

    @Test
    public void testAuthentication() throws IOException {
        // ...
        Allure.attachment("data.txt", "This is the file content.");
        try (InputStream is = Files.newInputStream(Paths.get("/path/img.png"))) {
            Allure.attachment("image.png", is);
        }
    }
}

Seleccionar pruebas mediante un archivo de plan de pruebas ​

WARNING

Para que esta característica funcione, la integración de AspectJ para Allure Report debe estar agregada al proyecto.

Si la variable de entorno ALLURE_TESTPLAN_PATH está definida y apunta a un archivo existente, JUnit 4 solo ejecutará las pruebas listadas en ese archivo.

Aquí tienes un ejemplo de ejecución de pruebas según un archivo llamado testplan.json:

bash
export ALLURE_TESTPLAN_PATH=testplan.json
./gradlew test
powershell
$Env:ALLURE_TESTPLAN_PATH = "testplan.json"
gradlew test

Información del entorno ​

Para la página principal del informe, puedes recopilar diversa información sobre el entorno en el que se ejecutaron las pruebas.

Por ejemplo, es una buena idea usar esto para registrar las versiones del sistema operativo y de Java. Esto puede ayudar al lector futuro a investigar errores que solo son reproducibles en algunos entornos.

Widget de Entorno en Allure Report

Para proporcionar información del entorno, coloca un archivo llamado environment.properties en el directorio allure-results después de ejecutar las pruebas. Consulta el ejemplo en Archivo de entorno.

Ten en cuenta que esta función debe usarse para propiedades que no cambian para todas las pruebas del informe. Si tienes propiedades que pueden ser diferentes para distintas pruebas, considera usar Pruebas parametrizadas.

Pager
Previous pageReferencia
Next pageConfiguración
Powered by

Únete a nuestro boletín

Allure TestOps
  • Visión general
  • Por qué elegirnos
  • Nube
  • Autoalojado
  • Historias de éxito
Compañía
  • Documentación
  • Blog
  • Sobre nosotros
  • Contacto
  • Eventos
© 2025 Qameta Software Inc. All rights reserved.