Referencia de Allure Bun

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

En la mayoría de los casos, Allure Bun ofrece dos formas diferentes de usar una función: la API de Runtime y la API de Metadatos.

API de Runtime: usa 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 al inicio de la prueba. De esta manera, los datos se agregarán incluso si la prueba falla temprano.
API de Metadatos: agrega un tag de metadatos (que comienza con @) en el nombre de la prueba. Allure Bun lo extraerá y actualizará los datos del resultado de prueba en consecuencia. Al usar este enfoque, se garantiza que los datos se agregarán independientemente de cómo se ejecute la prueba.

Limitaciones conocidas

Siempre coloca las pruebas dentro de bloques describe(). Mezclar llamadas a test() en el nivel raíz con bloques describe() en el mismo archivo produce el error allure-bun does not support concurrent tests. Esta es una limitación conocida: Bun difiere los callbacks de describe(), lo que hace que la cola de registro de allure-bun diverja del orden de ejecución — el mismo mecanismo de ordenamiento que usa para evitar la ejecución concurrente de pruebas. test.skip y test.todo están exentos. Los archivos que contienen solo pruebas en el nivel raíz sin bloques describe() tampoco se ven afectados.

.only (tanto en test como en describe) no está soportado por la misma razón: cuando solo se ejecuta una prueba, la cola de allure-bun espera la primera prueba registrada, no la prueba con .only, y lanza el mismo error.

API Síncrona

Todas las funciones en esta referencia son asíncronas y devuelven un PromiseLike. Si tu prueba usa 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 { describe, test } from "bun:test";

describe("example", () => {
  test("Test Authentication", () => {
    allure.step("check result", () => {
      allure.parameter("mode", "sync");
    });
  });
});

La fachada síncrona es estrictamente síncrona: step() debe completarse sincrónicamente y no debe devolver un Promise.

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 { describe, test } from "bun:test";

describe("example", () => {
  test("Test Authentication", async () => {
    await allure.displayName("Test Authentication!");
    // ...
  });
});

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. Cualquier formato HTML, si está presente, será eliminado por razones de seguridad.

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

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

Propietario

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

Establece el propietario de la prueba.

Runtime APIMetadata API

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

import { describe, test } from "bun:test";

describe("example", () => {
  test("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 APIMetadata API

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

import { describe, test } from "bun:test";

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

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

Runtime APIMetadata API

import * as allure from "allure-js-commons";
import { Severity } from "allure-js-commons";
import { describe, test } from "bun:test";

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

import { describe, test } from "bun:test";

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

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 arreglo de valores bajo el nombre dado.

Runtime APIMetadata API

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

import { describe, test } from "bun:test";

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

ID

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

Establece el ID de la prueba.

Runtime APIMetadata API

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

import { describe, test } from "bun:test";

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

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>

Agrega un enlace relacionado con la prueba.

Según el type (que puede ser cualquier cadena, por defecto "link"), Allure intentará cargar una plantilla de enlace correspondiente para procesar la URL, según lo definido por la opción de configuración links. Si no se encuentra ninguna plantilla para el tipo dado, la URL se deja sin modificar.

Si la URL no comienza con "http" o "https", se procesará según la opción de configuración links.

El name se usará como el 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";
import { describe, test } from "bun:test";

describe("example", () => {
  test("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 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 para una prueba, como parte de la jerarquía basada en comportamiento de Allure.

Runtime APIMetadata API

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

import { describe, test } from "bun:test";

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

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

Esto reemplaza los niveles correspondientes de la jerarquía de suites predeterminada, que Allure Bun crea en función de los argumentos de describe().

Runtime APIMetadata API

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

import { describe, test } from "bun:test";

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

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 como segundo argumento, que puede ser síncrona o asíncrona. La función anónima puede aceptar ningún argumento o un único argumento de tipo StepContext. Este objeto proporciona los siguientes métodos:

displayName() — reemplaza el nombre del paso durante su ejecución.
parameter(name: string, value: string, mode?: "default" | "masked" | "hidden") — indica parámetros arbitrarios usados para el paso. El tercer argumento es el modo de visualización (una cadena simple, no un objeto ParameterOptions). A diferencia del parameter() de toda la prueba, los parámetros de paso no soportan la opción excluded.

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 { describe, test } from "bun:test";

describe("example", () => {
  test("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>

El patrón de pruebas parametrizadas en Bun puede implementarse llamando a la función integrada test.each() o ejecutando un test() dentro de un bucle. En ambos casos, Allure Report reconoce cada iteración como una ejecución de prueba separada.

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. 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 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 del directorio allure-results si lo publicas.

Using test()Using test.each()

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

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

import * as allure from "allure-js-commons";
import { describe, test } from "bun:test";

describe("example", () => {
  test.each(["johndoe", "[email protected]"])("Test Authentication as %s", async (login) => {
    await allure.parameter("login", login);
    await allure.parameter("time", new Date().toUTCString(), { excluded: true });
    // ...
  });
});

Adjuntos

allure.attachment(name: string, content: Buffer | Uint8Array | 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 la path desde la cual se leerán los datos.

El argumento options controla el tipo de medio del contenido y la extensión de nombre 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 a continuación) o simplemente especificar el tipo de medio y dejar que Allure deduzca automáticamente la extensión de nombre 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";
import { describe, test } from "bun:test";

describe("example", () => {
  test("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",
    });
  });
});

Instalación y Actualización

Instalación y Actualización

Referencia de Allure Bun

API Síncrona

Metadatos

Título

Descripción

Propietario

Tag

Severidad

Etiqueta

ID

Enlace

Jerarquía basada en comportamiento

Jerarquía basada en suites

Pasos de prueba

Pruebas parametrizadas

Adjuntos

Powered by

Suscríbete a nuestro boletín

Allure TestOps

Compañía

Referencia de Allure Bun ​

API Síncrona ​

Metadatos ​

Título ​

Descripción ​

Propietario ​

Tag ​

Severidad ​

Etiqueta ​

ID ​

Enlace ​

Jerarquía basada en comportamiento ​

Jerarquía basada en suites ​

Pasos de prueba ​

Pruebas parametrizadas ​

Adjuntos ​

Powered by

Suscríbete a nuestro boletín

Allure TestOps

Compañía

Referencia de Allure Bun

API Síncrona

Metadatos

Título

Descripción

Propietario

Tag

Severidad

Etiqueta

ID

Enlace

Jerarquía basada en comportamiento

Jerarquía basada en suites

Pasos de prueba

Pruebas parametrizadas

Adjuntos