Empezando con Allure Cucumber-JVM

Genera hermosos informes HTML usando Allure Report y tus pruebas de Cucumber-JVM.

Ejemplo de Allure Report Cucumber-JVM

INFO

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

Configuración

INFO

Esta guía está diseñada exclusivamente para Cucumber-JVM 7. Aunque Allure mantiene compatibilidad con versiones anteriores de Cucumber-JVM (versión 4 en adelante), las configuraciones para estas versiones no se incluyen para mantener la simplicidad en esta documentación. Los pasos de configuración generales siguen siendo similares para versiones anteriores, pero deberás ajustar los nombres de las dependencias y los plugins según corresponda. Por ejemplo, cuando trabajes con Cucumber-JVM 6, la dependencia sería allure-cucumber6-jvm y el plugin a usar sería io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm.

Para integrar Allure en un proyecto Cucumber-JVM existente, debes:

Agregar las dependencias de Allure a tu proyecto.
Activar el plugin Allure Cucumber-JVM.
Configurar AspectJ para el soporte de las anotaciones @Step y @Attachment.
Designar una ubicación para el almacenamiento de los resultados de Allure.

La implementación específica de estos pasos varía según cómo esté configurado tu Cucumber-JVM. Cucumber-JVM se puede utilizar con tres tipos diferentes de ejecutores:

JUnit Platform (recomendado)
TestNG
JUnit 4 (obsoleto)

Usando JUnit Platform

JUnit Platform es el ejecutor recomendado para las pruebas Cucumber-JVM. La configuración completa se muestra en este ejemplo.

Agregar dependencias de Allure

MavenGradle (Kotlin)Gradle (Groovy)

xml

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

<!-- Agrega allure-bom a la gestión de dependencias para garantizar 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-cucumber7-jvm</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-junit-platform</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

kts

// Define la versión de Allure que deseas usar mediante la propiedad allureVersion
val allureVersion = "2.24.0"
// ...
dependencies {
    // Importa allure-bom para garantizar que se usen las versiones correctas de todas las dependencias
    testImplementation(platform("io.qameta.allure:allure-bom:$allureVersion"))
    // Agrega las dependencias necesarias de Allure en la sección de dependencias
    testImplementation("io.qameta.allure:allure-cucumber7-jvm")
    testImplementation("io.qameta.allure:allure-junit-platform")
}

groovy

// Define la versión de Allure que deseas usar mediante la propiedad allureVersion
def allureVersion = "2.24.0"

dependencies {
    // Importa allure-bom para garantizar que se usen las versiones correctas de todas las dependencias
    testImplementation platform("io.qameta.allure:allure-bom:$allureVersion")
    // Agrega las dependencias necesarias de Allure en la sección de dependencias
    testImplementation "io.qameta.allure:allure-cucumber7-jvm"
    testImplementation "io.qameta.allure:allure-junit-platform"
}

Activar el plugin Allure Cucumber-JVM

Using junit-platform.properties fileUsing @ConfigurationParameter

properties

# Create a `src/test/resources/junit-platform.properties` file and add property `cucumber.plugin` with value `io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm`:

#junit-platform.properties
cucumber.plugin=io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm

java

// Agrega la anotación `org.junit.platform.suite.api.ConfigurationParameter` y especifica la propiedad `cucumber.plugin` con el valor `io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm`:

import org.junit.platform.suite.api.ConfigurationParameter;

import static io.cucumber.core.options.Constants.PLUGIN_PROPERTY_NAME;

@Suite
@IncludeEngines("cucumber")
@ConfigurationParameter(
        key = PLUGIN_PROPERTY_NAME,
        value = "io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm"
)
class CucumberTest {
}

Usando TestNG

INFO

Para garantizar la compatibilidad con Cucumber-JVM 7, debes usar TestNG 7.8 o superior, que a su vez requiere Java 11 o más reciente. Sin embargo, si también estás utilizando Allure TestNG, que es compatible con TestNG 6, debes tener cuidado con el orden de las dependencias en tu proyecto. Declara la dependencia io.qameta.allure:allure-testng después de la dependencia io.cucumber:cucumber-testng, o cualquier dependencia explícita de TestNG, para evitar conflictos. Esta secuencia es importante para garantizar que se utilice la versión correcta de TestNG.

