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 y problemas conocidos
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,
        charts: chartLayout,
        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",
        layout: defaultChartsConfig,
      },
    },
    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"
      }
    },
    "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"
  }
}

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"`
`historyPath`	`undefined`
`knownIssuesPath`	`"./allure/known.json"`
`appendHistory`	`true`
`variables`	`{}`
`environments`	`{}`
`defaultLabels`	`{}`
`plugins`	`{ awesome: { options: {} } }`

2. Opciones de Configuración Básicas

`name`

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

javascript

{
  name: "Reporte de Mi Suite de Pruebas";
}

`output`

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

javascript

{
  output: "./reportes/allure";
}

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áficos 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: Controla el comportamiento de acumulación del historial

javascript

{
  appendHistory: true;
}

Estructura del Archivo: Consulta la sección Archivo de Historial para más detalles.

4. Opciones de Problemas Conocidos

`knownIssuesPath`

Tipo: string
Predeterminado: "./allure/known.json"
Descripción: Ruta al archivo JSON que contiene fallos de prueba conocidos

javascript

{
  knownIssuesPath: "./config/known.json";
}

Estructura del Archivo: Consulta la sección Gestión de Problemas Conocidos para más detalles.

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: {
    "Versión de la Aplicación": "2.5.1",
    "Suite de Pruebas": "Regresión v1.2",
    "Fecha de Lanzamiento": "2025-10-20",
    "Número de Compilación": "#1234",
    "Entorno": "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": "sin asignar",
    "layer": "desconocido",
    "tags": ["necesita-revisión"]
  }
}

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 ["necesita-revisión"]
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: {
    "nombre-entorno": {
      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" },
    // ... más etiquetas
  ];
}

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

Ejemplo - Entornos Basados en Sistema Operativo

javascript

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

Ejemplo - Entornos de Despliegue

javascript

