Referencia de Allure Cucumber-JVM

Estas son las funciones que puedes usar para integrar tus pruebas de Cucumber-JVM con Allure.

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 obtener una lista exhaustiva de lo que se puede agregar.

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

1. Usando etiquetas Gherkin: Usa una convención de nomenclatura para agregar metadatos a los escenarios de prueba.
2. API en tiempo de ejecución: Usa una llamada de método dentro del cuerpo de un método de paso de prueba para asignar metadatos dinámicamente durante la ejecución de la prueba. Este enfoque permite construir 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 control y los posibles riesgos. Si bien la API en tiempo de ejecución ofrece mayor flexibilidad para manejar los metadatos dinámicamente, también presenta 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 lleva 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.

WARNING

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

Metadatos

Asigna una descripción, enlaces y otros metadatos a una prueba.

Título

• Allure.getLifecycle().updateTestCase(Consumer<TestResult> update)

Establece el título de la prueba.

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.getLifecycle().updateTestCase(result ->
                result.setName("Some modified scenario name"));
        // ...
    }
}

Description

• Allure.description(String description)

Establece la descripción de la prueba.

Puedes comenzar una característica con una descripción en tu archivo Gherkin o llamar a los métodos para actualizar los valores dinámicamente.

Se permite el formato Markdown. Cualquier formato HTML, si está presente, será eliminado por motivos de seguridad.

Gherkin description

Feature: Labels

  This test attempts to create a label with specified title

  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"

Runtime API

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.description("This test attempts to create a label with specified title");
        // ...
    }
}

Owner

Establece el propietario de la prueba.

Puedes usar las etiquetas @allure.label.owner en tu archivo Gherkin o llamar al método label() para actualizar los valores dinámicamente. Ten en cuenta que, al usar etiquetas en Gherkin, el valor no puede contener espacios.

Set the test's owner.

You can either use the @allure.label.owner tags in your Gherkin file or call the label() method for updating the values dynamically. Note that when using tags in Gherkin, the value cannot contain spaces.

Gherkin tags

@allure.label.owner=JohnDoe
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"

Runtime API

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.label("owner", "JohnDoe");
        // ...
    }
}

Tag

Establece los tags de la prueba.

Puedes usar las etiquetas en tu archivo Gherkin o llamar al método label() para actualizar los valores dinámicamente.

Gherkin tags

@ui @labels
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"

Runtime API

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.label("tag", "ui");
        Allure.label("tag", "labels");
        // ...
    }
}

Severity

Establece la gravedad de la prueba.

Los valores permitidos son: “trivial”, “minor”, “normal”, “critical”, y “blocker”.

Gherkin tags

Feature: Labels

  @critical
  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"

Runtime API

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.label("severity", "critical");
        // ...
    }
}

Label

• Allure.label(String name, String value)

Las etiquetas de Allure son pares clave-valor que se utilizan para agregar información adicional a tus pruebas. Pueden considerarse como una forma de categorizar, organizar y buscar casos de prueba dentro de tus informes de Allure. Las etiquetas se pueden utilizar para especificar cosas como el ID del caso de prueba, la gravedad de la prueba, la característica que se está probando o la historia relacionada con la prueba. Esta información adicional ayuda a crear informes más detallados y estructurados.

Gherkin Tags

@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"

Runtime API

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");
        // ...
    }
}

Allure ID (Allure TestOps)

Puedes especificar el ID del caso de prueba para tus pruebas de Cucumber-JVM utilizando la etiqueta @allure.id o mediante la API en tiempo de ejecución:

Gherkin Tags

Feature: Labels

  @allure.id:123
  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"

Link

• Allure.link(String url)
• Allure.link(String name, String url)
• Allure.link(String name, String type, String url)
• Allure.issue(String name, String url)
• Allure.tms(String name, String url)

Agrega un enlace relacionado con la prueba.

Según el type (que puede ser cualquier cadena), Allure intentará cargar un patrón de enlace correspondiente para procesar la URL, como se define en la opción de configuración allure.link.*.pattern. Si no se encuentra ningún patrón para el tipo dado, la URL se deja sin modificar.

El name se utilizará como el texto del enlace. Si se omite, se usará la URL sin procesar.

Para mayor comodidad, Allure proporciona dos funciones abreviadas con tipos de enlace preseleccionados: issue y tms.

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