Añadir dependencias de Allure

MavenGradle (Kotlin)Gradle (Groovy)

xml

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

<!-- Añade allure-bom a la gestión de dependencias para garantizar el uso de 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 en la sección de dependencias -->
<dependencies>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-cucumber7-jvm</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-testng</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

kts

// Define la versión de Allure que deseas usar mediante la propiedad allureVersion
val allureVersion = "2.24.0"
// ...
dependencies {
    // Importa allure-bom para garantizar el uso de versiones correctas de todas las dependencias
    testImplementation(platform("io.qameta.allure:allure-bom:$allureVersion"))
    // Añade las dependencias necesarias de Allure en la sección de dependencias
    testImplementation("io.qameta.allure:allure-cucumber7-jvm")
    testImplementation("io.qameta.allure:allure-testng")
}

groovy

// Define la versión de Allure que deseas usar mediante la propiedad allureVersion
def allureVersion = "2.24.0"

dependencies {
    // Importa allure-bom para garantizar el uso de versiones correctas de todas las dependencias
    testImplementation platform("io.qameta.allure:allure-bom:$allureVersion")
    // Añade las dependencias necesarias de Allure en la sección de dependencias
    testImplementation "io.qameta.allure:allure-cucumber7-jvm"
    testImplementation "io.qameta.allure:allure-testng"
}

Activar el plugin Allure Cucumber-JVM

Añade el plugin io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm a tus opciones de Cucumber:

java

@Test
@CucumberOptions(
        plugin = {
                "io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm"
        }
)
public class CucumberTest extends AbstractTestNGCucumberTests {
}

Usando JUnit 4

Agregar dependencias de Allure

MavenGradle (Kotlin)Gradle (Groovy)

xml

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

<!-- Agrega allure-bom a la gestión de dependencias para garantizar el uso de 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 a la sección de dependencias -->
<dependencies>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-cucumber7-jvm</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-junit4</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

kts

// Define la versión de Allure que deseas usar mediante la propiedad allureVersion
val allureVersion = "2.24.0"
// ...
dependencies {
    // Importa allure-bom para garantizar el uso de las versiones correctas de todas las dependencias
    testImplementation(platform("io.qameta.allure:allure-bom:$allureVersion"))
    // Agrega las dependencias necesarias de Allure a la sección de dependencias
    testImplementation("io.qameta.allure:allure-cucumber7-jvm")
    testImplementation("io.qameta.allure:allure-junit4")
    testImplementation("io.qameta.allure:allure-junit4-aspect")
}

groovy

// Define la versión de Allure que deseas usar mediante la propiedad allureVersion
def allureVersion = "2.24.0"

dependencies {
    // Importa allure-bom para garantizar el uso de las versiones correctas de todas las dependencias
    testImplementation platform("io.qameta.allure:allure-bom:$allureVersion")
    // Agrega las dependencias necesarias de Allure a la sección de dependencias
    testImplementation "io.qameta.allure:allure-cucumber7-jvm"
    testImplementation "io.qameta.allure:allure-junit4"
    testImplementation "io.qameta.allure:allure-junit4-aspect"
}

Activar el plugin Allure Cucumber-JVM

Agrega el plugin io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm a tus opciones de Cucumber:

java

@RunWith(Cucumber.class)
@CucumberOptions(
        plugin = {
                "io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm"
        }
)
public class CucumberTest {
}

Configurar AspectJ

Allure utiliza AspectJ para la funcionalidad de las anotaciones @Step y @Attachment. Además, ciertos frameworks, como JUnit 4 o AssertJ, dependen de la integración con AspectJ para funcionar correctamente. Estos frameworks requerirán una configuración adecuada para asegurar su correcto funcionamiento.

MavenGradle (Kotlin)Gradle (Groovy)

xml

<!-- Define la versión de AspectJ -->
<properties>
    <aspectj.version>1.9.20.1</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.1.2</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>
        <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.20.1"

// 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 de AspectJ para Allure
    testImplementation("io.qameta.allure:allure-junit4-aspect")
}

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

