Configuración de Allure Mocha

Existen dos formas de configurar Allure Mocha: usando un script de ejecución y a través de la configuración de Mocha. La primera requiere algunos pasos adicionales, pero admite todas las opciones de configuración de Allure Mocha. La segunda es más fácil de usar, pero solo admite un conjunto limitado de opciones.

Usando un script de ejecución

Crea un script de ejecución y pasa las propiedades reporter y reporterOptions a una instancia de Mocha. Luego, usa la instancia configurada para ejecutar las pruebas.

Aquí tienes ejemplos de configuraciones ESM y CommonJS:

runner.mjs

import { Status } from "allure-js-commons";
import { glob } from "glob";
import Mocha from "mocha";
import * as os from "node:os";

const mocha = new Mocha({
  reporter: "allure-mocha",
  reporterOptions: {
    resultsDir: "allure-results",
    extraReporters: "spec",
    links: {
      issue: {
        nameTemplate: "Issue #%s",
        urlTemplate: "https://issues.example.com/%s",
      },
      tms: {
        nameTemplate: "TMS #%s",
        urlTemplate: "https://tms.example.com/%s",
      },
      jira: {
        urlTemplate: (v) => `https://jira.example.com/browse/${v}`,
      },
    },
    categories: [
      {
        name: "foo",
        messageRegex: "bar",
        traceRegex: "baz",
        matchedStatuses: [Status.FAILED, Status.BROKEN],
      },
    ],
    environmentInfo: {
      os_platform: os.platform(),
      os_release: os.release(),
      os_version: os.version(),
      node_version: process.version,
    },
    globalLabels: [{ name: "layer", value: "api" }],
  },

  /* Otras opciones de Mocha... */
});

glob.sync("test/**/*.spec.{m,c,}js").forEach((file) => mocha.addFile(file));
await mocha.loadFilesAsync();
mocha.run((failures) => process.exit(failures));

runner.cjs

const { Status } = require("allure-js-commons");
const { glob } = require("glob");
const Mocha = require("mocha");
const os = require("node:os");

const mocha = new Mocha({
  reporter: "allure-mocha",
  reporterOptions: {
    resultsDir: "allure-results",
    extraReporters: "spec",
    links: {
      issue: {
        nameTemplate: "Issue #%s",
        urlTemplate: "https://issues.example.com/%s",
      },
      tms: {
        nameTemplate: "TMS #%s",
        urlTemplate: "https://tms.example.com/%s",
      },
      jira: {
        urlTemplate: (v) => `https://jira.example.com/browse/${v}`,
      },
    },
    categories: [
      {
        name: "foo",
        messageRegex: "bar",
        traceRegex: "baz",
        matchedStatuses: [Status.FAILED, Status.BROKEN],
      },
    ],
    environmentInfo: {
      os_platform: os.platform(),
      os_release: os.release(),
      os_version: os.version(),
      node_version: process.version,
    },
    globalLabels: [{ name: "layer", value: "api" }],
  },

  /* Otras opciones de Mocha... */
});

glob.sync("test/**/*.spec.{m,c,}js").forEach((file) => mocha.addFile(file));
mocha.loadFilesAsync().then(() => {
  mocha.run((failures) => process.exit(failures));
});

INFO

Los ejemplos utilizan el paquete glob para ubicar y cargar los archivos de prueba. Es posible que necesites ajustar el patrón según la estructura de tu proyecto.

Ejecuta el script para correr las pruebas:

npm, pnpm

node ./runner.mjs

yarn

yarn node ./runner.mjs

Usando la configuración de Mocha

Puedes usar un archivo de configuración de Mocha o la CLI para configurar Allure Mocha. Ten en cuenta que solo se admiten resultsDir y extraReporters de esa forma.

.mocharc.json

{
  "reporter": "allure-mocha",
  "reporterOptions": ["resultsDir=allure-results", "extraReporters=spec"]
}

package.json

{
  // ...
  "mocha": {
    "reporter": "allure-mocha",
    "reporterOptions": ["resultsDir=allure-results", "extraReporters=spec"]
  }
}

.mocharc.yaml

reporter: allure-mocha
reporterOptions:
  - "resultsDir=allure-results"
  - "extraReporters=spec"

.mocharc.cjs

