Configurar Allure Report 3

Allure Report 3 utiliza un único archivo de configuración para gestionar todos los ajustes de tu reporte. Puedes crear este archivo en formato dinámico (JavaScript) o estático (JSON/YAML). Los archivos de configuración dinámicos admiten código ejecutable, importaciones y lógica condicional, mientras que los archivos estáticos proporcionan un formato más simple con valores fijos.

Puedes cargar valores de configuración desde variables de entorno y sobreescribirlos mediante opciones de comando CLI, lo que te brinda flexibilidad en cómo gestionas los ajustes en diferentes entornos y flujos de trabajo.

Las características avanzadas de Allure 3 se implementan como un sistema de plugins. Puedes configurar todos los plugins en el mismo archivo de configuración.

Qué Cubre Este Documento

Estructura y sintaxis del archivo de configuración
Todas las opciones de configuración principales
Agregar plugins y configurar múltiples tipos de reportes
Características avanzadas como seguimiento de historial, resoluciones y métricas de rendimiento
Publicación de reportes y acceso al historial vía Allure Report Storage
Comandos CLI y sobreescrituras

1. Conceptos Básicos del Archivo de Configuración

Nombre y Ubicación del Archivo

Allure CLI busca archivos de configuración en el directorio de trabajo actual, en el siguiente orden (el primer archivo descubierto se analiza para los parámetros de configuración):

allurerc.js
allurerc.mjs
allurerc.cjs
allurerc.json
allurerc.yaml
allurerc.yml

Formato y Sintaxis del Archivo

Allure 3 admite tanto archivos de configuración dinámicos (.mjs, .cjs, .js) como estáticos (.json, .yml, .yaml).

Los archivos de configuración estáticos tienen funcionalidad limitada (sin importaciones, sin lectura de variables de entorno, sin código ejecutable) pero funcionan con una instalación global de Allure Report 3.

Los archivos de configuración dinámicos están escritos en JavaScript. Requieren que Allure 3 esté instalado localmente en tu proyecto y puedes usar lo siguiente en ellos:

Variables de entorno
Lógica condicional
Valores calculados
Utilidades importadas

Ejemplos de Archivos de Configuración Dinámicos y Estáticos

allurerc.mjsallurerc.jsonallurerc.yaml

javascript

import { defineConfig } from "allure";

export default defineConfig({
  name: "Allure Report",
  output: "./allure-report",
  historyPath: "./history.jsonl",
  qualityGate: {
    rules: [
      {
        maxFailures: 5,
        fastFail: true,
      },
    ],
  },
  plugins: {
    awesome: {
      options: {
        reportName: "HelloWorld",
        singleFile: false,
        reportLanguage: "en",
        open: false,
        publish: true,
      },
    },
    allure2: {
      options: {
        reportName: "HelloWorld",
        singleFile: false,
        reportLanguage: "en",
      },
    },
    classic: {
      options: {
        reportName: "HelloWorld",
        singleFile: false,
        reportLanguage: "en",
      },
    },
    dashboard: {
      options: {
        singleFile: false,
        reportName: "HelloWorld-Dashboard",
        reportLanguage: "en",
      },
    },
    csv: {
      options: {
        fileName: "allure-report.csv",
      },
    },
    log: {
      options: {
        groupBy: "none",
      },
    },
  },
  variables: {
    env_variable: "unknown",
  },
  environments: {
    foo: {
      variables: {
        env_variable: "foo",
        env_specific_variable: "foo",
      },
      matcher: ({ labels }) => labels.some(({ name, value }) => name === "env" && value === "foo"),
    },
    bar: {
      variables: {
        env_variable: "bar",
        env_specific_variable: "bar",
      },
      matcher: ({ labels }) => labels.some(({ name, value }) => name === "env" && value === "bar"),
    },
  },
});

json

{
  "name": "Allure Report",
  "output": "./allure-report",
  "historyPath": "./history.jsonl",
  "qualityGate": {
    "rules": [
      {
        "maxFailures": 5,
        "fastFail": true
      }
    ]
  },
  "plugins": {
    "awesome": {
      "options": {
        "reportName": "HelloWorld",
        "singleFile": false,
        "reportLanguage": "en",
        "open": false,
        "publish": true
      }
    },
    "allure2": {
      "options": {
        "reportName": "HelloWorld",
        "singleFile": false,
        "reportLanguage": "en"
      }
    },
    "classic": {
      "options": {
        "reportName": "HelloWorld",
        "singleFile": false,
        "reportLanguage": "en"
      }
    },
    "dashboard": {
      "options": {
        "singleFile": false,
        "reportName": "HelloWorld-Dashboard",
        "reportLanguage": "en"
      }
    },
    "csv": {
      "options": {
        "fileName": "allure-report.csv"
      }
    },
    "log": {
      "options": {
        "groupBy": "none"
      }
    }
  },
  "variables": {
    "env_variable": "unknown"
  }
}

yaml

name: Allure Report
output: ./allure-report
historyPath: ./history.jsonl
qualityGate:
  rules:
    - maxFailures: 5
      fastFail: true
plugins:
  allure2:
    options:
      reportName: HelloWorld
      singleFile: false
      reportLanguage: en
  classic:
    options:
      reportName: HelloWorld
      singleFile: false
      reportLanguage: en
  awesome:
    options:
      reportName: HelloWorld
      singleFile: false
      reportLanguage: en
      open: false
      publish: true
  dashboard:
    options:
      singleFile: false
      reportName: HelloWorld-Dashboard
      reportLanguage: en
  csv:
    options:
      fileName: allure-report.csv
  log:
    options:
      groupBy: none
variables:
  env_variable: unknown

Capacidades y Prerrequisitos del Archivo de Configuración Dinámico

Para Proyectos de Node.js

Agrega Allure como dependencia de desarrollo a tu proyecto:

bash

cd tu-proyecto
npm install -D allure

Luego, envuelve el objeto de configuración con la función defineConfig:

javascript

import { defineConfig } from "allure";

export default defineConfig({
  name: "Mi Reporte de Allure",
  // ... configuración
});

Para Otros Tipos de Proyectos

Puedes usar una instalación global de Allure Report y simplemente exportar el objeto de configuración directamente:

export default {
  name: "Mi Reporte de Allure",
  // ... configuración
};

De esta manera, sin embargo, no obtendrás sugerencias de tipo.

Puedes evitar esa limitación inicializando un proyecto Node.js ficticio e instalando Allure en él:

bash

npm init --yes
npm install -D allure

Luego, envuelve el objeto de configuración en la función defineConfig, tal como lo harías para cualquier proyecto de Node.js (consulta la sección anterior).

Lectura de Variables de Entorno

Dado que los archivos de configuración dinámicos son JavaScript ejecutable, puedes usar:

javascript

import { env } from "node:process";

export default {
  name: env.REPORT_NAME || "Reporte Predeterminado",
  output: env.CI ? "./ci-reports" : "./local-reports",
};

Importación de Código

Cuando uses archivos dinámicos, puedes trasladar algo de lógica ejecutable a otros archivos JavaScript y luego importarla a tu configuración desde ellos.

También puedes importar código de otros módulos de Node.js, incluidos los plugins de Allure 3.

Referencia de Valores Predeterminados de Nivel Superior