groovy

// Define la versión de AspectJ
def aspectJVersion = "1.9.20.1"

// 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 de AspectJ para Allure
    testImplementation "io.qameta.allure:allure-junit4-aspect"
}

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

Especificar la ubicación de los resultados de Allure

Por defecto, Allure guarda los resultados de las pruebas en el directorio raíz del proyecto. Sin embargo, se recomienda almacenar los resultados de las pruebas en el directorio de salida de compilación.

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

MavenGradle (Kotlin)Gradle (Groovy)

properties

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

properties

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

properties

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

Ejecución de pruebas

Ejecuta tus pruebas Cucumber-JVM como lo harías normalmente. A continuación se muestran los comandos para usuarios de Gradle y Maven:

Para Gradle:

MacOS/LinuxWindows

bash

./gradlew test

bash

gradlew test

For Maven:

MacOS/LinuxWindows

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. Posteriormente, puedes generar un informe HTML a partir de estos resultados utilizando las herramientas de generación de informes de Allure.

Escritura de pruebas

El adaptador Allure Cucumber-JVM extiende las características estándar de informes de Cucumber-JVM al proporcionar capacidades adicionales para crear pruebas más informativas y estructuradas. Esta sección destaca las mejoras clave que se pueden utilizar:

Anotación de Metadatos: Enriquece los informes de prueba con descripciones, enlaces y otros metadatos.
Organización de Pruebas: Estructura tus pruebas en jerarquías claras para una mejor legibilidad y organización.
División de Pasos: Divide las pruebas en pasos más pequeños sub-pasos de prueba para facilitar la comprensión y el mantenimiento.
Pruebas Parametrizadas: Describe claramente los parámetros para pruebas parametrizadas para especificar diferentes escenarios.
Archivos Adjuntos: Captura automáticamente capturas de pantalla y otros archivos durante la ejecución de la prueba.
Selección de Pruebas: Utiliza un archivo de plan de pruebas para seleccionar qué pruebas ejecutar, permitiendo una ejecución flexible de las pruebas.
Detalles del Entorno: Incluye información completa del entorno para acompañar el informe de prueba.

Añadiendo metadatos

Allure te permite enriquecer tus informes con una variedad de metadatos. Esta información adicional proporciona contexto y detalles para cada prueba, mejorando la utilidad del informe. Consulta la sección de referencia de metadatos para ver una lista exhaustiva de lo que se puede añadir.

Puedes asignar metadatos a las características de Cucumber-JVM de dos formas:

Usando etiquetas Gherkin: Utiliza una convención de nomenclatura para añadir metadatos a los escenarios de prueba.
API en Tiempo de Ejecución: Utiliza una llamada de método dentro del cuerpo de un método de paso de prueba para asignar dinámicamente metadatos durante la ejecución de la prueba. Este enfoque permite la construcción de cadenas y valores sobre la marcha.

Al asignar metadatos a tus pruebas utilizando la API en Tiempo de Ejecución de Allure, es crucial considerar el equilibrio entre el control y los riesgos potenciales. Si bien la API en Tiempo de Ejecución ofrece más flexibilidad en el manejo dinámico de metadatos, también conlleva ciertos inconvenientes. Por ejemplo, si una prueba falla antes de que se apliquen todos los metadatos dinámicos, el informe resultante puede carecer de información importante, lo que conduce a una menor claridad y completitud. Por lo tanto, es esencial asegurarse de que los metadatos se establezcan temprano en la prueba para mitigar este riesgo.

Gherkin TagsRuntime API

gherkin

@allure.label.layer:web
@allure.label.owner:eroshenkoam
@allure.label.page:/{org}/{repo}/labels
Feature: Labels

  @critical
  @allure.label.jira:AE-2
  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

java

import io.cucumber.java.en.Given;
import io.qameta.allure.Allure;

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.label("layer", "web");
        Allure.label("owner", "eroshenkoam");
        Allure.label("page", "/{org}/{repo}/labels");
        Allure.label("severity", "critical");
        Allure.label("jira", "AE-2");
        // ...
    }
}

WARNING