module.exports = {
  reporter: "allure-mocha",
  reporterOptions: ["resultsDir=allure-results", "extraReporters=spec"],
};

CLI

npx mocha -R "allure-mocha" -O "resultsDir=allure-results,extraReporters=spec"

Opciones de configuración

INFO

Esta sección describe las opciones de configuración para Allure Mocha 3.0 y versiones posteriores. Para versiones más antiguas, puedes consultar este readme.

resultsDir

Ruta al directorio donde Allure Mocha guardará los resultados de las pruebas, consulta Cómo funciona. Si el directorio no existe, se creará. El valor predeterminado es allure-results.

WARNING

La ruta no puede contener los caracteres = y , si se proporciona a través de un archivo de configuración de Mocha o la CLI. Usa un script de ejecución si necesitas superar esta limitación.

extraReporters

Uno o más reporteros de Mocha que se ejecutarán junto con Allure Mocha. En su forma más básica, toma una sola cadena, que es el nombre o la ruta del módulo del reportero:

Built-in reporter

npx mocha -R allure-mocha -O extraReporters=spec

Local reporter

npx mocha -R allure-mocha -O extraReporters=./reporter.cjs

Si necesitas pasar opciones al reportero, usa la siguiente sintaxis (solo es compatible en un script de ejecución):

const mocha = new Mocha({
  reporter: "allure-mocha",
  reporterOptions: {
    extraReporters: ["json", { output: "results.json" }],
  },
});

Puedes habilitar más de un reportero adicional:

const mocha = new Mocha({
  reporter: "allure-mocha",
  reporterOptions: {
    extraReporters: ["spec", ["json", { output: "results.json" }]],
  },
});

links

Un mapeo de plantillas que se pueden usar para construir URLs completas a partir de identificadores cortos.

Para cada tipo de enlace (ver allure.link()), puedes especificar lo siguiente:

• nameTemplate — una plantilla o una función para generar el nombre del enlace cuando no se proporciona.
• urlTemplate — una plantilla o una función para generar la dirección del enlace cuando no se proporciona.

Las plantillas pueden ser cadenas (con %s donde debe colocarse el identificador) o funciones (que aceptan el identificador y devuelven la URL).

Por ejemplo, con la configuración anterior, await allure.issue("123") producirá un enlace con el nombre Issue #123 y la dirección https://issues.example.com/. Allure mostrará el enlace con el ícono apropiado para el tipo issue.

INFO

Esta opción solo se puede proporcionar a través de un script de ejecución.

categories

Define categorías personalizadas que se usarán para distinguir los resultados de las pruebas según sus errores; consulta Categorías.

Esta configuración es un arreglo, donde cada elemento es un objeto que representa una categoría personalizada. Los objetos pueden tener las siguientes propiedades:

• name — el nombre de la categoría.
• messageRegex — una expresión regular con la que debería coincidir el mensaje del resultado de la prueba.
• traceRegex — una expresión regular con la que debería coincidir el rastreo del resultado de la prueba.
• matchedStatuses — un arreglo de estados que el resultado de la prueba debe cumplir.
• flaky — si el resultado de la prueba debe ser marcado como inestable.

INFO

Esta opción solo se puede proporcionar a través de un script de ejecución.

environmentInfo

Pares de clave-valor que se mostrarán en la página principal del reporte, consulta Información del entorno.

INFO

Esta opción solo se puede proporcionar a través de un script de ejecución.

globalLabels

Etiquetas aplicadas a todos los resultados de las pruebas en la ejecución. Útil para etiquetar todos los resultados con una capa, equipo o identificador de entorno sin necesidad de repetirlo en cada prueba.

Puede proporcionarse como un arreglo de objetos de etiqueta { name, value }:

const mocha = new Mocha({
  reporter: "allure-mocha",
  reporterOptions: {
    globalLabels: [
      { name: "layer", value: "api" },
      { name: "team", value: "backend" },
    ],
  },
});

O como un objeto simple que mapea nombres de etiqueta a valores. Un nombre puede corresponder a una sola cadena o a un arreglo de cadenas:

const mocha = new Mocha({
  reporter: "allure-mocha",
  reporterOptions: {
    globalLabels: {
      layer: "api",
      team: "backend",
    },
  },
});

INFO

Esta opción solo se puede proporcionar a través de un script de ejecución.