Opción	Valor Predeterminado
`name`	`"Allure Report"`
`output`	`"./allure-report"`
`open`	`false`
`port`	`undefined` (aleatorio)
`historyPath`	`undefined`
`appendHistory`	`true`
`historyLimit`	`undefined` (sin límite)
`historyBaseUrl`	`undefined`
`flakyDetection`	`undefined` (`historyDepth: 10`, `stabilizationPeriod: 5`, `includePassedTests: false`)
`categories`	`{ rules: [{ name: "Product errors", matchers: { statuses: ["failed"] } }, { name: "Test errors", matchers: { statuses: ["broken"] } }] }`
`variables`	`{}`
`environments`	`{}`
`environment`	`undefined`
`allowedEnvironments`	`undefined`
`defaultLabels`	`{}`
`hideLabels`	`undefined`
`resolutions`	`undefined`
`plugins`	`{ awesome: { options: {} } }`
`qualityGate`	`{}`
`performance`	`undefined`
`dump`	`undefined`
`globalAttachments`	`undefined`

2. Opciones de Configuración Básicas

`name`

Tipo: string
Predeterminado: "Allure Report"
Descripción: Nombre para mostrar del reporte

javascript

{
  name: "My Test Suite Report"
}

`output`

Tipo: string
Predeterminado: "./allure-report"
Descripción: Directorio donde se generará el reporte

javascript

{
  output: "./reports/allure"
}

`open`

Tipo: boolean
Predeterminado: false
Descripción: Al finalizar la generación, inicia un servidor local de archivos estáticos y abre el reporte en el navegador predeterminado. Úsalo junto con port para controlar el puerto del servidor.

javascript

{
  open: true
}

`port`

Tipo: string
Predeterminado: undefined (puerto disponible aleatorio)
Descripción: Puerto para el servidor local que se inicia cuando open: true. Si se omite, se elige un puerto disponible aleatorio.

javascript

{
  port: "3000"
}

`hideLabels`

Tipo: (string | RegExp)[]
Predeterminado: undefined
Descripción: Oculta etiquetas de la UI del reporte por nombre de etiqueta. No filtra pruebas — solo afecta lo que se muestra. Las etiquetas cuyo nombre comienza con _ siempre se ocultan independientemente de esta configuración.

javascript

{
  hideLabels: ["package", "thread", /^allure_id/]
}

`dump`

Tipo: string
Predeterminado: undefined
Descripción: Cuando se establece, archiva el estado procesado de los resultados de prueba en un archivo .zip en la ruta indicada (.zip se agrega automáticamente) en lugar de ejecutar los plugins de reporte. El archivo de volcado puede restaurarse más tarde usando el flag --dump en el comando CLI generate.

javascript

{
  dump: "./snapshots/run-2025-10-20"
  // produce ./snapshots/run-2025-10-20.zip
}

Documentación: Consulta Compilaciones Multietapa para la documentación completa.

`globalAttachments`

Tipo: string[]
Predeterminado: undefined
Descripción: Patrones glob (relativos al directorio de trabajo) para archivos que se adjuntan al reporte de forma global, independientemente de cualquier resultado de prueba. Solo se incluyen archivos dentro del directorio de trabajo; las rutas que se resuelven fuera de él se omiten silenciosamente.

javascript

{
  globalAttachments: ["./logs/*.log", "./screenshots/global/**/*.png"]
}

Documentación: Consulta Errores Globales y Adjuntos para la documentación completa.

3. Opciones de Historial

`historyPath`

Tipo: string
Predeterminado: undefined
Descripción: Ruta al archivo de historial que rastrea los resultados de pruebas en múltiples ejecuciones
Formato: JSONL (JSON Lines) - cada línea contiene datos de una ejecución de prueba completa
Usado para:
- Gráficas de tendencias que muestran el comportamiento de las pruebas a lo largo del tiempo
- Detección de pruebas inestables
- Comparaciones históricas

javascript

{
  historyPath: "./test-history/allure-history.jsonl"
}

`appendHistory`

Tipo: boolean
Predeterminado: true
Descripción: Indica si se agrega la ejecución actual al historial. Si es false, Allure sigue leyendo el historial y mostrándolo en el reporte, pero no escribe una nueva entrada para la ejecución actual.

javascript

{
  appendHistory: true
}

`historyLimit`

Tipo: number
Predeterminado: undefined (sin límite)
Descripción: Limita cuántas ejecuciones pasadas se consideran. Con historyPath (archivo de historial local), esto recorta el archivo: cuando excede este conteo, se eliminan las entradas más antiguas. Con allureService (Allure Report Storage), en cambio limita cuántas entradas previas se recuperan, no se elimina nada remotamente, el historial más antiguo permanece almacenado y es recuperable con un límite mayor más adelante. No tiene efecto si ni historyPath ni allureService.accessToken están establecidos.

javascript

{
  historyLimit: 20
}

`historyBaseUrl`

Tipo: string
Predeterminado: undefined
Descripción: La dirección en la que se publicará el reporte: una URL absoluta del directorio que contiene el reporte, no de su archivo index.html, y sin un fragmento #. De lo contrario, la generación del reporte falla. Allure guarda la dirección en el historial, para que los reportes posteriores puedan vincular las entradas de su pestaña Historial con la prueba en este reporte. Solo se usa con historyPath, se ignora si allureService está configurado.

javascript

{
  historyBaseUrl: "https://reports.example.com/builds/42/"
}

`flakyDetection`

Tipo: { historyDepth?: number; stabilizationPeriod?: number; includePassedTests?: boolean }
Predeterminado: undefined (se usan los valores predeterminados de todos los campos)
Descripción: Controla cómo Allure marca las pruebas como inestables según su historial. No tiene efecto si el historial no está disponible.
Campos:
- historyDepth - el número máximo de resultados anteriores de una prueba que Allure analiza. Solo se cuentan los resultados con el estado Aprobado, Fallido o Roto del mismo entorno. Los resultados anteriores a una ejecución en la que la prueba no estuvo presente nunca se analizan. Por defecto: 10. Establécelo en 0 para analizar todo el historial disponible, o en -1 para desactivar la detección de pruebas inestables basada en el historial. Debe ser un entero mayor o igual que -1.
- stabilizationPeriod - el número de resultados Aprobado, Fallido o Roto idénticos seguidos a partir del cual Allure deja de tener en cuenta los cambios de estado anteriores. Por defecto: 5. Debe ser un entero positivo.
- includePassedTests - si una prueba aprobada en la ejecución actual también puede marcarse como inestable. Por defecto: false, lo que significa que solo las pruebas con el estado Fallido o Roto pueden marcarse.

Las pruebas que tu integración de Allure marca explícitamente como inestables siempre se marcan como inestables, independientemente de esta configuración.

javascript

{
  flakyDetection: {
    historyDepth: 20,
    stabilizationPeriod: 3,
    includePassedTests: true,
  },
}

Estructura del Archivo: Consulta el documento Archivo de Historial para más detalles.

4. Categorías

Define categorías personalizadas para agrupar y clasificar pruebas fallidas y rotas por estado, mensaje de error, etiquetas y otros criterios.

Tipo: { rules: CategoryRule[] }
Predeterminado: Dos categorías integradas — Defectos de producto (failed) y Defectos de prueba (broken)
Propósito: Crear una pestaña "Categorías" en los reportes que agrupa los resultados de prueba por tipo de defecto. Todos los resultados de prueba se comparan primero con las reglas personalizadas, en el orden definido; las pruebas fallidas/rotas que no coincidan vuelven a las categorías predeterminadas.

Estructura

{
  categories: {
    rules: [
      {
        name: "Título de categoría",           // Requerido
        id: "category-id",                     // Opcional, identificador estable que permite cambiar el nombre
        matchers: { ... } | (data) => boolean | [...],  // Requerido, objeto matcher o función matcher
        groupBy: ["severity", "owner"],        // Opcional, determina los niveles de organización
        groupByMessage: true,                  // Opcional, predeterminado: true
        groupEnvironments: true,               // Opcional
        expand: false,                         // Opcional, predeterminado: false
        hide: false,                           // Opcional, predeterminado: false
      }
    ]
  }
}