Para utilizar etiquetas Gherkin para asignar datos, asegúrate de actualizar a Allure Report 2.27 o superior o considera cargar tus resultados de prueba en Allure TestOps.

Organizar pruebas

Allure facilita la navegación mejorada en informes de prueba al permitir que las pruebas se organicen en estructuras jerárquicas. Como se explica en la sección sobre Mejorar la navegación en tu informe de prueba, Allure Cucumber-JVM admite esta función.

Para definir la posición de una prueba dentro de la jerarquía basada en el comportamiento:

Gherkin TagsRuntime API

gherkin

@allure.label.epic:Web
Feature: Labels

    Scenario: Create new label for authorized user
        When I open labels page
        And I create label with title "hello"
        Then I should see label with title "hello"

java

import io.cucumber.java.en.Given;
import io.qameta.allure.Allure;

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.epic("Web");
        // ...
    }
}

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

Gherkin TagsRuntime API

gherkin

@allure.label.parentSuite:Cucumber
@allure.label.suite:Labels
@allure.label.subSuite:Authorized
Feature: Labels

  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

java

import io.cucumber.java.en.Given;
import io.qameta.allure.Allure;

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.label("parentSuite", "Cucumber");
        Allure.label("suite", "Labels");
        Allure.label("subSuite", "Authorized");
        // ...
    }
}

La ubicación de una prueba dentro de la jerarquía basada en paquetes se determina por la ubicación de los archivos de características en relación con el directorio de recursos de prueba.

Creación de sub-pasos

Allure Cucumber-JVM mejora los informes de prueba permitiendo la creación de sub-pasos dentro de un solo paso Gherkin, lo cual puede ser especialmente útil en casos donde tienes un conjunto de acciones que son:

Suficientemente cohesivas para describirse como un solo paso en un escenario Gherkin.
Suficientemente intrincadas como para involucrar varios puntos potenciales de falla.

Allure proporciona tres métodos para definir sub-pasos:

Sub-pasos Anotados: Definidos utilizando la anotación @Step.
Sub-pasos Lambda: Utilizando expresiones lambda para definiciones de pasos más concisas e en línea.
Sub-pasos Sin Operación: Utilizados como marcadores o para estructurar pasos sin funcionalidad adicional.

Para obtener orientación detallada sobre cómo implementar cada tipo de sub-paso, consulta la referencia de pasos de prueba.

Annotated sub-stepsLambda steps and no-op steps

java

import io.cucumber.java.en.Then;
import io.qameta.allure.Step;

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        subStep1();
        subStep2();
    }

    @Step("Sub-step 1")
    public void subStep1() {
        subSubStep1();
        subSubStep2();
    }

    @Step("Sub-sub-step 1")
    public void subSubStep1() {
        // ...
    }

    @Step("Sub-sub-step 2")
    public void subSubStep2() {
        // ...
    }

    @Step("Sub-step 2")
    public void subStep2() {
        // ...
    }
}

java

import io.cucumber.java.en.Then;
import io.qameta.allure.Allure;

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {

        Allure.step("Sub-step 1", (step) -> {
            // ...
            Allure.step("Sub-sub-step 1");
            // ...
            Allure.step("Sub-sub-step 2");
        });

        Allure.step("Sub-step 2", (step) -> {
            // ...
        });
    }
}

Soporte para Scenario Outlines

Allure Cucumber-JVM proporciona soporte completo para Scenario Outlines, una característica de Cucumber-JVM que permite pruebas parametrizadas. No se necesita ninguna configuración especial para aprovechar esta capacidad dentro de Allure.

gherkin

Feature: Parameters

  Scenario Outline: test authorization as "<login>"
    Then authorize as "<login>"

    Examples:
      | login               |
      | johndoe             |
      | [email protected] |

java

import io.cucumber.java.en.Then;
import io.qameta.allure.Allure;

public class CucumberSteps {

    @Then("authorize as {string}")
    public void testAuthentication(String login) {
        // ...
    }
}

Además, la API de tiempo de ejecución de Allure se puede utilizar para incluir parámetros adicionales en el informe de prueba, ofreciendo capacidades mejoradas de documentación y más detalles para cada escenario de prueba.

java

