Referencia de Allure Cucumber.js

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

En la mayoría de los casos, Allure Cucumber.js proporciona dos formas diferentes de usar una característica: la API en tiempo de ejecución y las etiquetas Gherkin.

• API en tiempo de ejecución: usa las funciones de Allure para agregar ciertos datos al resultado de la prueba durante su ejecución. Este enfoque permite construir los datos dinámicamente.

  Ten en cuenta que se recomienda llamar a las funciones de Allure lo más cerca posible al inicio de la prueba. De esta manera, los datos se agregarán incluso si la prueba falla temprano.

• Etiquetas Gherkin: agrega una etiqueta Gherkin de un formato específico (puede configurarse mediante las opciones de labels y links). Cuando se usa este enfoque, los datos se agregarán sin importar cómo se ejecute la prueba.

Metadatos

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

Description

• allure.description(markdown: string): PromiseLike<void>

Establece la descripción de la prueba. Se permite el formato Markdown. Cualquier formato HTML, si está presente, será eliminado por razones de seguridad.

Alternativamente, usa la sintaxis nativa de Gherkin para describir los escenarios.

Runtime API

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.description("This test attempts to log into the website.");
  // ...
});

Gherkin description

Feature: MyFeature

  Scenario: MyTest
  This test attempts to log into the website.

    When something should be done
    Then do something

Owner

• allure.owner(name: string): PromiseLike<void>
• @allure.label.owner:⟨VALUE⟩

Establece el propietario de la prueba.

Runtime API

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.owner("John Doe");
  // ...
});

Gherkin tags

Feature: MyFeature

  @allure.label.owner:JohnDoe
  Scenario: MyTest
    When something should be done
    Then do something

Tag

• allure.tag(name: string): PromiseLike<void>
• allure.tags(...tagsList: string[]): PromiseLike<void>
• @⟨VALUE⟩

Establece las etiquetas de la prueba.

Alternativamente, utiliza la sintaxis nativa de Gherkin para las etiquetas.

Runtime API

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.tag("New UI");
  await allure.tags("Essentials", "Authentication");
  // ...
});

Gherkin tags

Feature: MyFeature

  @NewUI
  @Essentials
  @Authentication
  Scenario: MyTest
    When something should be done
    Then do something

Severity

• allure.severity(name: string): PromiseLike<void>
• @allure.label.severity:⟨VALUE⟩

Establece la severidad de la prueba.

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

Runtime API

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";
import { Severity } from "allure-js-commons";

Then("do something", async () => {
  await allure.severity(Severity.CRITICAL);
  // ...
});

Gherkin tags

Feature: MyFeature

  @allure.label.severity:critical
  Scenario: MyTest
    When something should be done
    Then do something

Label

• allure.label(name: LabelName | string, value: string): PromiseLike<void>
• allure.labels(...labelsList: Label[]): PromiseLike<void>

Establece una etiqueta arbitraria para la prueba. Esta es la implementación subyacente de muchas de las otras funciones de Allure.

Puedes llamar a label() varias veces para crear una lista de valores bajo el nombre dado.

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.label("microservice", "UI");
  // ...
});

ID

• @allure.id:⟨VALUE⟩

Establece el ID de la prueba.

Feature: MyFeature

  @allure.id:123
  Scenario: MyTest
    When something should be done
    Then do something

Link

• allure.link(url: string, name?: string, type?: LinkType | string): PromiseLike<void>
• allure.links(...linksList: Link[]): PromiseLike<void>
• allure.issue(url: string, name?: string): PromiseLike<void>
• allure.tms(url: string, name?: string): PromiseLike<void>

Añade un enlace relacionado con la prueba.

Basado en el type (que puede ser cualquier cadena, por defecto es “link”), Allure intentará cargar una plantilla de enlace correspondiente para procesar la URL, como se define en la opción de configuración links. Si no se encuentra una plantilla para el tipo dado o si el enlace ya representa una URL válida, se deja sin modificar.

El name se usará como el texto del enlace. Si se omite, se usará la URL en su lugar.

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

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.issue("AUTH-123", "Related issue");
  await allure.tms("TMS-456", "Related TMS issue");
  await allure.link("JIRA-777", "Related Jira issue", "jira");
  await allure.link("https://example.com/", "Project website");
  // ...
});

Jerarquía basada en el comportamiento

• allure.epic(name: string): PromiseLike<void>
• allure.feature(name: string): PromiseLike<void>
• allure.story(name: string): PromiseLike<void>
• @allure.label.epic:⟨VALUE⟩
• @allure.label.feature:⟨VALUE⟩
• @allure.label.story:⟨VALUE⟩

Asigna nombres de epic, características o historias de usuario a una prueba, como parte de la jerarquía basada en el comportamiento de Allure.

Runtime API

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.epic("Web interface");
  await allure.feature("Essential features");
  await allure.story("Authentication");
  // ...
});

Gherkin tags