{
  environments: {
    staging: {
      matcher: ({ labels }) =>
        labels.find(l => l.name === "env" && l.value === "staging"),
      variables: {
        "Servidor": "staging.example.com",
        "Base de Datos": "staging-db"
      }
    },
    production: {
      matcher: ({ labels }) =>
        labels.find(l => l.name === "env" && l.value === "production"),
      variables: {
        "Servidor": "api.example.com",
        "Base de Datos": "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

7. Archivo de Historial

Formato del Archivo de Historial

Archivo: Formato JSONL (JSON Lines) - un objeto JSON por línea

Ubicación: Configurado mediante historyPath (predeterminado: undefined)

Estructura: Cada línea representa una ejecución de prueba completa

jsonl

{"uuid":"abc-123","name":"Allure Report","timestamp":1697020800000,"knownTestCaseIds":["tc1","tc2"],"testResults":{...},"metrics":{},"url":""}
{"uuid":"def-456","name":"Allure Report","timestamp":1697107200000,"knownTestCaseIds":["tc1","tc2","tc3"],"testResults":{...},"metrics":{},"url":""}

Qué se Rastrea

Cada entrada del historial contiene:

uuid - ID único para esta ejecución del reporte
name - Nombre del reporte
timestamp - Cuándo ocurrió esta ejecución
knownTestCaseIds - Arreglo de IDs de casos de prueba
testResults - Objeto indexado por historyId que contiene resultados de prueba
url - URL remota (ej., URL del trabajo de CI)

Cómo se Usa el Historial

Gráficos de tendencias - Estado, duración a lo largo del tiempo
Detección de pruebas inestables - Patrones inconsistentes de éxito/fallo
Pruebas nuevas/eliminadas - Comparar IDs de casos de prueba entre ejecuciones
Contexto histórico - Mensajes de error previos, duraciones

Configuración

javascript

{
  historyPath: "./.allure/history.jsonl",
  appendHistory: true
}

8. Gestión de Problemas Conocidos

Rastrea fallos de prueba conocidos y vincúlalos a tickets del rastreador de errores.

Configuración

javascript

{
  knownIssuesPath: "./allure/known.json";
}

Estructura del Archivo

Archivo: Arreglo JSON de objetos de problemas conocidos

json

[
  {
    "historyId": "a3f5e9b2c1d4f8a7b6e5c4d3a2f1e0b9",
    "issues": [
      {
        "name": "JIRA-1234",
        "url": "https://jira.example.com/browse/JIRA-1234"
      }
    ],
    "comment": "Prueba inestable conocida debido a problemas de conexión a la base de datos",
    "error": {
      "message": "Tiempo de espera de conexión agotado"
    }
  }
]

Campos

`historyId` (requerido)

Tipo: string
Descripción: El ID de historial de la prueba (identificador interno único para cada prueba)
Formato: Hash MD5 de metadatos de prueba (nombre, ruta, parámetros)
Cómo obtenerlo: De archivos de resultados de prueba sin procesar

`issues` (opcional)

Tipo: Arreglo de objetos de enlace
Descripción: Enlaces a tickets del rastreador de errores

json

{
  "name": "JIRA-1234",
  "url": "https://jira.example.com/browse/JIRA-1234"
}

`comment` (opcional)

Tipo: string
Descripción: Explicación legible del problema conocido

`error` (opcional)

Tipo: Objeto de error
Descripción: Patrón de error esperado para este problema conocido

json

{
  "message": "Tiempo de espera de conexión agotado después de 5000ms",
  "trace": "..."
}

Creación del Archivo de Problemas Conocidos

Automatizado (Recomendado)

Usa el comando CLI para generar automáticamente a partir de pruebas fallidas:

bash

allure known-issue ./allure-results

Qué hace:

Encuentra todas las pruebas fallidas/rotas
Extrae su historyId
Extrae cualquier enlace de tipo "issue" de los metadatos de prueba
Crea known.json con un comentario estándar

Manual

Encuentra el historyId de los archivos de resultados de prueba sin procesar
Crea o edita known.json
Agrega una entrada con los campos deseados

Cómo Funciona

La prueba se ejecuta y tiene un historyId
Allure verifica si este historyId existe en problemas conocidos
Si se encuentra una coincidencia:
- La prueba se marca como "fallo conocido"
- Se muestran los enlaces de problemas
- Se muestra el comentario
- Puede afectar la evaluación de Quality Gate

Casos de Uso

Rastrear pruebas inestables conocidas
Vincular fallos al rastreador de errores
Proporcionar contexto a los miembros del equipo
Separar "nuevos fallos" de "problemas conocidos"
Documentar fallos esperados

9. 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/estilo Allure 2
allure2 - Compatibilidad con Allure 2
dashboard - Vista de tablero con gráficos
log - Salida de registro de consola
csv - Exportación a CSV
slack - Integración con Slack
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

Para habilitar un plugin en tu proyecto, instala el paquete del plugin:

npm add @allurereport/plugin-name

Y 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: {} }
  }
}

10. 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", "class", "method"];

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

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

charts (ChartOptions[])

Configuración de gráficos/widgets
Consulta la Referencia de Configuración de Gráficos para más detalles

Ejemplo de Configuración

javascript

{
  plugins: {
    awesome: {
      options: {
        singleFile: false,
        reportLanguage: "en",
        reportName: "Mi Reporte Awesome",
        groupBy: ["epic", "feature", "story"]
      }
    }
  }
}

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áficos 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)

Arreglo de definiciones de gráficos/widgets

Estructura de widget:

javascript

{
  type: "pie" | "trend" | "bar" | "treemap" | "heatmap" | "funnel",
  dataType?: string,  // Opcional, varía según el tipo de widget
  title: string
}

Ejemplo de Configuración

javascript

{
  plugins: {
    dashboard: {
      options: {
        reportName: "Tablero de Pruebas",
        reportLanguage: "en",
        layout: [
          {
            type: "pie",
            title: "Distribución de Estado de Pruebas"
          },
          {
            type: "trend",
            dataType: "status",
            title: "Estado a lo Largo del Tiempo"
          },
          {
            type: "bar",
            dataType: "statusBySeverity",
            title: "Resultados por Severidad"
          }
        ]
      }
    }
  }
}

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de DashboardPluginOptions

Nota: Dashboard genera un reporte independiente separado de los plugins awesome/classic.

Plugin Classic

UI clásica estilo Allure 2.

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 Log

Vista de registro de consola filtrada de resultados de prueba.

Ejemplo de Configuración

javascript

{
  plugins: {
    log: {
      options: {
        groupBy: "none",
        filter: ({ status }) => status === "failed" || status === "broken"
      }
    }
  }
}

Referencia Completa de Opciones

Para todas las opciones disponibles, consulta:

Código fuente de LogPluginOptions

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