import io.cucumber.java.en.Then;
import io.qameta.allure.Allure;

public class CucumberSteps {

    @Then("authorize as {string}")
    public void testAuthentication(String login) {
        Allure.parameter("Login", login);
        // ...
    }
}

Adjuntar capturas de pantalla y otros archivos

En los informes de Allure, tienes la capacidad de adjuntar varios tipos de archivos, lo cual puede mejorar enormemente la comprensión del informe. Una práctica común es adjuntar capturas de pantalla que capturan el estado de la interfaz de usuario en momentos específicos durante la ejecución de la prueba.

Allure Cucumber-JVM ofrece múltiples métodos para crear adjuntos, ya sea desde archivos preexistentes o desde contenido generado sobre la marcha. Para instrucciones detalladas sobre cómo implementar adjuntos, consulta la sección de adjuntos en la referencia de Allure Cucumber-JVM.

java

import io.cucumber.java.en.Then;
import io.qameta.allure.Allure;

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() 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);
        }
        // ...
    }
}

Ejecución selectiva de pruebas (Allure TestOps)

WARNING

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

En Allure TestOps, tienes la opción de volver a ejecutar solo un subconjunto de pruebas utilizando el mismo trabajo de Integración Continua (CI) que se utilizó para la ejecución completa de las pruebas. La capacidad de realizar ejecuciones selectivas de pruebas varía según el runner de pruebas que estés utilizando:

JUnit Platform Runner: Este runner soporta ejecuciones selectivas de pruebas de forma nativa, lo que te permite especificar fácilmente qué pruebas incluir en la rerun sin necesidad de configuración adicional.
JUnit 4 Runner: Para los usuarios de Gradle, JUnit 4 también admite ejecuciones selectivas de pruebas directamente. Sin embargo, los usuarios de Maven podrían encontrar algunos problemas con esta funcionalidad debido a limitaciones dentro del plugin Maven Surefire.
TestNG Runner: Para utilizar ejecuciones selectivas de pruebas con TestNG, debes estar utilizando la versión 7.8 o posterior de TestNG. Además, es posible que se necesiten algunas configuraciones adicionales para habilitar esta función.

TestNG

Para integrar ejecuciones selectivas de pruebas en un proyecto TestNG con Allure TestOps, sigue estos pasos:

Crea CucumberTestNgFilter: Implementa una clase de filtro llamada CucumberTestNgFilter. Esta clase determinará qué pruebas ejecutar según tus criterios. Coloca esta clase dentro del directorio de origen de tu proyecto, asegurándote de que esté correctamente empaquetada.
Registra CucumberTestNgFilter: En tu proyecto, crea un archivo llamado META-INF/services/org.testng.ITestNGListener en tus recursos de prueba. Dentro de este archivo, escribe el nombre completo calificado de tu clase CucumberTestNgFilter. Este paso es crucial ya que registra tu filtro como un listener de TestNG, que TestNG invocará durante la ejecución de las pruebas.

java

// Paso 1: Crea CucumberTestNgFilter.java
package com.yourproject.filters;

import io.cucumber.testng.FeatureWrapper;
import io.cucumber.testng.Pickle;
import io.cucumber.testng.PickleWrapper;
import org.testng.IDataProviderInterceptor;
import org.testng.IDataProviderMethod;
import org.testng.ITestContext;
import org.testng.ITestNGMethod;

