Referencia de Allure AVA

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

En la mayoría de los casos, Allure AVA ofrece 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 prueba durante su ejecución. Este enfoque permite construir los datos de forma dinámica.

  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 @allure.) en el nombre de la prueba. Allure AVA la extraerá y actualizará los datos del resultado de prueba en consecuencia. Al usar este enfoque, se garantiza que los datos se agreguen independientemente de cómo se ejecute la prueba.

  Una etiqueta de metadatos consiste en un nombre y un valor separados por : o =. Si el valor debe contener espacios, envuélvelo entre comillas simples, dobles o invertidas, por ejemplo: @allure.label.owner:"John Doe".

Metadatos

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

Título

• allure.displayName(name: string): PromiseLike<void>

Establece el título de la prueba.

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

test("Test Authentication", async (t) => {
  await allure.displayName("¡Autenticación de prueba!");
  // ...
  t.pass();
});

Descripción

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

Establece la descripción de la prueba.

Usa description() para contenido en Markdown. Por motivos de seguridad, cualquier formato HTML en él no se renderiza: dependiendo de la versión de Allure Report, las etiquetas se eliminan o se muestran como texto plano.

Usa descriptionHtml() cuando necesites proporcionar HTML sin procesar directamente en lugar de Markdown.

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

test("Test Authentication", async (t) => {
  await allure.description("Esta prueba intenta iniciar sesión en el sitio web.");
  // ...
  t.pass();
});

Propietario

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

Establece el propietario de la prueba.

API de tiempo de ejecución

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

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

API de metadatos

import test from "ava";

test("Test Authentication @allure.label.owner:JohnDoe", (t) => {
  // ...
  t.pass();
});

Tag

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

Establece los tags de la prueba.

API de tiempo de ejecución

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

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

API de metadatos

import test from "ava";

test("Test Authentication @allure.label.tag:WebInterface @allure.label.tag:Authentication", (t) => {
  // ...
  t.pass();
});

Severidad

• 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".

API de tiempo de ejecución

import * as allure from "allure-js-commons";
import { Severity } from "allure-js-commons";
import test from "ava";

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

API de metadatos

import test from "ava";

test("Test Authentication @allure.label.severity:critical", (t) => {
  // ...
  t.pass();
});

Etiqueta

• 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 de muchas otras funciones de Allure.

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

API de tiempo de ejecución

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

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

API de metadatos

import test from "ava";

test("Test Authentication @allure.label.microservice:UI", (t) => {
  // ...
  t.pass();
});

ID

• allure.allureId(value: string): PromiseLike<void>
• @allure.id:⟨VALUE⟩

Establece el ID de la prueba. El ID se utiliza para el filtrado de planes de pruebas en Allure TestOps.

API de tiempo de ejecución

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

test("Test Authentication", async (t) => {
  await allure.allureId("123");
  // ...
  t.pass();
});

API de metadatos

import test from "ava";

test("Test Authentication @allure.id:123", (t) => {
  // ...
  t.pass();
});

Enlace

• 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>
• @allure.link.⟨TYPE⟩:⟨VALUE⟩

Agrega un enlace relacionado con la prueba.

Si el url no es una URL completa (por ejemplo, solo es un identificador de issue), Allure intentará construir la dirección completa a partir de una plantilla de enlace que corresponde al type (que puede ser cualquier cadena y por defecto es "link"), según lo definido por la opción de configuración links. Si no se encuentra una plantilla para el tipo dado, o el valor ya es una URL completa, se deja sin modificar.

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

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

API de tiempo de ejecución

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

test("Test Authentication", async (t) => {
  await allure.issue("AUTH-123", "Issue relacionado");
  await allure.tms("TMS-456", "Issue TMS relacionado");
  await allure.link("JIRA-777", "Issue Jira relacionado", "jira");
  await allure.link("https://example.com/", "Sitio web del proyecto");
  // ...
  t.pass();
});

API de metadatos

import test from "ava";

test("Test Authentication @allure.link.issue:AUTH-123 @allure.link.tms:TMS-456", (t) => {
  // ...
  t.pass();
});

Jerarquía basada en 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 epics, features o historias de usuario a una prueba, como parte de la jerarquía basada en comportamiento de Allure.

API de tiempo de ejecución

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

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

API de metadatos

import test from "ava";

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

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

Por defecto, Allure AVA no asigna etiquetas de suite a las pruebas; la agrupación predeterminada en la vista de árbol del reporte se basa en la ruta del archivo de prueba. Usa estas funciones para organizar las pruebas en una jerarquía de suites explícita.

API de tiempo de ejecución

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

test("Test Authentication", async (t) => {
  await allure.parentSuite("Pruebas para la interfaz web");
  await allure.suite("Pruebas para funcionalidades esenciales");
  await allure.subSuite("Pruebas para autenticación");
  // ...
  t.pass();
});

API de metadatos

import test from "ava";

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

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 paso o subpaso de prueba con el name dado.