También puedes establecer categories: false para deshabilitar las categorías completamente (ni las categorías predeterminadas ni las reglas personalizadas se aplicarán).

`matchers`

matchers es obligatorio y debe ser uno de los siguientes:

Object matcher - un objeto plano con cualquier combinación de:
- statuses: TestStatus[] - coincide con el estado de la prueba, p. ej. ["failed", "broken"].
- flaky: boolean - determina si la categoría debe incluir pruebas inestables. Requiere historial para funcionar.
- labels: { [labelName]: string | RegExp } - coincide con etiquetas, como expresión regular. La entrada de cadena se convierte en un objeto RegExp, por lo que cualquier metacarácter de regex incluido en la cadena (como ., * o ^) afectará cómo se comporta la coincidencia, p. ej. { owner: /^alice/ } coincidirá con todos los resultados donde la etiqueta owner comience con alice.
- message: (sub)cadena | RegExp - coincide con el mensaje de error como expresión regular. Al igual que con labels, cualquier metacarácter de regex en una cadena proporcionada afectará la coincidencia.
- trace: (sub)cadena | RegExp - coincide con el stack trace como expresión regular. Al igual que con labels, cualquier metacarácter de regex en una cadena proporcionada afectará la coincidencia.
- transitions: TestStatusTransition[] - coincide con transiciones, p. ej. ["new", "regressed"]. Requiere historial para funcionar.
- environments: string[] - coincide con entornos.
Las pruebas que cumplan todas estas condiciones serán incluidas (se aplica lógica AND).
Function matcher — (data) => boolean, donde data contiene status, labels, message, trace, flaky, duration, transition, environment.
El function matcher requiere configuración dinámica para funcionar, y al igual que con los object matchers, debes habilitar el historial para coincidir con flaky y transition, y configurar los entornos para coincidir con environment.
Al usar function matchers, puedes filtrar adicionalmente por duration (p. ej. (data) => data.duration > 5000), implementar compuertas lógicas complejas entre múltiples condiciones y usar expresiones JavaScript arbitrarias para ajustar tus categorías.
Array — cualquier combinación de los anteriores; la prueba coincide si algún matcher del arreglo coincide (se aplica lógica OR).

`groupBy`

groupBy es opcional, controla la jerarquía de anidación dentro del árbol de categorías. Cada elemento es un selector de cadena integrado o un objeto de etiqueta personalizado:

Integrados: "flaky", "owner", "severity", "transition", "status", "environment", "layer"
Etiquetas personalizadas: { label: "myCustomLabel" }

Ejemplo: groupBy: ["severity", { label: "feature" }] crea dos niveles de agrupación — primero por severidad, luego por feature — antes de mostrar los resultados de prueba individuales.

Ejemplo

Categorías mediante object matchersCategorías mediante function matchers

import { defineConfig } from "allure";

export default defineConfig({
  name: "Allure Report 3",
  output: "./allure-report",
  historyPath: "./history.jsonl", //requerido para identificar de inestabilidad (“flaky”) y de transiciones de estado
  categories: {
    rules: [
      {
        name: "Critical regressions by layer",
        id: "critical-regressions-by-layer",
        // esta sección determina qué se incluye en la categoría
        matchers: {
          statuses: ["failed", "broken"],
          flaky: false,
          labels: { severity: "critical" },
          message: /expected|API/, // acepta expresiones regulares
          trace: /AssertionError|timeout|unexpected/, // acepta expresiones regulares
          transitions: ["regressed", "malfunctioned"],
          environments: ["staging", "production"],
        },

        // esta sección determina cómo se presenta la categoría
        groupBy: ["layer", "owner", "status"],
        groupByMessage: true,
        groupEnvironments: true,
        expand: true,
        hide: false,
      },
    ],
  },
});

import { defineConfig } from "allure";

export default defineConfig({
  name: "Allure Report 3",
  output: "./allure-report",
  historyPath: "./history.jsonl", //requerido para identificar de inestabilidad (“flaky”) y de transiciones de estado
  categories: {
    rules: [
      {
        name: "Critical regressions by layer",
        id: "critical-regressions-by-layer",
        // esta sección determina qué se incluye en la categoría
        matchers: (data) =>
          (data.status === "failed" || data.status === "broken") &&
          !data.flaky &&
          data.labels.some((l) => l.name === "severity" && l.value === "critical") &&
          /expected|API/.test(data.message ?? "") &&
          /AssertionError|timeout|unexpected/.test(data.trace ?? "") &&
          (data.transition === "regressed" || data.transition === "malfunctioned") &&
          (data.environment === "staging" || data.environment === "production"),
        // esta sección determina cómo se presenta la categoría
        groupBy: ["layer", "owner", "status"],
        groupByMessage: true,
        groupEnvironments: true,
        expand: true,
        hide: false,
      },
    ],
  },
});

Documentación: Consulta la Guía de Categorías para la documentación completa.

5. Variables y Etiquetas

`variables`

Muestra metadatos personalizados de clave-valor en la parte superior del reporte.

Tipo: Record<string, string>
Predeterminado: {}
Dónde se muestra: Parte superior del reporte en el plugin awesome
Propósito: Mostrar metadatos de compilación/ejecución

Ejemplo

javascript

{
  variables: {
    "App Version": "2.5.1",
    "Test Suite": "Regression v1.2",
    "Launch Date": "2025-10-20",
    "Build Number": "#1234",
    "Environment": "Staging"
  }
}

`defaultLabels`

Aplica etiquetas predeterminadas a las pruebas.

Tipo: Record<string, string | string[]>
Predeterminado: {}
Comportamiento: No sobrescribe - solo se aplica si la prueba no tiene esa etiqueta
Propósito: Proporcionar valores de respaldo para etiquetas faltantes

Ejemplo

javascript

{
  defaultLabels: {
    "severity": "normal",
    "owner": "unassigned",
    "layer": "unknown",
    "tags": ["needs-review"]
  }
}

Cómo Funciona

Prueba con severity: "critical" → mantiene "critical" (no se sobrescribe)
Prueba sin severity → obtiene "normal" de los valores predeterminados
Prueba sin tags → obtiene ["needs-review"]
Prueba con tags: ["smoke"] → mantiene ["smoke"]

Valores de Etiqueta

Valor único:

javascript

"severity": "critical"

Múltiples valores (arreglo):

javascript

"tags": ["smoke", "regression", "api"]

6. Entornos

Agrupa y categoriza los resultados de las pruebas por entorno con lógica de coincidencia personalizada.

Tipo: Record<string, EnvironmentDescriptor>
Predeterminado: {}
Propósito: Crear un menú "Entornos" en los reportes y dividir el árbol de resultados de pruebas en grupos basados en entornos, entre los cuales puedes cambiar usando ese menú.

Estructura

javascript

{
  environments: {
    "id-entorno": {                        // Clave = ID: solo letras latinas, dígitos, guiones bajos y guiones
      name?: string,                       // Nombre visible en el reporte; por defecto se usa el ID
      matcher: ({ labels }) => boolean,    // Requerido
      variables?: Record<string, string>   // Opcional
    }
  }
}

Función Matcher

Recibe las etiquetas de prueba y devuelve true si la prueba pertenece a este entorno. Requiere configuración dinámica para funcionar.

Estructura del payload:

javascript

{
  labels: [
    { name: "os", value: "Windows" },
    { name: "browser", value: "Chrome" },
    // ... more labels
  ]
}

Nota: estas etiquetas deben establecerse en las pruebas ya que no hay valores predeterminados para las etiquetas de entorno.

Ejemplo

Entornos Basados en OSEntornos de Despliegue

javascript

