Primeros pasos con Allure Playwright Java

Genera reportes HTML atractivos usando Allure Report y tus pruebas de Playwright Java.

Configuración

Allure Playwright Java funciona junto a tu framework de pruebas — primero configura JUnit 5 o TestNG, luego sigue los pasos a continuación.

Para integrar Allure Playwright en tu proyecto, necesitas:

1. Agregar las dependencias de Allure Playwright.
2. Configurar el agente de AspectJ weaving.
3. Especificar una ubicación para el almacenamiento de resultados de Allure.

Agregar dependencias de Allure

Maven

<!-- Define la versión de Allure que deseas usar mediante la propiedad allure.version -->
<properties>
    <allure.version>VERSION</allure.version>
    <aspectj.version>1.9.25.1</aspectj.version>
</properties>

<!-- Agrega allure-bom a la gestión de dependencias para asegurar que se usen 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>

<!-- Agrega las dependencias necesarias de Allure en la sección de dependencias -->
<dependencies>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-playwright</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Gradle (Kotlin)

val allureVersion = "VERSION"
val aspectjVersion = "1.9.25.1"

val aspectjAgent: Configuration by configurations.creating

dependencies {
    testImplementation(platform("io.qameta.allure:allure-bom:$allureVersion"))
    testImplementation("io.qameta.allure:allure-playwright")
    testRuntimeOnly("org.aspectj:aspectjrt:$aspectjVersion")
    aspectjAgent("org.aspectj:aspectjweaver:$aspectjVersion")
}

Gradle (Groovy)

def allureVersion = "VERSION"
def aspectjVersion = "1.9.25.1"

configurations {
    aspectjAgent
}

dependencies {
    testImplementation platform("io.qameta.allure:allure-bom:$allureVersion")
    testImplementation "io.qameta.allure:allure-playwright"
    testRuntimeOnly "org.aspectj:aspectjrt:$aspectjVersion"
    aspectjAgent "org.aspectj:aspectjweaver:$aspectjVersion"
}

Configurar el agente de AspectJ

Allure Playwright utiliza AspectJ para interceptar llamadas a la API de Playwright en tiempo de ejecución y registrarlas como pasos de Allure. El weaver de AspectJ debe estar adjunto a la JVM cuando se ejecutan las pruebas.

Maven

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.2.3</version>
    <configuration>
        <argLine>
            -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
        </argLine>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
    </dependencies>
</plugin>

Gradle (Kotlin)

tasks.test {
    doFirst {
        jvmArgs("-javaagent:${configurations["aspectjAgent"].singleFile}")
    }
}

Gradle (Groovy)

test {
    doFirst {
        jvmArgs "-javaagent:${configurations.aspectjAgent.singleFile}"
    }
}

Especificar la ubicación de resultados de Allure

Allure guarda los resultados de prueba en el directorio raíz del proyecto por defecto. Se recomienda almacenar los resultados en el directorio de salida de la build.

Crea un archivo allure.properties en src/test/resources:

Maven

allure.results.directory=target/allure-results

Gradle (Kotlin)

allure.results.directory=build/allure-results

Gradle (Groovy)

allure.results.directory=build/allure-results

Generar un reporte

Después de ejecutar tus pruebas, convierte los resultados en un reporte HTML usando uno de estos comandos:

• allure generate procesa los resultados de prueba y guarda un reporte HTML en el directorio allure-report. Para ver el reporte, usa el comando allure open.

• allure serve crea el mismo reporte que allure generate, y luego abre automáticamente la página principal del reporte en un navegador web.

Acciones del navegador como pasos

Con el agente de AspectJ activo, Allure Playwright intercepta automáticamente las llamadas a la API de Playwright Java y las registra como pasos en el reporte de pruebas. No se requiere código adicional.

Se interceptan los siguientes tipos de Playwright:

• Page, Frame, Locator, ElementHandle — métodos de interacción con el navegador
• Clases de aserción de Playwright — aserciones assertThat(...)

Los nombres de los pasos se generan a partir del nombre del método y sus argumentos. Por ejemplo:

page.click("button");                 // → "Click button"
page.navigate("https://example.com"); // → "Navigate to https://example.com"
page.hover(".menu-item");             // → "Hover .menu-item"
page.fill("#search", "query");        // → "Fill #search with <redacted>"
page.type("#comment", "text");        // → "Type <redacted> into #comment"
page.screenshot();                    // → paso "Take screenshot", con un adjunto "Screenshot" dentro de él

Los valores pasados a fill(), type() y press() se reemplazan por <redacted> en los nombres de los pasos por defecto para evitar exponer contraseñas y otros datos sensibles. Consulta la configuración para cambiar este comportamiento.

Los pasos de acción de Playwright se anidan bajo cualquier paso de Allure que definas:

Allure.step("Flujo de compra", () -> {
    page.click("button");   // aparece como un subpaso de "Flujo de compra"
});

Por defecto, solo se registran como pasos los métodos reconocidos de interacción con el navegador (click, fill, navigate, hover, check, type, dragTo, waitForSelector, y más) y las aserciones de Playwright. Para registrar cada llamada a un método público de la API de Playwright, establece allure.playwright.steps.mode=all en allure.properties.

Captura de artefactos del navegador

Allure Playwright captura artefactos del navegador automáticamente y también proporciona helpers para la captura manual.

Al fallar la prueba

Cuando una prueba falla o está rota, Allure Playwright captura automáticamente una captura de pantalla y el código fuente actual de la página para cada página registrada, y los adjunta al resultado de prueba.