La función step() acepta una función anónima asíncrona como segundo argumento. La función anónima puede aceptar ningún argumento o un solo argumento de 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 para el paso. Las firmas disponibles de este método son similares a la implementación a nivel de prueba, ver Pruebas parametrizadas.

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

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

test("Test Authentication", async (t) => {
  await allure.step("Paso 1", async () => {
    await allure.step("Subpaso 1", async (ctx) => {
      await ctx.parameter("foo", "1");
      // ...
    });
    await allure.step("Subpaso 2", async (ctx) => {
      await ctx.parameter("foo", "2");
      // ...
    });
  });
  await allure.logStep("Paso 2", Status.SKIPPED);
  t.pass();
});

Hooks

Los hooks de AVA declarados con test.before(), test.beforeEach(), test.after(), y test.afterEach() (incluyendo sus variantes .always) se reportan como los fixtures de setup y limpieza de la prueba, incluyendo sus estados y duraciones. Si un hook lanza una excepción, se muestra como un fixture fallido o roto, y las pruebas que bloquea se reportan como rotas.

Puedes usar las funciones de Allure dentro de los hooks:

• Las etiquetas, enlaces y parámetros agregados en los hooks before() y beforeEach() se aplican a los resultados de prueba para los que se ejecutan. Los metadatos agregados en los hooks after() y afterEach() no afectan los resultados de prueba.
• Los pasos y adjuntos creados en un hook se muestran dentro del fixture correspondiente.

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

test.beforeEach(async () => {
  await allure.parameter("database", "postgres");
});

test("Test Authentication", (t) => {
  // ...
  t.pass();
});

Pruebas parametrizadas

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

El patrón de pruebas parametrizadas en AVA se puede implementar ejecutando un test() dentro de un bucle. Cada iteración se trata como una ejecución de prueba separada por Allure Report.

Los valores que distinguen una iteración de otra se llaman parámetros de prueba. Para mostrar el valor de un parámetro en el reporte de prueba, pásalo a la función parameter().

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 usará el parámetro al comparar el resultado de prueba actual con los anteriores en el historial. Ver Error común: los reintentos de una prueba se muestran como pruebas separadas.

• El mode afecta cómo se mostrará el parámetro en el reporte. 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" — el parámetro y su valor no se mostrarán en el reporte de prueba.

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

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

for (const login of ["johndoe", "[email protected]"]) {
  test(`Test Authentication as ${login}`, async (t) => {
    await allure.parameter("login", login);
    await allure.parameter("time", new Date().toUTCString(), { excluded: true });
    // ...
    t.pass();
  });
}

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 adjunto al resultado de prueba bajo el name dado. Pasa el content directamente o el path desde el cual se leerán los datos.

El argumento options controla el tipo de medio del contenido y la extensión de archivo que se usará si un usuario descarga el adjunto desde el reporte de prueba. Puedes especificar ambas opciones en un objeto (como se muestra para el adjunto de imagen abajo) o solo especificar el tipo de medio y dejar que Allure deduzca la extensión de archivo adecuada automáticamente (como se muestra para el adjunto de texto abajo). 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";
import test from "ava";

test("Test Authentication", async (t) => {
  // ...

  await allure.attachment(
    "Archivo de texto",
    "Este es el contenido del archivo.",
    ContentType.TEXT,
  );

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

  t.pass();
});

Además, cualquier mensaje registrado con el t.log() integrado de AVA se agrega automáticamente al resultado de prueba (o al fixture correspondiente, cuando se registra en un hook) como un adjunto de texto llamado "AVA logs".

Adjuntos globales y errores globales

• allure.globalAttachment(name: string, content: Buffer | string, options: ContentType | string | AttachmentOptions): PromiseLike<void>
• allure.globalAttachmentPath(name: string, path: string, options: ContentType | string | Omit<AttachmentOptions, "encoding">): PromiseLike<void>
• allure.globalError(details: StatusDetails): PromiseLike<void>

Adjunta datos o reporta un error que se relaciona con la ejecución de prueba en su conjunto, en lugar de con una prueba específica. Llama a estas funciones fuera de cualquier prueba o hook — por ejemplo, en el nivel superior de un archivo de prueba.

Las funciones globalAttachment() y globalAttachmentPath() aceptan los mismos argumentos que sus equivalentes a nivel de prueba, ver Adjuntos.

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

await allure.globalAttachment(
  "Configuración de ejecución",
  JSON.stringify({ region: "eu-west-1" }),
  ContentType.JSON,
);

test("Test Authentication", (t) => {
  // ...
  t.pass();
});

API síncrona

Todas las funciones en esta referencia son asíncronas y devuelven un PromiseLike. Si tu prueba utiliza helpers síncronos o integraciones de matchers que no soportan async, importa desde allure-js-commons/sync en su lugar:

import * as allure from "allure-js-commons/sync";
import test from "ava";

test("Test Authentication", (t) => {
  allure.step("verificar resultado", () => {
    allure.parameter("mode", "sync");
  });
  t.pass();
});

La fachada síncrona es estrictamente síncrona: step() debe completarse de forma síncrona y no debe devolver un Promise.