{
  environments: {
    windows: {
      matcher: ({ labels }) =>
        labels.find(({ name, value }) => name === "os" && value === "Windows"),
      variables: {
        "OS": "Windows 11",
        "Architecture": "x64"
      }
    },
    macos: {
      matcher: ({ labels }) =>
        labels.find(({ name, value }) => name === "os" && value === "macOS"),
      variables: {
        "OS": "macOS Sonoma",
        "Architecture": "arm64"
      }
    },
    linux: {
      matcher: ({ labels }) =>
        labels.find(({ name, value }) => name === "os" && value === "Linux"),
      variables: {
        "OS": "Ubuntu 22.04",
        "Architecture": "x64"
      }
    }
  }
}

javascript

{
  environments: {
    staging: {
      matcher: ({ labels }) =>
        labels.find(l => l.name === "env" && l.value === "staging"),
      variables: {
        "Server": "staging.example.com",
        "Database": "staging-db"
      }
    },
    production: {
      matcher: ({ labels }) =>
        labels.find(l => l.name === "env" && l.value === "production"),
      variables: {
        "Server": "api.example.com",
        "Database": "prod-db-primary"
      }
    }
  }
}

Variables de Entorno

Las variables opcionales específicas del entorno sobrescriben o extienden las variables globales al ver ese entorno.

Comportamiento de fusión:

Las variables globales se muestran en todas las vistas
Las variables específicas del entorno sobrescriben/agregan a las globales cuando ese entorno está seleccionado

Casos de Uso

Agrupar pruebas por SO (Windows/macOS/Linux)
Agrupar por navegador (Chrome/Firefox/Safari)
Agrupar por entorno de despliegue (staging/producción)
Agrupar por cualquier criterio personalizado basado en etiquetas

`environment`

Nota: Esta es una opción de nivel superior.

Tipo: string
Predeterminado: undefined
Descripción: Asigna forzosamente un único ID de entorno a todos los resultados de prueba de esta ejecución, omitiendo la lógica de matcher en environments. Úsalo cuando no necesites coincidencia dinámica basada en etiquetas y ya sabes contra qué entorno estás ejecutando. Tiene precedencia sobre cualquier entorno coincidente.

javascript

{
  environment: "staging"
}

`allowedEnvironments`

Nota: Esta es una opción de nivel superior.

Tipo: string[]
Predeterminado: undefined
Descripción: Restringe qué IDs de entorno se consideran válidos. Cuando se establece, cualquier ID de entorno — del mapa environments, del override environment, o de los datos de resultados de prueba — que no esté en esta lista causará un error de validación al inicio. Úsalo para imponer un conjunto fijo de entornos conocidos y detectar configuraciones incorrectas anticipadamente.

javascript

{
  allowedEnvironments: ["staging", "production", "windows", "macos"]
}

Documentación: Consulta la Guía de Entornos para la documentación completa.

7. Resoluciones

Marca fallos de prueba conocidos, silenciados y aceptados, y vincúlalos a rastreadores de incidencias. Los fallos resueltos se destacan en el reporte, y los silenciados y aceptados son ignorados por los quality gates.

`resolutions`

Tipo: object
Predeterminado: undefined
Descripción: Reglas de resolución, plantillas de enlaces de incidencias y la ruta del archivo de problemas conocidos

javascript

{
  resolutions: {
    links: {
      jira: { urlTemplate: "https://jira.example.com/browse/%s", nameTemplate: "JIRA %s" },
    },
    rules: [
      {
        resolution: "issue",
        issue: { id: "SHOP-42", type: "jira" },
        messageRegexp: "Connection timeout",
        comment: "Payment gateway sandbox is slow",
      },
      {
        resolution: "muted",
        testCaseId: ["103"],
        expiresAt: "2027-03-31T18:00:00+02:00",
        comment: "Muted until the widget redesign lands",
      },
    ],
  },
}

Campo	Descripción
`rules`	Requerido. Lista de reglas. Cada regla tiene una `resolution` (`issue`, `muted` o `accepted`), uno o más matchers (`messageRegexp`, `testCaseId`, `retryHash`, `environment`), un `issue` (para reglas `issue`), un `comment` (requerido para reglas `muted` y `accepted`) y una marca de tiempo `expiresAt` opcional a partir de la cual una regla `muted` deja de ignorar la falla.
`links`	Plantillas para enlaces de incidencias, por tipo de incidencia: `urlTemplate` (requerido) y `nameTemplate`, cada una con exactamente un marcador `%s` para el ID de la incidencia.
`knownIssuesPath`	Ruta del archivo de problemas conocidos que Allure escribe después de generar el reporte. Predeterminado: `known-issues.json` en el directorio de trabajo actual. Puede sobrescribirse con la opción `--known-issues`.

Documentación: Consulta Resoluciones para la documentación completa.

8. Configuración de Plugins

Descripción General del Sistema de Plugins

Allure 3 utiliza una arquitectura basada en plugins. Cada plugin genera un tipo específico de reporte o proporciona funcionalidad adicional.

Plugins Oficiales Disponibles:

awesome - UI moderna (recomendado)
classic - UI clásica
allure2 - UI estilo Allure 2
dashboard - Vista de tablero con gráficas
log - Salida de registro de consola
csv - Exportación a CSV
metrics - Exportación de estadísticas de prueba para Prometheus e InfluxDB
mail - Resumen de ejecución como un correo HTML listo para enviar
slack - Integración con Slack
xray - Integración con Xray
testplan - Generación de plan de pruebas
jira - Integración con Jira

Puedes encontrar el código de los plugins oficiales en el repositorio de Allure 3.

Configuración Básica de Plugins

Todos los plugins listados anteriormente excepto mail están incluidos en el paquete allure. Para usar un plugin que no está incluido, como mail o un plugin de terceros, instala primero su paquete:

npm add @allurereport/plugin-name

Para habilitar un plugin, agrégalo a la sección plugins de la configuración:

javascript

{
  plugins: {
    "nombre": {
      options: {
        // opciones específicas del plugin
      }
    }
  }
}

Propiedades de Configuración de Plugins

`import` (opcional)

Ruta de módulo personalizada para el plugin

javascript

{
  plugins: {
    "mi-id-personalizado": {
      import: "@allurereport/plugin-awesome",
      options: {}
    }
  }
}

Caso de uso: Ejecutar múltiples instancias del mismo plugin con diferentes configuraciones

`enabled` (opcional)

Habilitar o deshabilitar el plugin

Tipo: boolean
Predeterminado: true

javascript

{
  plugins: {
    awesome: {
      enabled: false,  // Deshabilitar este plugin
      options: {}
    }
  }
}

`options` (opcional)

Objeto de configuración específico del plugin

Tipo: Record<string, any>
Predeterminado: {}

javascript

{
  plugins: {
    awesome: {
      options: {
        singleFile: true,
        reportLanguage: "en"
      }
    }
  }
}

Múltiples Reportes

Puedes generar múltiples reportes configurando varios plugins:

javascript

{
  plugins: {
    "awesome-framework": {
      import: "@allurereport/plugin-awesome",
      options: {
        reportName: "Vista de Framework",
        groupBy: ["framework", "language"]
      }
    },
    "awesome-package": {
      import: "@allurereport/plugin-awesome",
      options: {
        reportName: "Vista de Paquetes",
        groupBy: ["package", "suite"]
      }
    },
    dashboard: {
      options: {
        reportName: "Tablero"
      }
    }
  }
}

Plugin Predeterminado

Si no se especifican plugins, Allure usa el plugin awesome por defecto:

javascript

// Estos son equivalentes:
export default { name: "Reporte" }

export default {
  name: "Reporte",
  plugins: {
    awesome: { options: {} }
  }
}

9. Opciones de Plugins

Plugin Awesome

UI moderna recomendada para reportes de Allure.

Opciones Comunes

reportName (string)