import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CucumberTestNgFilter implements IDataProviderInterceptor {

    private static final String CUCUMBER_WORKING_DIR
            = Paths.get("").toUri().toString();
    private static final String CLASSPATH_PREFIX = "classpath:";

    private static final String CUCUMBER_RUN_METHOD
            = "io.cucumber.testng.AbstractTestNGCucumberTests.runScenario";

    @Override
    public Iterator<Object[]> intercept(
      final Iterator<Object[]> original,
      final IDataProviderMethod dataProviderMethod,
      final ITestNGMethod method,
      final ITestContext iTestContext
    ) {
        if (!CUCUMBER_RUN_METHOD.equals(method.getQualifiedName())) {
            return original;
        }

        final List<Object[]> filtered = new ArrayList<>();
        original.forEachRemaining(objects -> {
            if (objects.length != 2) {
                filtered.add(objects);
            }
            final PickleWrapper first = (PickleWrapper) objects[0];
            final FeatureWrapper second = (FeatureWrapper) objects[1];

            final Pickle pickle = first.getPickle();
            final String fullName = String.format("%s:%d",
                    getUri(pickle),
                    pickle.getLine()
            );

            System.out.println(fullName);

            filtered.add(new Object[]{first, second});
        });

        return filtered.iterator();
    }

    private String getUri(final Pickle pickle) {
        final String testCaseUri = pickle.getUri().toString();
        if (testCaseUri.startsWith(CUCUMBER_WORKING_DIR)) {
            return testCaseUri.substring(CUCUMBER_WORKING_DIR.length());
        }
        if (testCaseUri.startsWith(CLASSPATH_PREFIX)) {
            return testCaseUri.substring(CLASSPATH_PREFIX.length());
        }
        return testCaseUri;
    }
}

Para el paso 2, la estructura del proyecto debe incluir:

text

src/
└── test/
    └── resources/
        └── META-INF/
            └── services/
                └── org.testng.ITestNGListener

Información del entorno

Para la página principal del informe, puedes recopilar varios detalles sobre el entorno en el cual se ejecutaron las pruebas.

Por ejemplo, es una buena práctica incluir información como el sistema operativo y la versión de Java. Esto puede ayudar al lector futuro a investigar errores que solo se reproducen en ciertos entornos.

Widget de Entornos en el Informe de Allure

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 debería utilizarse para propiedades que no cambian para todas las pruebas en el informe. Si tienes propiedades que pueden ser diferentes para pruebas distintas, considera utilizar Pruebas Parametrizadas.

Empezando con Allure Cucumber-JVM

Configuración

Usando JUnit Platform

Agregar dependencias de Allure

Activar el plugin Allure Cucumber-JVM

Usando TestNG

Añadir dependencias de Allure

Activar el plugin Allure Cucumber-JVM

Usando JUnit 4

Agregar dependencias de Allure

Activar el plugin Allure Cucumber-JVM

Configurar AspectJ

Especificar la ubicación de los resultados de Allure

Ejecución de pruebas

Escritura de pruebas

Añadiendo metadatos

Organizar pruebas

Creación de sub-pasos

Soporte para Scenario Outlines

Adjuntar capturas de pantalla y otros archivos

Ejecución selectiva de pruebas (Allure TestOps)

TestNG

Información del entorno

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Empezando con Allure Cucumber-JVM ​

Configuración ​

Usando JUnit Platform ​

Agregar dependencias de Allure ​

Activar el plugin Allure Cucumber-JVM ​

Usando TestNG ​

Añadir dependencias de Allure ​

Activar el plugin Allure Cucumber-JVM ​

Usando JUnit 4 ​

Agregar dependencias de Allure ​

Activar el plugin Allure Cucumber-JVM ​

Configurar AspectJ ​

Especificar la ubicación de los resultados de Allure ​

Ejecución de pruebas ​

Escritura de pruebas ​

Añadiendo metadatos ​

Organizar pruebas ​

Creación de sub-pasos ​

Soporte para Scenario Outlines ​

Adjuntar capturas de pantalla y otros archivos ​

Ejecución selectiva de pruebas (Allure TestOps) ​

TestNG ​

Información del entorno ​

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Empezando con Allure Cucumber-JVM

Configuración

Usando JUnit Platform

Agregar dependencias de Allure

Activar el plugin Allure Cucumber-JVM

Usando TestNG

Añadir dependencias de Allure

Activar el plugin Allure Cucumber-JVM

Usando JUnit 4

Agregar dependencias de Allure

Activar el plugin Allure Cucumber-JVM

Configurar AspectJ

Especificar la ubicación de los resultados de Allure

Ejecución de pruebas

Escritura de pruebas

Añadiendo metadatos

Organizar pruebas

Creación de sub-pasos

Soporte para Scenario Outlines

Adjuntar capturas de pantalla y otros archivos

Ejecución selectiva de pruebas (Allure TestOps)

TestNG

Información del entorno