Feature: MyFeature

  @allure.label.epic:WebInterface
  @allure.label.feature:EssentialFeatures
  @allure.label.story:Authentication
  Scenario: MyTest
    When something should be done
    Then do something

Jerarquía basada en suites

• allure.parentSuite(name: string): PromiseLike<void>
• allure.suite(name: string): PromiseLike<void>
• allure.subSuite(name: string): PromiseLike<void>
• @allure.label.parentSuite:⟨VALUE⟩
• @allure.label.suite:⟨VALUE⟩
• @allure.label.subSuite:⟨VALUE⟩

Asigna los nombres de suite principal, suite o sub-suite a una prueba, como parte de la jerarquía basada en suites de Allure.

Runtime API

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.parentSuite("Tests for web interface");
  await allure.suite("Tests for essential features");
  await allure.subSuite("Tests for authentication");
  // ...
});

Gherkin tags

Feature: MyFeature

  @allure.label.parentSuite:TestsForWebInterface
  @allure.label.suite:TestsForEssentialFeatures
  @allure.label.subSuite:TestsForAuthentication
  Scenario: MyTest
    When something should be done
    Then do something

Pasos de prueba

• allure.step<T = void>(name: string, body: (context: StepContext) => T | PromiseLike<T>): PromiseLike<T>
• allure.logStep(name: string, status?: Status, error?: Error): PromiseLike<void>

Define un sub-paso de prueba con el nombre proporcionado.

La función step() es asincrónica y acepta una función anónima asincrónica como su segundo argumento. Observa las palabras clave async y await en el ejemplo a continuación.

La función anónima puede aceptar ninguno o un solo argumento de la clase StepContext. Este objeto proporciona los siguientes métodos:

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

Para crear un paso sin cuerpo, llama a la función logStep() que acepta un nombre y, opcionalmente, un estado del paso y un objeto de error.

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";
import { Status } from "allure-js-commons";

Then("do something", async () => {
  await allure.step("Step 1", async () => {
    await allure.step("Sub-step 1", async (ctx) => {
      await ctx.parameter("foo", "1");
      // ...
    });
    await allure.step("Sub-step 2", async (ctx) => {
      await ctx.parameter("foo", "2");
      // ...
    });
  });
  await allure.logStep("Step 2", Status.SKIPPED);
});

Pruebas parametrizadas

• allure.parameter(name: string, value: string, options?: ParameterOptions): PromiseLike<void>

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

El argumento options, si se proporciona, debe ser un objeto con dos propiedades opcionales excluded y mode.

• Si excluded se establece en true, Allure no utilizará el parámetro al comparar el resultado de la prueba actual con el anterior en el historial. Consulta Trampa común: los reintentos de una prueba se muestran como pruebas separadas.

• El mode afecta cómo se mostrará el parámetro en el informe. Las opciones disponibles son:

  • "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.
  • "masked" — el parámetro se mostrará en la tabla, pero su valor estará oculto. Usa este modo para contraseñas, tokens y otros parámetros sensibles.
  • "hidden" — el parámetro y su valor no se mostrarán en el informe de la prueba.

  Ten en cuenta que, incluso cuando uses el modo "masked" o "hidden", aún es posible extraer el valor del directorio allure_results si lo publicas.

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";

Then("do something", async () => {
  await allure.parameter("login", "johndoe");
  await allure.parameter("time", new Date().toUTCString(), { excluded: true });
  // ...
});

Archivos adjuntos

• allure.attachment(name: string, content: Buffer | string, options: ContentType | string | AttachmentOptions): PromiseLike<void>
• allure.attachmentPath(name: string, path: string, options: ContentType | string | Omit<AttachmentOptions, "encoding">): PromiseLike<void>

Agrega un archivo adjunto al resultado de la prueba bajo el nombre dado. Pasa ya sea el contenido o la ruta desde la cual se leerán los datos.

Se pueden pasar opciones adicionales en un objeto como tercer parámetro.

• Las opciones contentType y fileExtension controlan el tipo de medio del contenido y la extensión del archivo que se utilizará si un usuario descarga el archivo adjunto desde el informe de prueba. Puedes especificar ambas opciones o solo especificar el tipo contentType y dejar que Allure deduzca automáticamente la extensión fileExtension apropiada. En cualquiera de los casos, el tipo de medio puede ser un valor de la enumeración ContentType o cualquier cadena.

• La opción encoding especifica cómo debe guardarse el texto adjunto. Solo se aplica cuando se proporciona el contenido como una cadena, y su valor predeterminado es "utf-8".

Si el tercer argumento no es un objeto, se interpreta como una opción única contentType.

import { Then } from "@cucumber/cucumber";
import * as allure from "allure-js-commons";
import { ContentType } from "allure-js-commons";

Then("do something", async () => {
  // ...

  await allure.attachment("Text file", "This is the file content.", ContentType.TEXT);

  await allure.attachmentPath("Screenshot", "/path/to/image.png", {
    contentType: ContentType.PNG,
    fileExtension: "png",
  });
});