Sobrescribe el name de nivel superior para este reporte

singleFile (boolean, predeterminado: false)

Genera el reporte como un único archivo HTML independiente
true: Archivo HTML único
false: Múltiples archivos

reportLanguage (predeterminado: "en")

Establece el idioma de la UI

groupBy (string[])

Define la organización de jerarquía de resultados de prueba
Arreglo de nombres de etiquetas

Patrones comunes:

javascript

// Jerarquía estilo BDD
groupBy: ["epic", "feature", "story"];

// Jerarquía basada en suites
groupBy: ["parentSuite", "suite", "subSuite"];

// Jerarquía basada en paquetes
groupBy: ["package", "testClass", "testMethod"];

// Basada en módulos
groupBy: ["module", "parentSuite", "suite", "subSuite"];

// Jerarquía personalizada
groupBy: ["framework", "language", "package"];

filter (function) Requiere configuración dinámica

Determina qué resultados de prueba se incluyen en el reporte.
Recibe un objeto de resultado de prueba; retorna un valor verdadero para incluir, falso para excluir

Patrones comunes:

javascript

// Incluir solo pruebas con una etiqueta específica
filter: ({ labels }) =>
  labels.find(({ name, value }) => name === "framework" && value === "playwright");

// Excluir pruebas con una etiqueta específica
filter: ({ labels }) => !labels.find(({ name, value }) => name === "language" && value === "java");

ideaLinks (boolean u object, predeterminado: false)

Agrega un enlace Abrir en IDEA a la página de cada prueba que tenga una etiqueta testClass, como las pruebas de las integraciones de Allure para Java. El enlace abre la clase de prueba en IntelliJ IDEA.
true habilita los enlaces con la configuración predeterminada. Un objeto los habilita con configuración personalizada:
- port - el puerto del servidor integrado de IntelliJ IDEA. Predeterminado: 63342.
- fileExtension - la extensión de los archivos fuente de prueba. Predeterminado: java.
- sourceRoot - la ruta a las fuentes de prueba relativa a la raíz del proyecto, por ejemplo, src/test/java. No necesario para proyectos Maven y Gradle estándar.
Para que los enlaces funcionen, instala el plugin IDE Remote Control en IntelliJ IDEA y abre el proyecto. Al hacer clic en un enlace, IntelliJ IDEA te pide confirmar que confías en el host del reporte.

javascript

{
  plugins: {
    awesome: {
      options: {
        ideaLinks: true,
      },
    },
  },
}

charts (predeterminado: todas las gráficas incluidas)

Configuración de gráficas integradas: las gráficas configuradas aquí se incluirán en el propio reporte Awesome. No confundir con Dashboard, que es un tipo de reporte separado solo de gráficas.
Para más detalles sobre lo que ilustran las gráficas, consulta la documentación completa de Gráficas.
Para poblar correctamente la mayoría de las gráficas, el historial debe estar habilitado.
Si se omite charts, se incluyen todos los tipos de gráficas disponibles con sus opciones predeterminadas, que puedes revisar a continuación:

Ejemplo de configuración completa de gráficas con todas las opciones predeterminadas

import { defineConfig } from "allure";

// Configuración de gráficos con todos los tipos de gráficos y todas las opciones establecidas en valores predeterminados
const allChartsDefaultValues = [
  {
    type: "currentStatus",
    title: "Current status",
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
    metric: "passed", // estado utilizado para calcular el valor porcentual central
  },

  {
    type: "testResultSeverities",
    title: "Test results by severities",
    levels: ["blocker", "critical", "normal", "minor", "trivial"], //severidades incluidas
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
    includeUnset: true, //si se debe mostrar la sección "Sin severidad"
  },

  {
    type: "statusDynamics",
    title: "Status dynamics",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
  },

  {
    type: "statusTransitions",
    title: "Status transitions",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "testBaseGrowthDynamics",
    title: "Test base growth dynamics",
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "coverageDiff",
    title: "Coverage diff map",
  },

  {
    type: "successRateDistribution",
    title: "Success rate distribution",
  },

  {
    type: "problemsDistribution",
    title: "Problems distribution by environment",
    by: "environment", //solo se puede agrupar por entornos
  },

  {
    type: "stabilityDistribution",
    title: "Stability distribution by features",
    threshold: 90, // nivel de estabilidad aceptable en %
    skipStatuses: ["skipped", "unknown"], //estados de prueba omitidos
    groupBy: "feature", //por qué etiqueta agrupar las pruebas
  },

  {
    type: "stabilityDistribution",
    title: "Stability distribution by epics",
    threshold: 90, // nivel de estabilidad aceptable en %
    skipStatuses: ["skipped", "unknown"], //estados de prueba omitidos
    groupBy: "epic", //por qué etiqueta agrupar las pruebas
  },

  {
    type: "stabilityDistribution",
    title: "Stability distribution by stories",
    threshold: 90, // nivel de estabilidad aceptable en %
    skipStatuses: ["skipped", "unknown"], //estados de prueba omitidos
    groupBy: "story", //por qué etiqueta agrupar las pruebas
  },

  {
    type: "durations",
    title: "Durations histogram",
    groupBy: "none", //si se deben agrupar las pruebas por capa (otras etiquetas no son compatibles)
  },

  {
    type: "durations",
    title: "Durations by layer histogram",
    groupBy: "layer", //si se deben agrupar las pruebas por capa (otras etiquetas no son compatibles)
  },

  {
    type: "durationDynamics",
    title: "Durations dynamics",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "statusAgePyramid",
    title: "Status age pyramid",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "testingPyramid",
    title: "Testing pyramid",
    layers: ["unit", "integration", "e2e"], //capas de la pirámide, de abajo hacia arriba
  },
];

export default defineConfig({
  name: "Allure Report",
  output: "./allure-report",
  // la configuración del archivo de historial es necesaria para poblar la mayoría de los gráficos
  historyPath: "./history.jsonl",

  plugins: {
    awesome: {
      options: {
        reportName: "Allure Report",
        singleFile: false,
        reportLanguage: "en",
        // configuración de gráficos utilizada dentro del reporte Awesome
        charts: allChartsDefaultValues,
      },
    },

    dashboard: {
      options: {
        reportName: "Dashboard",
        singleFile: false,
        reportLanguage: "en",
        // configuración de gráficos utilizada en un reporte Dashboard
        layout: allChartsDefaultValues,
      },
    },
  },
});

Para cambiar solo algunas de las gráficas, parte de la lista predeterminada en lugar de copiarla: el paquete allure la exporta como defaultChartsConfig. Por ejemplo, esta configuración elimina el mapa de diferencia de cobertura y agrega una gráfica de distribución de estabilidad agrupada por owner:

javascript

import { defaultChartsConfig, defineConfig } from "allure";

const charts = [
  // todas las gráficas predeterminadas excepto el mapa de diferencia de cobertura
  ...defaultChartsConfig.filter((chart) => chart.type !== "coverageDiff"),
  // más una gráfica adicional de distribución de estabilidad
  {
    type: "stabilityDistribution",
    title: "Stability distribution by owners",
    threshold: 90,
    skipStatuses: ["skipped", "unknown"],
    groupBy: "owner",
  },
];

export default defineConfig({
  plugins: {
    awesome: { options: { charts } },
  },
});

Ejemplo de Configuración

javascript

{
  plugins: {
    awesome: {
      options: {
        singleFile: false,
        reportLanguage: "en",
        reportName: "My Awesome Report",
        groupBy: ["epic", "feature", "story"],
        filter: ({ labels }) => labels.find(({ name, value }) => name === "framework" && value === "playwright")
      }
    }
  }
}

Referencia Completa de Opciones

Para todas las opciones disponibles incluyendo características experimentales, consulta:

Código fuente de AwesomePluginOptions

Plugin Dashboard

Vista de tablero con gráficas y visualizaciones.

Opciones Comunes

reportName (string)

Título del tablero

singleFile (boolean, predeterminado: false)

Generar como archivo único

reportLanguage (predeterminado: "en")

Idioma de la UI

layout (arreglo de configuraciones de widgets)

Configuración de gráficas del reporte Dashboard
Para más detalles sobre lo que ilustran las distintas gráficas, consulta la documentación completa de Gráficas.
Para poblar correctamente la mayoría de las gráficas, el historial debe estar habilitado.
Si se omite layout, se incluyen todos los tipos de gráficas disponibles con sus opciones predeterminadas, que puedes revisar a continuación:
Para cambiar solo algunas de las gráficas, parte de defaultChartsConfig, de la misma forma que para la opción charts del reporte Awesome.

filter (function) Requiere configuración dinámica

Determina qué resultados de prueba se incluyen en el tablero. Recibe un objeto de resultado de prueba; retorna un valor verdadero para incluir, falso para excluir.

Ejemplo de Configuración

Ejemplo de configuración completa de gráficas con todas las opciones predeterminadas

import { defineConfig } from "allure";

// Configuración de gráficos con todos los tipos de gráficos y todas las opciones establecidas en valores predeterminados
const allChartsDefaultValues = [
  {
    type: "currentStatus",
    title: "Current status",
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
    metric: "passed", // estado utilizado para calcular el valor porcentual central
  },

  {
    type: "testResultSeverities",
    title: "Test results by severities",
    levels: ["blocker", "critical", "normal", "minor", "trivial"], //severidades incluidas
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
    includeUnset: true, //si se debe mostrar la sección "Sin severidad"
  },

  {
    type: "statusDynamics",
    title: "Status dynamics",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
  },

  {
    type: "statusTransitions",
    title: "Status transitions",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "testBaseGrowthDynamics",
    title: "Test base growth dynamics",
    statuses: ["passed", "failed", "broken", "skipped", "unknown"], //estados incluidos
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "coverageDiff",
    title: "Coverage diff map",
  },

  {
    type: "successRateDistribution",
    title: "Success rate distribution",
  },

  {
    type: "problemsDistribution",
    title: "Problems distribution by environment",
    by: "environment", //solo se puede agrupar por entornos
  },

  {
    type: "stabilityDistribution",
    title: "Stability distribution by features",
    threshold: 90, // nivel de estabilidad aceptable en %
    skipStatuses: ["skipped", "unknown"], //estados de prueba omitidos
    groupBy: "feature", //por qué etiqueta agrupar las pruebas
  },

  {
    type: "stabilityDistribution",
    title: "Stability distribution by epics",
    threshold: 90, // nivel de estabilidad aceptable en %
    skipStatuses: ["skipped", "unknown"], //estados de prueba omitidos
    groupBy: "epic", //por qué etiqueta agrupar las pruebas
  },

  {
    type: "stabilityDistribution",
    title: "Stability distribution by stories",
    threshold: 90, // nivel de estabilidad aceptable en %
    skipStatuses: ["skipped", "unknown"], //estados de prueba omitidos
    groupBy: "story", //por qué etiqueta agrupar las pruebas
  },

  {
    type: "durations",
    title: "Durations histogram",
    groupBy: "none", //si se deben agrupar las pruebas por capa (otras etiquetas no son compatibles)
  },

  {
    type: "durations",
    title: "Durations by layer histogram",
    groupBy: "layer", //si se deben agrupar las pruebas por capa (otras etiquetas no son compatibles)
  },

  {
    type: "durationDynamics",
    title: "Durations dynamics",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "statusAgePyramid",
    title: "Status age pyramid",
    limit: 10, // número de ejecuciones mostradas, incluida la más reciente
  },

  {
    type: "testingPyramid",
    title: "Testing pyramid",
    layers: ["unit", "integration", "e2e"], //capas de la pirámide, de abajo hacia arriba
  },
];

export default defineConfig({
  name: "Allure Report",
  output: "./allure-report",
  // la configuración del archivo de historial es necesaria para poblar la mayoría de los gráficos
  historyPath: "./history.jsonl",

  plugins: {
    awesome: {
      options: {
        reportName: "Allure Report",
        singleFile: false,
        reportLanguage: "en",
        // configuración de gráficos utilizada dentro del reporte Awesome
        charts: allChartsDefaultValues,
      },
    },

    dashboard: {
      options: {
        reportName: "Dashboard",
        singleFile: false,
        reportLanguage: "en",
        // configuración de gráficos utilizada en un reporte Dashboard
        layout: allChartsDefaultValues,
      },
    },
  },
});

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de DashboardPluginOptions

Nota: Dashboard genera un reporte independiente separado de otros plugins.

Plugin Allure2

UI estilo Allure 2.

Opciones Comunes

reportName (string)

Sobrescribe el name de nivel superior para este reporte

singleFile (boolean, predeterminado: false)

Genera el reporte como un único archivo HTML independiente

reportLanguage (predeterminado: "en")

Establece el idioma de la UI

createdAt (number)

Marca de tiempo de creación del reporte en milisegundos desde la época. Por defecto usa la hora actual si no se establece.

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de Allure2PluginOptions

Plugin Classic

UI clásica.

Opciones Comunes

reportName (string) reportLanguage (predeterminado: "en") singleFile (boolean)

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de ClassicPluginOptions

Plugin CSV

Exporta los resultados de prueba como un archivo CSV.

Opciones

fileName (string, predeterminado: "allure-report.csv")

Nombre del archivo de salida para la exportación CSV

separator (string, predeterminado: ",")

Carácter separador de campos

disableHeaders (boolean, predeterminado: false)

Cuando es true, omite la fila de encabezados de la salida

fields (array) Requiere configuración dinámica

Definiciones de columnas personalizadas. Cada entrada tiene un string header y un accessor — ya sea una clave del objeto de resultado de prueba o una función (result) => string.

sort (function) Requiere configuración dinámica

Función de ordenamiento aplicada a los resultados de prueba antes de escribir. Recibe dos objetos de resultado de prueba; sigue las convenciones de comparación estándar de Array.sort.

filter (function) Requiere configuración dinámica

Determina qué resultados de prueba se incluyen. Recibe un objeto de resultado de prueba; retorna un valor verdadero para incluir, falso para excluir.

Ejemplo de Configuración

javascript

{
  plugins: {
    csv: {
      options: {
        fileName: "results.csv",
        separator: ";",
        filter: ({ status }) => status === "failed",
        fields: [
          { header: "Name", accessor: "name" },
          { header: "Status", accessor: "status" },
          { header: "Duration (ms)", accessor: ({ duration }) => String(duration ?? "") }
        ]
      }
    }
  }
}

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de CsvPluginOptions

Plugin Log

Imprime los resultados de prueba en la consola.

Opciones

Agrupa la salida de consola por la jerarquía especificada antes de listar los resultados de prueba

allSteps (boolean, predeterminado: false)

Muestra todos los pasos en la salida. Por defecto solo se muestran los pasos de las pruebas fallidas.

withTrace (boolean, predeterminado: false)

Incluye stack traces para las pruebas fallidas

filter (function) Requiere configuración dinámica

Determina qué resultados de prueba se imprimen. Recibe un objeto de resultado de prueba; retorna un valor verdadero para incluir, falso para excluir.

qualityGateResults (boolean, predeterminado: true)

Imprime los resultados de quality gate después de los resultados de prueba

qualityGateFilter (function, predeterminado: solo reglas fallidas) Requiere configuración dinámica