Esto requiere que las páginas o contextos estén registrados, ya sea explícitamente o automáticamente (consulta Registro de páginas y contextos).

Al cerrar

Cuando se cierra un Page, BrowserContext o Browser mientras una prueba está activa, Allure Playwright recopila automáticamente:

• Mensajes de consola — salida de la consola del navegador acumulada desde que se creó la página (controlado por allure.playwright.close.page-logs).
• Errores de página — excepciones de JavaScript no capturadas (controlado por allure.playwright.close.page-logs).
• Video — si el contexto fue creado con grabación de video habilitada (controlado por allure.playwright.close.video).
• Trace — si el tracing fue iniciado con AllurePlaywright.startTracing() (controlado por allure.playwright.close.trace). Consulta Captura de trace para el conjunto completo de disparadores; cerrar un Page individual no dispara el adjunto de trace.

Los mensajes de consola y errores de página también se capturan cuando termina la prueba para cualquier página registrada cuyo contexto no fue cerrado explícitamente durante la prueba.

Consulta la configuración para detalles sobre cada ajuste.

Captura manual

Puedes capturar y adjuntar cualquiera de estos artefactos en cualquier momento durante una prueba usando los helpers estáticos de AllurePlaywright:

import io.qameta.allure.playwright.AllurePlaywright;

// Adjunta una captura de pantalla del estado actual de la página
AllurePlaywright.attachScreenshot("Antes de enviar", page);

// Adjunta el HTML actual de la página
AllurePlaywright.attachPageSource("Código fuente de la página", page);

// Adjunta los mensajes de consola recopilados por la página
AllurePlaywright.attachConsoleMessages("Consola del navegador", page);

// Adjunta errores de JavaScript no capturados
AllurePlaywright.attachPageErrors("Errores de página", page);

// Adjunta un archivo de trace existente
AllurePlaywright.attachTrace("Trace de Playwright", Path.of("trace.zip"));

// Adjunta un archivo de video existente
AllurePlaywright.attachVideo("Grabación de prueba", Path.of("video.webm"));

Todos los helpers son seguros de llamar cuando no hay una prueba de Allure activa — no hacen nada en ese caso.

Registro de páginas y contextos

Allure Playwright rastrea las páginas y contextos registrados y los utiliza para capturar capturas de pantalla, código fuente de la página, mensajes de consola y errores de página cuando una prueba falla.

Cuando el weaving de AspectJ está activo, las páginas y contextos se registran automáticamente de dos maneras: cuando se crean mediante browser.newPage(), browser.newContext(), o context.newPage(); y cuando se realiza cualquier acción interceptada de Playwright (como click o fill) en una página mientras una prueba está activa. El registro automático solo aplica mientras una prueba está activa; los objetos creados y usados exclusivamente antes de que la prueba comience, como en un setup @BeforeAll, deben registrarse explícitamente.

Para páginas o contextos creados fuera de los métodos estándar de fábrica de Playwright, o fuera de una prueba activa, regístralos explícitamente:

AllurePlaywright.register(page);
AllurePlaywright.register(context);

Registrar un Page también registra su BrowserContext padre.

Captura de trace

Las traces de Playwright registran la actividad del navegador como un archivo rico que puede abrirse en el Playwright Trace Viewer. Allure Playwright puede iniciar una trace y adjuntar el archivo resultante automáticamente.

Usa AllurePlaywright.startTracing() para comenzar a trazar un contexto de navegador. El TraceSession retornado detiene el tracing y adjunta el archivo cuando se cierra:

import io.qameta.allure.playwright.AllurePlaywright;
import io.qameta.allure.playwright.TraceSession;

BrowserContext context = browser.newContext();

try (TraceSession trace = AllurePlaywright.startTracing(context)) {
    // ejecutar acciones del navegador
}
// el archivo de trace ahora está adjunto al resultado de prueba

El tracing también se detiene y adjunta automáticamente cuando:

• Se cierra el BrowserContext o Browser mientras una prueba está activa (controlado por allure.playwright.close.trace).
• La prueba falla mientras una trace sigue abierta (siempre, independientemente de allure.playwright.close.trace).
• La prueba termina mientras una trace sigue abierta (controlado por allure.playwright.close.trace).

Para asignar un nombre personalizado al adjunto de trace, usa la sobrecarga que acepta un nombre:

TraceSession trace = AllurePlaywright.startTracing("Trace del flujo de login", context);

Integración con el ciclo de vida del framework

Cuando allure-playwright está en el classpath junto a cualquier integración de framework de Allure, la integración del ciclo de vida se configura automáticamente — no se necesita configuración adicional.

Para frameworks de prueba sin integración de Allure, llama a los siguientes métodos en tu setup y limpieza de pruebas. beforeTest() debe ejecutarse antes del cuerpo de la prueba, y afterTest() debe ejecutarse después — normalmente en un par @BeforeEach/@AfterEach. Detectar fallos requiere interceptar la excepción del cuerpo de la prueba antes de que se propague:

import io.qameta.allure.playwright.AllurePlaywright;

// Antes de que se ejecute el cuerpo de la prueba (@BeforeEach o equivalente)
AllurePlaywright.beforeTest();

// Envuelve la ejecución del cuerpo de la prueba para detectar fallos:
try {
    // cuerpo de la prueba
} catch (Throwable t) {
    AllurePlaywright.afterTestFailure(t);
    throw t;
} finally {
    AllurePlaywright.afterTest();
}

Información del entorno

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

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.

os.name=Linux
java.version=17.0.10
browser=chromium
playwright.version=1.60.0