public class CucumberSteps {

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

Jerarquía basada en el comportamiento

• Allure.epic(String value)
• Allure.feature(String value)
• Allure.story(String value)

Asigna los nombres de epics, features o user stories a una prueba, como parte de la jerarquía basada en comportamiento de Allure.

Puedes usar las etiquetas @allure.label.* en tu archivo Gherkin o llamar a los métodos para actualizar los valores dinámicamente. Ten en cuenta que cuando usas etiquetas en Gherkin, los valores no pueden contener espacios.

Gherkin tags

@allure.label.epic:WebInterface
@allure.label.feature:EssentialFeatures
@allure.label.story:Labels
Feature: My feature
  Scenario: My scenario
    Then my step

Runtime API

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.epic("Web interface");
        Allure.feature("Essential features");
        Allure.story("Labels");
        // ...
    }
}

Jerarquía basada en suites

• Allure.suite(String value)

Asigna el nombre de la suite, como parte de la jerarquía basada en suites de Allure.

Puedes usar las etiquetas @allure.label.* en tu archivo Gherkin o llamar a los métodos suite() y label() para actualizar los valores dinámicamente. Ten en cuenta que cuando usas etiquetas en Gherkin, los valores no pueden contener espacios.

Gherkin tags

@allure.label.parent_suite:WebInterface
@allure.label.suite:EssentialFeatures
@allure.label.sub_suite:Labels
Feature: My feature
  Scenario: My scenario
    Then my step

Runtime API

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

public class CucumberSteps {

    @When("^I open labels page$")
    public void openLabelsPage() {
        Allure.label("parentSuite", "Tests for web interface");
        Allure.suite("Tests for essential features");
        Allure.label("subSuite", "Tests for labels");
        // ...
    }
}

Pasos de prueba

• @Step(String value="")
• Allure.step(String name)
• Allure.step(String name, Status status)
• Allure.step(String name, ThrowableRunnableVoid runnable)
• Allure.step(String name, ThrowableRunnable<T> runnable)
• Allure.step(ThrowableContextRunnableVoid<StepContext> runnable)
• Allure.step(String name, ThrowableContextRunnableVoid<StepContext> runnable)
• Allure.step(String name, ThrowableContextRunnable<T, StepContext> runnable)
• Allure.step(ThrowableContextRunnable<T, StepContext> runnable)

Define un paso de prueba con el nombre dado.

Hay tres formas de definir un paso.

• "Un paso anotado": define un método que contenga un paso de prueba y decóralo con @Step().
• "Un paso lambda": escribe un paso de prueba en una función lambda y pásalo a Allure.step().
• "Un paso sin efecto (no-op)": solo pasa un nombre y un estado opcional a Allure.step() para agregar inmediatamente una entrada correspondiente a los resultados como un subpaso del paso actual.

Cuando implementas una función para un paso lambda, puede aceptar ya sea sin argumentos o un solo argumento de la clase StepContext. Este objeto proporciona los siguientes métodos:

• name() — sobrescribe el nombre del paso durante su ejecución.
• parameter() — indica parámetros arbitrarios utilizados para el paso. Las firmas disponibles de este método son las mismas que para la implementación a nivel de prueba, consulta Pruebas parametrizadas.

Annotated steps

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

public class CucumberSteps {

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

    @Step("Step 1")
    public void step1() {
        subStep1();
        subStep2();
    }

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

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

    @Step("Step 2")
    public void step2() {
        // ...
    }
}

Lambda steps and no-op steps

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

public class CucumberSteps {

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

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

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

Pruebas parametrizadas

• Allure.parameter(String name, T value)
• Allure.parameter(String name, T value, Boolean excluded)
• Allure.parameter(String name, T value, Parameter.Mode mode)
• Allure.parameter(String name, T value, Boolean excluded, Parameter.Mode mode)

Especifica un nombre y un valor de un parámetro que se utilizó durante esta prueba. Consulta Pruebas parametrizadas para más detalles.

WARNING

Allure Cucumber-JVM identifica las pruebas basándose solo en sus nombres y los parámetros de Gherkin. Si tienes varias pruebas que solo difieren en parámetros dinámicos (es decir, las llamadas Allure.parameter()), se tratarán como una única prueba para los fines de historial y reintentos.

Si el argumento excluded se establece en true, Allure no usará el parámetro cuando compare el resultado de la prueba actual con el anterior en el historial. Este argumento solo es utilizado por Allure TestOps.

El argumento mode afecta cómo se mostrará el parámetro en el informe. Las opciones disponibles están definidas en la enumeración Parameter.Mode:

• Parameter.Mode.DEFAULT (igual a no especificar ningún modo) — el parámetro y su valor se mostrarán en una tabla junto con otros parámetros.
• Parameter.Mode.MASKED — el parámetro se mostrará en la tabla, pero su valor estará oculto. Utiliza este modo para contraseñas, tokens y otros parámetros sensibles.
• Parameter.Mode.HIDDEN — el parámetro y su valor no se mostrarán en el informe de la prueba. Sin embargo, ten en cuenta que aún es posible extraer el valor del directorio allure_results si lo publicas.

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("auth_method", "password");
        Allure.parameter("login", login);
        // ...
    }

    @Then("authorize with empty login")
    public void testAuthenticationWithEmptyLogin() {
        Allure.parameter("login", "");
        Allure.parameter("auth_method", "password");
        // ...
    }
}