Determina qué resultados de quality gate se imprimen. Recibe un objeto de resultado de quality gate con los campos success, rule, message, actual y expected; retorna un valor verdadero para incluir, falso para excluir. Por ejemplo, () => true también imprime las reglas aprobadas.

Ejemplo de Configuración

javascript

{
  plugins: {
    log: {
      options: {
        groupBy: "suites",
        allSteps: false,
        withTrace: true,
        filter: ({ status }) => status === "failed" || status === "broken"
      }
    }
  }
}

Plugin Mail

Genera un correo HTML listo para enviar con un resumen de la ejecución.

El correo contiene el nombre del reporte, el estado de la ejecución, la tasa de éxito, la duración, el número de pruebas de cada estado y la lista de pruebas fallidas y rotas con sus mensajes de error. Si se conoce la dirección del reporte, el correo enlaza al reporte. Si Allure detecta un entorno de CI, el correo también enlaza a la compilación de CI y muestra la rama.

El plugin escribe el correo en el directorio de salida del reporte y no lo envía. Para enviarlo, usa un paso de correo de tu pipeline de CI o cualquier otra herramienta.

El plugin no está incluido en el paquete allure, así que instálalo primero:

bash

npm add @allurereport/plugin-mail

Opciones

title (string, predeterminado: el nombre del reporte)

Título del correo

reportUrl (string)

Enlace al reporte. Por defecto, la dirección del reporte que Allure conoce desde historyBaseUrl o desde el campo reportUrl del archivo ejecutor. Si la dirección es desconocida, el correo no tiene enlace.

maxFailed (number, predeterminado: 20)

Número máximo de pruebas fallidas y rotas listadas en el correo. El resto se cuentan como "… and N more".

filename (string, predeterminado: "mail.html")

Nombre del archivo generado

Ejemplo de Configuración

javascript

{
  plugins: {
    awesome: {},
    mail: {
      options: {
        reportUrl: "https://reports.example.com/nightly/",
        maxFailed: 10,
      },
    },
  },
}

Plugin Metrics

Exporta estadísticas de prueba a archivos para Prometheus e InfluxDB, y opcionalmente las envía.

Consulta Exportación de métricas para las opciones y las métricas exportadas.

Plugin Slack

Publica un resumen de la ejecución en un canal de Slack.

Opciones

webhook (string)

URL del webhook entrante de Slack. También puede proporcionarse mediante la variable de entorno ALLURE_SLACK_WEBHOOK. Si se establece, token y channel no se usan.

token (string)

Token de bot de Slack. También puede proporcionarse mediante la variable de entorno ALLURE_SLACK_TOKEN.

channel (string)

ID o nombre del canal donde publicar, usado con token. También puede proporcionarse mediante la variable de entorno ALLURE_SLACK_CHANNEL.

Consulta Integración con Slack para cómo configurar Slack y qué contiene el mensaje.

Plugin TestPlan

Genera un archivo testplan.json para reejecutar un subconjunto de pruebas.

El archivo lista las pruebas que coincidieron con el filtro — por defecto, todas las pruebas no exitosas de la ejecución. Puede pasarse a un framework de pruebas compatible para reejecutar solo esas pruebas.

Opciones

fileName (string, predeterminado: "testplan.json")

Nombre del archivo de salida

filter (function) Requiere configuración dinámica

Determina qué resultados de prueba se incluyen en el plan de pruebas. Por defecto incluye todas las pruebas no exitosas (fallidas, rotas o de otro modo no aprobadas).

Ejemplo de Configuración

javascript

{
  plugins: {
    testplan: {
      options: {
        fileName: "rerun.json",
        filter: ({ status }) => status === "failed"
      }
    }
  }
}

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de TestPlanPlugin

Plugin TestOps

Sube los resultados de prueba a Allure TestOps.

Opciones

endpoint (string, requerido)

URL de la instancia de Allure TestOps

accessToken (string, requerido)

Token de acceso a la API para autenticación

projectId (string, requerido)

ID del proyecto de destino en Allure TestOps

launchName (string, requerido)

Nombre para mostrar del lanzamiento creado en TestOps

launchTags (string[], requerido)

Tags para adjuntar al lanzamiento

autocloseLaunch (boolean, predeterminado: false)

Cierra automáticamente el lanzamiento en TestOps después de que la subida se complete

limit (number, predeterminado: sin límite)

Número máximo de resultados de prueba a subir por lote

filter (function) Requiere configuración dinámica

Determina qué resultados de prueba se suben. Recibe un objeto de resultado de prueba; retorna un valor verdadero para incluir, falso para excluir.

Ejemplo de Configuración

javascript

import { env } from "node:process";

export default {
  plugins: {
    testops: {
      import: "@allurereport/plugin-testops",
      options: {
        endpoint: env.TESTOPS_URL,
        accessToken: env.TESTOPS_TOKEN,
        projectId: env.TESTOPS_PROJECT_ID,
        launchName: "Regression Suite",
        launchTags: ["regression", "nightly"],
        autocloseLaunch: true,
      },
    },
  },
};

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de TestOpsPluginOptions

Plugin Xray

Actualiza los estados de las ejecuciones de prueba en Xray Test Executions (Jira Server y Data Center).

Opciones

endpoint (string)

Dirección de Jira. También puede proporcionarse mediante la variable de entorno ALLURE_XRAY_ENDPOINT.

token (string)

Token de acceso personal de Jira. También puede proporcionarse mediante la variable de entorno ALLURE_XRAY_TOKEN. Si se establece, username y password no se usan.

username y password (string)

Nombre de usuario y contraseña de Jira. También pueden proporcionarse mediante las variables de entorno ALLURE_XRAY_USERNAME y ALLURE_XRAY_PASSWORD.

executions (string[])

Claves de las Test Executions a actualizar. También puede proporcionarse mediante la variable de entorno ALLURE_XRAY_EXECUTIONS, como una lista separada por comas.

statuses (object)

Estado de Xray (PASS, FAIL o TODO) a establecer para cada estado de prueba de Allure.

comment (boolean, predeterminado: true)

Si se debe agregar un comentario con un enlace al reporte a cada Test Execution.

Consulta Integración con Xray para cómo vincular pruebas a Xray y cómo se actualizan los estados.

10. Quality Gate

Controla el código de salida del proceso según los criterios de resultados de prueba, permitiendo que las ejecuciones de prueba pasen o fallen según reglas personalizadas.

javascript

{
  qualityGate: {
    rules: [
      {
        maxFailures: 5,
      },
    ]
  }
}

Documentación: Consulta la Guía de Quality Gate para la documentación completa.

Nota: Esta es una característica compleja con su propia documentación dedicada.

11. Publicación de Reportes (Allure Service)

Conecta Allure 3 a Allure Report Storage (o una instancia compatible), para que los reportes puedan publicarse y su historial recuperarse automáticamente después de cada ejecución, en vez de gestionar archivos de historial o alojar tú mismo.

allureService.accessToken proporciona el token de acceso; publish: true en las options de un plugin marca ese reporte para publicación.

javascript

{
  plugins: {
    awesome: {
      options: {
        publish: true,
      },
    },
  },
  allureService: {
    accessToken: "ars1...",
  },
}

Documentación: Consulta Allure Report Storage para la documentación completa, incluyendo cómo generar un token de acceso y ejecutar el servicio por tu cuenta.

12. Métricas de Rendimiento

Títulos, unidades, grupos y la dirección preferida de las métricas de rendimiento recopiladas durante la ejecución de prueba.

`performance`

Tipo: object
Predeterminado: undefined
Descripción: groups define los grupos de métricas (title para cada ID de grupo); metrics define los ajustes de cada clave de métrica: title, unit, better ("lower" o "higher") y group

javascript

{
  performance: {
    groups: {
      web: { title: "Web pages" },
    },
    metrics: {
      "page.load": { title: "Page load", unit: "ms", better: "lower", group: "web" },
    },
  },
}

