Referencia de Allure Mocha

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

En la mayoría de los casos, Allure Mocha proporciona dos formas diferentes de usar una funcionalidad: la API de tiempo de ejecución y la API de metadatos.

• API de tiempo de ejecución: utiliza 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 del inicio de la prueba. De esta manera, los datos se agregarán incluso si la prueba falla temprano.

• API de metadatos: agrega una etiqueta de metadatos (que comienza con @) en el nombre de la prueba. Allure Mocha la extraerá y actualizará los datos del resultado de la prueba en consecuencia. Al usar este enfoque, los datos se agregarán independientemente de cómo se ejecute la prueba.

Metadatos

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

Descripción

• 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 motivos de seguridad.

import * as allure from "allure-js-commons";

it("Test Authentication", async () => {
  await allure.description("This test attempts to log into the website.");
  // ...
});

Owner

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

Establece el propietario de la prueba.

Runtime API

import * as allure from "allure-js-commons";

it("Test Authentication", async () => {
  await allure.owner("John Doe");
  // ...
});

Metadata API

it("Test Authentication @allure.label.owner:JohnDoe", async () => {
  // ...
});

Tag

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

Establece los tags de la prueba.

Runtime API

import * as allure from "allure-js-commons";

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

Metadata API

it(
  "Test Authentication" +
    " @allure.label.tag:NewUI" +
    " @allure.label.tag:Essentials" +
    " @allure.label.tag:Authentication",
  async () => {
    // ...
  },
);

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 * as allure from "allure-js-commons";
import { Severity } from "allure-js-commons";

it("Test Authentication", async () => {
  await allure.severity(Severity.CRITICAL);
  // ...
});

Metadata API

it("Test Authentication @allure.label.severity:critical", async () => {
  // ...
});

Label

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

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

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

Runtime API

import * as allure from "allure-js-commons";

it("Test Authentication", async () => {
  await allure.label("microservice", "UI");
  // ...
});

Metadata API

it("Test Authentication @allure.label.microservice:UI", async () => {
  // ...
});

ID

• @allure.id:⟨VALUE⟩

Establece el ID de la prueba.

import * as allure from "allure-js-commons";

it("Test Authentication @allure.id:123", async () => {
  // ...
});

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>

Agrega un enlace relacionado con la prueba.

Basándose en el type (que puede ser cualquier cadena, por defecto “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 ninguna plantilla para el tipo dado o si el enlace ya representa una URL válida, se dejará sin modificar.

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

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

import * as allure from "allure-js-commons";

it("Test Authentication", 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 épicas, funcionalidades o historias de usuario para una prueba, como parte de la jerarquía basada en comportamiento de Allure.

Runtime API

import * as allure from "allure-js-commons";

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

Metadata API

it(
  "Test Authentication" +
    " @allure.label.epic:WebInterface" +
    " @allure.label.feature:EssentialFeatures" +
    " @allure.label.story:Authentication",
  async () => {
    // ...
  },
);

Jerarquía basada en la suite

• 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 padre, suite o sub-suite para una prueba, como parte de la jerarquía basada en suites de Allure.

Runtime API

import * as allure from "allure-js-commons";

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

Metadata API

it(
  "Test Authentication" +
    " @allure.label.parentSuite:TestsForWebInterface" +
    " @allure.label.suite:TestsForEssentialFeatures" +
    " @allure.label.subSuite:TestsForAuthentication",
  async () => {
    // ...
  },
);

Pasos de prueba

Define un paso de prueba con el name dado.

Hay dos formas de definir un paso:

• Pasos con función lambda

  Escribe un paso de prueba en una función y pásala a allure.step(). Si la función devuelve un valor, allure.step() lo devolverá sin modificaciones, y no afectará el informe. Si devuelve una promesa, será esperada y resuelta.

  La función puede aceptar o bien ningún argumento, o un único objeto del tipo StepContext. Este objeto proporciona los siguientes métodos:

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

• Pasos sin operación (No-op steps)

  Si llamas a allure.logStep(), Allure añadirá al informe un paso sin operación (no-op). Esto permite un informe estilo registro dentro de una prueba o de un paso más grande. Un paso sin operación finaliza inmediatamente después de comenzar y no puede tener subpasos ni parámetros.

  El segundo argumento opcional indica el estado que se mostrará para el paso en el informe. Los valores permitidos son: Status.PASSED (el valor por defecto), Status.FAILED, Status.BROKEN y Status.SKIPPED.

  El tercer argumento opcional es un objeto de tipo Error. Cuando se proporciona, los datos de este objeto se mostrarán en un mensaje dentro del paso.

import * as allure from "allure-js-commons";
import { Status } from "allure-js-commons";

it("Test Authentication", 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 name y un value 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 está establecido en true, Allure no usará el parámetro al comparar el resultado actual de la prueba con el anterior en el historial. Consulta Problema 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 que 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" — ni el parámetro ni su valor se mostrarán en el informe de la prueba.

  Nota que, incluso cuando uses el modo "masked" o "hidden", es posible extraer el valor del directorio allure_results si lo publicas.

import * as allure from "allure-js-commons";

for (const login of ["johndoe", "[email protected]"]) {
  it(`Test Authentication as ${login}`, async () => {
    await allure.parameter("login", login);
    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>

Añade un adjunto al resultado de la prueba bajo el name proporcionado. Pasa ya sea el content o el path desde donde se leerán los datos.

El argumento options controla el tipo de medio del contenido y la extensión del archivo que se usará si un usuario descarga el adjunto desde el informe de la prueba. Puedes especificar ambas opciones en un objeto (como se muestra para el adjunto de imagen a continuación) o simplemente especificar el tipo de medio y dejar que Allure deduzca automáticamente la extensión de archivo apropiada (como se muestra para el adjunto de texto a continuación). En cualquier caso, el tipo de medio puede ser un valor de la enumeración ContentType o cualquier cadena.

import * as allure from "allure-js-commons";
import { ContentType } from "allure-js-commons";

it("Test Authentication", 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",
  });
});