12. 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 ./salida-personalizada \
  --name "Nombre Sobrescrito" \
  --history-path ./historial-personalizado.jsonl

Opciones sobrescribibles:

--name / --report-name
--output / -o
--history-path / -h
--known-issues
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 [opciones] <directorio>

Opciones:

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

Dashboard

bash

allure dashboard [opciones] <directorio>

Reporte Classic

bash

allure classic [opciones] <directorio>

Exportación CSV

bash

allure csv [opciones] <directorio>

Salida Log

bash

allure log [opciones] <directorio>

Comandos Utilitarios

Problemas Conocidos

bash

allure known-issue [--output,-o] <directorio>

Genera el archivo de problemas conocidos a partir de pruebas fallidas.

Historial

bash

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

Genera el historial en la carpeta especificada.

Plan de Pruebas

bash

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

Genera testplan.json.

Ayuda

Obtén ayuda detallada para cualquier comando:

bash

allure <comando> --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;
  knownIssuesPath?: string;
  defaultLabels?: DefaultLabelsConfig;
  environments?: EnvironmentsConfig;
  variables?: ReportVariables;
  plugins?: Record<string, PluginDescriptor>;
  appendHistory?: boolean;
  qualityGate?: QualityGateConfig;
  allureService?: {
    url?: string;
    project?: string;
    accessToken?: string;
  };
}

Tipos de Soporte

typescript

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

type ReportVariables = Record<string, string>;

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

type EnvironmentsConfig = Record<string, EnvironmentDescriptor>;

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

interface KnownTestFailure {
  historyId: string;
  issues?: TestLink[];
  comment?: string;
  error?: TestError;
}

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 ​

3. Opciones de Historial ​

historyPath ​

appendHistory ​

4. Opciones de Problemas Conocidos ​

knownIssuesPath ​

5. Variables y Etiquetas ​

variables ​

Ejemplo ​

defaultLabels ​

Ejemplo ​

Cómo Funciona ​

Valores de Etiqueta ​

6. Entornos ​

Estructura ​

Función Matcher ​

Ejemplo - Entornos Basados en Sistema Operativo ​

Ejemplo - Entornos de Despliegue ​

Variables de Entorno ​

Casos de Uso ​

7. Archivo de Historial ​

Formato del Archivo de Historial ​

Qué se Rastrea ​

Cómo se Usa el Historial ​

Configuración ​

8. Gestión de Problemas Conocidos ​

Configuración ​

Estructura del Archivo ​

Campos ​

historyId (requerido) ​

issues (opcional) ​

comment (opcional) ​

error (opcional) ​

Creación del Archivo de Problemas Conocidos ​

Automatizado (Recomendado) ​

Manual ​

Cómo Funciona ​

Casos de Uso ​

9. 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 ​

10. 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 Classic ​

Opciones Comunes ​

Referencia Completa de Opciones ​

Plugin Log ​

Ejemplo de Configuración ​

Referencia Completa de Opciones ​

11. Quality Gate ​

12. Sobreescrituras de Configuración CLI ​

Comandos Específicos de Plugins ​

Reporte Awesome ​

Dashboard ​

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`

3. Opciones de Historial

`historyPath`

`appendHistory`

4. Opciones de Problemas Conocidos

`knownIssuesPath`

5. Variables y Etiquetas

`variables`

Ejemplo

`defaultLabels`

Ejemplo

Cómo Funciona

Valores de Etiqueta

6. Entornos

Estructura

Función Matcher

Ejemplo - Entornos Basados en Sistema Operativo

Ejemplo - Entornos de Despliegue

Variables de Entorno

Casos de Uso

7. Archivo de Historial

Formato del Archivo de Historial

Qué se Rastrea

Cómo se Usa el Historial

Configuración

8. Gestión de Problemas Conocidos

Configuración

Estructura del Archivo

Campos

`historyId` (requerido)

`issues` (opcional)

`comment` (opcional)

`error` (opcional)

Creación del Archivo de Problemas Conocidos

Automatizado (Recomendado)

Manual

Cómo Funciona

Casos de Uso

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

10. 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 Classic

Opciones Comunes

Referencia Completa de Opciones

Plugin Log

Ejemplo de Configuración

Referencia Completa de Opciones

11. Quality Gate

12. Sobreescrituras de Configuración CLI

Comandos Específicos de Plugins

Reporte Awesome

Dashboard