Adjuntos

Funciones para agregar adjuntos a los resultados de las pruebas.

Adjuntar contenido desde variables

• Allure.addAttachment(String name, String content)
• Allure.addAttachment(String name, String type, String content)
• Allure.addAttachment(String name, String type, String content, String fileExtension)
• Allure.addAttachment(String name, InputStream content)
• Allure.addAttachment(String name, String type, InputStream content, String fileExtension)
• Allure.attachment(String name, String content)
• Allure.attachment(String name, InputStream content)

Agrega content como un adjunto al resultado de la prueba bajo el nombre dado (por defecto se utiliza un string pseudo-aleatorio único).

TIP

Puedes usar datos producidos por cualquier función, no necesariamente leídos desde un archivo real.

Para asegurar que el navegador web del lector muestre los adjuntos correctamente, se recomienda especificar el tipo de cada adjunto. Para ello, pasa el tipo de medio del contenido como type y, opcionalmente, una extensión de archivo como fileExtension. El tipo de medio afecta cómo se mostrará el dato en el informe de la prueba, mientras que la extensión del archivo se añadirá al nombre del archivo cuando el usuario quiera guardar el archivo.

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.");
        Allure.attachment("img.png", Files.newInputStream(Paths.get("/path/img.png")));
    }
}

Generación dinámica de adjuntos

• @Attachment(String value="", String type="", String fileExtension="")

Define una función que devuelva los datos que necesitas adjuntar y anótala con @Attachment. Llama a la función en cualquier punto durante tu prueba para adjuntar los datos al resultado de la prueba.

Los datos se procesarán de la siguiente manera:

• Si el tipo de datos es byte[], Allure lo usará sin modificación.
• Si el tipo de datos es String, Allure lo convertirá a byte[].
• Si los datos son de cualquier otro tipo, Allure llamará al método toString() y luego convertirá la cadena a byte[].

Para asegurarte de que el navegador web del lector muestre los adjuntos correctamente, se recomienda especificar el tipo de cada adjunto. Para hacerlo, pasa el tipo de medio del contenido como type y, opcionalmente, una extensión de archivo como fileExtension. El tipo de medio afecta cómo se mostrará el dato en el reporte de prueba, mientras que la extensión del archivo se agregará al nombre del archivo cuando el usuario desee guardar el archivo.

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

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 {
        // ...
        attachDataTXT();
        attachScreenshotPNG();
    }

    @Attachment(value = "data", type = "text/plain", fileExtension = ".txt")
    public String attachDataTXT() {
        return "This is the file content.";
    }

    @Attachment(value = "screenshot", type = "image/png", fileExtension = ".png")
    public byte[] attachScreenshotPNG() throws IOException {
        return Files.readAllBytes(Paths.get("/path/to/image.png"));
    }
}

INFO

Además, Allure proporciona una forma de generar hilos que agregarán adjuntos a los resultados de las pruebas de forma asincrónica sin bloquear el ejecutor de pruebas. Aunque no se recomienda para la mayoría de los casos, este enfoque puede mejorar las pruebas que de otro modo tendrían que esperar el procesamiento de archivos muy grandes, como videos de más de 1 GB. Consulta el código fuente de Allure.addByteAttachmentAsync() y Allure.addStreamAttachmentAsync() para obtener más información.

Historial de resultados

Inestables

• @Flaky

Indica que la prueba es conocida por ser inestable y puede no tener éxito siempre. Consulta Pruebas inestables.