Documentación: Consulta Métricas de Rendimiento para la documentación completa.

Sobreescrituras de Configuración CLI

Las opciones de configuración pueden sobrescribirse desde la línea de comandos:

bash

allure generate \
  --config ./allurerc.mjs \
  --output ./custom-output \
  --name "Overridden Name"

Opciones sobrescribibles:

--name / --report-name
--output / -o
--known-issues (ruta del archivo de problemas conocidos)
Opciones específicas de plugins (varían según el comando)

Comandos Específicos de Plugins

Genera reportes con plugins específicos directamente:

Reporte Awesome

bash

allure awesome [options] <directory>

Opciones:

--single-file
--logo
--theme
--report-language, --lang
--group-by, -g

Dashboard

bash

allure dashboard [options] <directory>

Reporte Classic

bash

allure classic [options] <directory>

Exportación CSV

bash

allure csv [options] <directory>

Salida Log

bash

allure log [options] <directory>

Comandos Utilitarios

Historial

bash

allure history [--history-path,-h] [--report-name,--name] <directory>

Genera el historial en la carpeta especificada.

Plan de Pruebas

bash

allure testplan [--output,-o] <directory>

Genera testplan.json.

Ayuda

Obtén ayuda detallada para cualquier comando:

bash

allure <command> --help

Apéndice: Referencia de Definiciones de Tipos

Para referencia, aquí están las principales interfaces de TypeScript que definen la estructura de configuración:

Interfaz Config

typescript

interface Config {
  name?: string;
  output?: string;
  historyPath?: string;
  resolutions?: ResolutionsConfig;
  performance?: PerformanceConfig;
  defaultLabels?: DefaultLabelsConfig;
  environments?: EnvironmentsConfig;
  variables?: ReportVariables;
  plugins?: Record<string, PluginDescriptor>;
  appendHistory?: boolean;
  qualityGate?: QualityGateConfig;
  allureService?: {
    accessToken?: string;
  }; // ver Sección 11: Publicación de Reportes (Allure Service)
}

Tipos de Soporte

typescript

type DefaultLabelsConfig = Record<string, string | string[]>;

type ReportVariables = Record<string, string>;

type EnvironmentDescriptor = {
  name?: string;
  variables?: ReportVariables;
  matcher: (payload: { labels: TestLabel[] }) => boolean;
};

type EnvironmentsConfig = Record<string, EnvironmentDescriptor>;

interface PluginDescriptor {
  import?: string;
  enabled?: boolean;
  options?: Record<string, any>;
}

interface ResolutionsConfig {
  knownIssuesPath?: string;
  links?: Record<string, { urlTemplate: string; nameTemplate?: string }>;
  rules: ResolutionRule[];
}

interface ResolutionMatcher {
  messageRegexp?: string;
  testCaseId?: string[];
  retryHash?: string[];
  environment?: string[];
}

type ResolutionRule =
  | (ResolutionMatcher & {
      resolution: "issue";
      issue: { id: string; type: string };
      comment?: string;
    })
  | (ResolutionMatcher & {
      resolution: "muted";
      comment: string;
      expiresAt?: string;
    })
  | (ResolutionMatcher & {
      resolution: "accepted";
      comment: string;
    });

interface PerformanceConfig {
  groups?: Record<string, { title: string }>;
  metrics?: Record<
    string,
    { title: string; unit: string; better: "lower" | "higher"; group?: string }
  >;
}

Configurar Allure Report 3 ​

Qué Cubre Este Documento ​

1. Conceptos Básicos del Archivo de Configuración ​

Nombre y Ubicación del Archivo ​

Formato y Sintaxis del Archivo ​

Capacidades y Prerrequisitos del Archivo de Configuración Dinámico ​

Para Proyectos de Node.js ​

Para Otros Tipos de Proyectos ​

Lectura de Variables de Entorno ​

Importación de Código ​

Referencia de Valores Predeterminados de Nivel Superior ​

2. Opciones de Configuración Básicas ​

name ​

output ​

open ​

port ​

hideLabels ​

dump ​

globalAttachments ​

3. Opciones de Historial ​

historyPath ​

appendHistory ​

historyLimit ​

historyBaseUrl ​

flakyDetection ​

4. Categorías ​

Estructura ​

matchers ​

groupBy ​

Ejemplo ​

5. Variables y Etiquetas ​

variables ​

Ejemplo ​

defaultLabels ​

Ejemplo ​

Cómo Funciona ​

Valores de Etiqueta ​

6. Entornos ​

Estructura ​

Función Matcher ​

Ejemplo ​

Variables de Entorno ​

Casos de Uso ​

environment ​

allowedEnvironments ​

7. Resoluciones ​

resolutions ​

8. Configuración de Plugins ​

Descripción General del Sistema de Plugins ​

Configuración Básica de Plugins ​

Propiedades de Configuración de Plugins ​

import (opcional) ​

enabled (opcional) ​

options (opcional) ​

Múltiples Reportes ​

Plugin Predeterminado ​

9. Opciones de Plugins ​

Plugin Awesome ​

Opciones Comunes ​

Ejemplo de Configuración ​

Referencia Completa de Opciones ​

Plugin Dashboard ​

Opciones Comunes ​

Ejemplo de Configuración ​

Referencia Completa de Opciones ​

Plugin Allure2 ​

Opciones Comunes ​

Referencia Completa de Opciones ​

Plugin Classic ​

Opciones Comunes ​

Referencia Completa de Opciones ​

Plugin CSV ​

Opciones ​

Ejemplo de Configuración ​

Referencia Completa de Opciones ​

Plugin Log ​

Opciones ​

Ejemplo de Configuración ​

Plugin Mail ​

Opciones ​

Configurar Allure Report 3

Qué Cubre Este Documento

1. Conceptos Básicos del Archivo de Configuración

Nombre y Ubicación del Archivo

Formato y Sintaxis del Archivo

Capacidades y Prerrequisitos del Archivo de Configuración Dinámico

Para Proyectos de Node.js

Para Otros Tipos de Proyectos

Lectura de Variables de Entorno

Importación de Código

Referencia de Valores Predeterminados de Nivel Superior

2. Opciones de Configuración Básicas

`name`

`output`

`open`

`port`

`hideLabels`

`dump`

`globalAttachments`

3. Opciones de Historial

`historyPath`

`appendHistory`

`historyLimit`

`historyBaseUrl`

`flakyDetection`

4. Categorías

Estructura

`matchers`

`groupBy`

Ejemplo

5. Variables y Etiquetas

`variables`

Ejemplo

`defaultLabels`

Ejemplo

Cómo Funciona

Valores de Etiqueta

6. Entornos

Estructura

Función Matcher

Ejemplo

Variables de Entorno

Casos de Uso

`environment`

`allowedEnvironments`

7. Resoluciones

`resolutions`

8. Configuración de Plugins

Descripción General del Sistema de Plugins

Configuración Básica de Plugins

Propiedades de Configuración de Plugins

`import` (opcional)

`enabled` (opcional)

`options` (opcional)

Múltiples Reportes

Plugin Predeterminado

9. Opciones de Plugins

Plugin Awesome

Opciones Comunes

Ejemplo de Configuración

Referencia Completa de Opciones

Plugin Dashboard

Opciones Comunes

Ejemplo de Configuración

Referencia Completa de Opciones

Plugin Allure2

Opciones Comunes

Referencia Completa de Opciones

Plugin Classic

Opciones Comunes

Referencia Completa de Opciones

Plugin CSV

Opciones

Ejemplo de Configuración

Referencia Completa de Opciones

Plugin Log

Opciones

Ejemplo de Configuración

Plugin Mail

Opciones