Primeros pasos con Allure TestCafe

Genera reportes HTML atractivos usando Allure Report y tus pruebas de TestCafe.

Configuración

1. Prepara tu proyecto

Asegúrate de que Node.js esté instalado.
La integración se prueba con Node.js 18 y versiones superiores. Las versiones anteriores pueden funcionar, pero no lo garantizamos.
Abre una terminal y ve al directorio del proyecto. Por ejemplo:
bash
```
cd /home/user/myproject
```
Asegúrate de que Allure Report esté instalado. Si no lo está, sigue las instrucciones de instalación. Ten en cuenta que Allure Report requiere Java.
Alternativamente, instala Allure Report 3 como un paquete local de npm:
bash
```
npm install --save-dev allure
```

Instala el reporter de Allure TestCafe y asegúrate de que TestCafe también esté listado en las dependencias del proyecto.

npmyarnpnpm

bash

npm install --save-dev testcafe testcafe-reporter-allure-official

bash

yarn add --dev testcafe testcafe-reporter-allure-official

bash

pnpm add -D testcafe testcafe-reporter-allure-official

2. Configura el reporter

La forma recomendada de configurar el reporter es mediante un archivo de configuración en JavaScript. Esto también habilita el filtrado por plan de pruebas, que es necesario para los flujos de trabajo de reintento inteligente y modo agente de Allure.

Crea un archivo .testcaferc.cjs en la raíz de tu proyecto:

const { createAllureTestPlanFilter } = require("testcafe-reporter-allure-official/testplan");

module.exports = {
  src: ["tests/**/*.test.js"],
  browsers: ["chromium:headless"],
  reporter: ["spec", "allure-official"],
  filter: createAllureTestPlanFilter(),
};

La llamada a createAllureTestPlanFilter() devuelve undefined cuando ALLURE_TESTPLAN_PATH no está definido, por lo que TestCafe se ejecuta normalmente en ese caso. Es seguro dejarlo habilitado permanentemente.

INFO

Los archivos de configuración JSON (.testcaferc.json) no pueden usar filtros basados en funciones. Para la configuración recomendada de Allure, utiliza .testcaferc.js, .testcaferc.cjs o la API del runner.

Si solo necesitas el reporter sin soporte para plan de pruebas, puedes usar una configuración JSON:

json

{
  "src": ["tests/**/*.test.js"],
  "browsers": ["chromium:headless"],
  "reporter": ["spec", "allure-official"]
}

O pasar el nombre del reporter en la línea de comandos:

bash

testcafe "chromium:headless" tests -r spec,allure-official

API del runner

Usa la API del runner de TestCafe cuando necesites establecer opciones del reporter como un directorio de salida personalizado o plantillas de enlaces:

const createTestCafe = require("testcafe");
const createAllureTestCafeReporter = require("testcafe-reporter-allure-official");
const { createAllureTestPlanFilter } = require("testcafe-reporter-allure-official/testplan");

(async () => {
  const testcafe = await createTestCafe();

  try {
    const runner = testcafe.createRunner();

    await runner
      .src(["tests/**/*.test.js"])
      .browsers(["chromium:headless"])
      .filter(createAllureTestPlanFilter())
      .reporter(
        createAllureTestCafeReporter({
          resultsDir: "./out/allure-results",
        }),
      )
      .run();
  } finally {
    await testcafe.close();
  }
})();

Consulta Configuración para ver todas las opciones disponibles del reporter.

3. Ejecuta pruebas

Ejecuta tus pruebas de TestCafe de la misma manera que lo harías normalmente. Por ejemplo:

npmyarnpnpm

bash

npx testcafe --config-file .testcaferc.cjs

bash

yarn testcafe --config-file .testcaferc.cjs

bash

pnpm exec testcafe --config-file .testcaferc.cjs

Esto guardará los datos necesarios en allure-results u otro directorio, según la configuración. Si el directorio ya existe, los nuevos archivos se agregarán a los existentes, de modo que un futuro reporte se basará en todos ellos.

4. Genera un reporte

Finalmente, convierte los resultados de prueba en un reporte HTML. Esto se puede hacer con uno de los siguientes comandos:

allure generate procesa los resultados de prueba y guarda un reporte HTML en el directorio allure-report. Para ver el reporte, usa el comando allure open.
allure serve crea el mismo reporte que allure generate, y luego abre automáticamente la página principal del reporte en un navegador web.

Escribir pruebas

Esta sección cubre lo que la integración añade más allá del reporte estándar de TestCafe:

Anotación de metadatos: Mejora los reportes de prueba con descripciones, enlaces y otros metadatos.
Organización de pruebas: Estructura tus pruebas en jerarquías claras para una mejor legibilidad y organización, consulta organizar pruebas.
División en pasos: Divide las pruebas en pasos de prueba más pequeños para facilitar la comprensión y el mantenimiento.
Hooks: Usa la API en tiempo de ejecución dentro de hooks de fixture y prueba para añadir etiquetas, pasos y adjuntos desde el código de setup y limpieza.
Pruebas parametrizadas: Describe claramente los parámetros para pruebas parametrizadas y especifica diferentes escenarios.
Establecer etiquetas globalmente: Usa variables de entorno para establecer metadatos y otras etiquetas.
Adjuntos: Añade capturas de pantalla y otros archivos al reporte de prueba.
Selección de pruebas: Usa un archivo de plan de pruebas para seleccionar qué pruebas ejecutar, permitiendo una ejecución flexible.
Detalles de entorno: Incluye información completa del entorno para acompañar el reporte de prueba.

Allure TestCafe proporciona tres formas de asignar metadatos y anotaciones a las pruebas:

API en tiempo de ejecución: llama a las funciones de Allure desde allure-js-commons durante la ejecución de la prueba para añadir datos dinámicamente.
Se recomienda llamar a estas funciones lo más cerca posible del inicio de la prueba para que los datos se registren incluso si la prueba falla temprano.
API Meta: establece metadatos de fixture o prueba usando claves específicas de Allure. Este es el enfoque más robusto: los metadatos se resuelven antes de que la prueba comience y se garantiza su presencia en el reporte.
Anotaciones en el título: incrusta anotaciones directamente en el nombre de la prueba usando la sintaxis @allure.<type>=<value>. Estas se extraen al inicio de la prueba, antes de que se ejecute el cuerpo.

Añadir metadatos

Añade descripciones, enlaces, etiquetas y más a tus resultados de prueba. Consulta la referencia para la lista completa.

API en tiempo de ejecuciónAPI MetaAnotaciones en el título

const { displayName, owner, tags, severity } = require("allure-js-commons");

fixture`Authentication`.page`https://example.com/login`;

test("sign in", async () => {
  await displayName("Sign in");
  await owner("alice");
  await tags("Web interface", "Authentication");
  await severity("critical");
  // ...
});

fixture`Authentication`.page`https://example.com/login`.meta({
  "allure.label.tag": ["Web interface", "Authentication"],
});

test.meta({
  "allure.label.owner": "alice",
  "allure.label.severity": "critical",
})("sign in", async (t) => {
  // ...
});

fixture`Authentication`.page`https://example.com/login`;

test(
  "sign in" +
    " @allure.label.owner=alice" +
    " @allure.label.tag=WebInterface" +
    " @allure.label.tag=Authentication" +
    " @allure.label.severity=critical",
  async () => {
    // ...
  },
);

Organizar pruebas

Como se describe en Mejorar la navegación en tu reporte de prueba, Allure soporta múltiples formas de organizar pruebas en estructuras jerárquicas.

Para especificar la ubicación de una prueba en la jerarquía basada en comportamiento:

API en tiempo de ejecuciónAPI MetaAnotaciones en el título

const { epic, feature, story } = require("allure-js-commons");

fixture`Authentication`.page`https://example.com/login`;

test("sign in", async () => {
  await epic("Web interface");
  await feature("Essential features");
  await story("Authentication");
  // ...
});

fixture`Authentication`.page`https://example.com/login`.meta({
  "allure.label.epic": "Web interface",
  "allure.label.feature": "Essential features",
});

test.meta({
  "allure.label.story": "Authentication",
})("sign in", async (t) => {
  // ...
});

fixture`Authentication`.page`https://example.com/login`;

test(
  "sign in" +
    " @allure.label.epic=WebInterface" +
    " @allure.label.feature=EssentialFeatures" +
    " @allure.label.story=Authentication",
  async () => {
    // ...
  },
);

Para especificar la ubicación de una prueba en la jerarquía basada en suite:

API en tiempo de ejecuciónAPI MetaAnotaciones en el título

const { parentSuite, suite, subSuite } = require("allure-js-commons");

fixture`Authentication`.page`https://example.com/login`;

test("sign in", async () => {
  await parentSuite("Tests for web interface");
  await suite("Tests for essential features");
  await subSuite("Tests for authentication");
  // ...
});

fixture`Authentication`.page`https://example.com/login`.meta({
  "allure.label.parentSuite": "Tests for web interface",
  "allure.label.suite": "Tests for essential features",
});

test.meta({
  "allure.label.subSuite": "Tests for authentication",
})("sign in", async (t) => {
  // ...
});

fixture`Authentication`.page`https://example.com/login`;

test(
  "sign in" +
    " @allure.label.parentSuite=TestsForWebInterface" +
    " @allure.label.suite=TestsForEssentialFeatures" +
    " @allure.label.subSuite=TestsForAuthentication",
  async () => {
    // ...
  },
);

Divide una prueba en pasos

Para crear pasos y subpasos, utiliza la función step() de allure-js-commons. Consulta la referencia para la API completa.

Además, el reporter captura automáticamente acciones de TestCafe como t.click(), t.typeText() y t.expect() como pasos. Estos pasos automáticos aparecen anidados bajo cualquier paso explícito que los contenga. Para desactivar la captura automática de acciones, establece captureActionsAsSteps: false en la configuración del reporter.

const { step, logStep, Status } = require("allure-js-commons");

fixture`Authentication`.page`https://example.com/login`;

test("sign in", async (t) => {
  await step("Fill credentials", async () => {
    await step("Enter login", async (ctx) => {
      await ctx.parameter("login", "demo-user");
      await t.typeText("#login", "demo-user");
    });
    await t.typeText("#password", "secret").click("#submit");
  });
  await logStep("Verified", Status.PASSED);
});

Hooks

La API en tiempo de ejecución funciona en hooks de fixture y prueba de TestCafe. Las etiquetas, pasos y adjuntos añadidos dentro de los hooks se registran como parte del resultado de prueba correspondiente.

Hooks de fixtureHooks de prueba

const { owner, step, attachment } = require("allure-js-commons");

fixture`Authentication`.page`https://example.com/login`
  .beforeEach(async (t) => {
    await owner("alice");
    await step("Dismiss cookie banner", async () => {
      await t.click("#accept-cookies");
    });
  })
  .afterEach(async () => {
    await step("Capture session log", async () => {
      await attachment("session.log", "...", "text/plain");
    });
  });

test("sign in", async (t) => {
  // ...
});

const { severity, tag, step } = require("allure-js-commons");

fixture`Authentication`.page`https://example.com/login`;

test
  .before(async (t) => {
    await tag("smoke");
    await step("Seed credentials", async () => {
      await t.typeText("#username", "demo");
    });
  })
  .after(async () => {
    await severity("critical");
  })("sign in", async (t) => {
  // ...
});

Describe pruebas parametrizadas

Una forma típica de implementar pruebas parametrizadas en TestCafe es definir una prueba en un bucle. Para mostrar el valor de un parámetro en el reporte de prueba, pásalo a la función parameter().

Además, cualquier clave meta que no sea específica de Allure (allure.*) y cuyo valor sea un string, número, booleano o bigint, se añade automáticamente como parámetro de prueba. Esto te permite anotar variantes de prueba con meta simple sin llamadas a la API en tiempo de ejecución:

API en tiempo de ejecuciónAPI Meta

const { parameter } = require("allure-js-commons");

fixture`Authentication`.page`https://example.com/login`;

for (const login of ["johndoe", "[email protected]"]) {
  test(`sign in as ${login}`, async () => {
    await parameter("login", login);
    await parameter("timestamp", new Date().toISOString(), { excluded: true });
    // ...
  });
}

fixture`Authentication`.page`https://example.com/login`;

for (const [login, role] of [
  ["johndoe", "user"],
  ["admin", "admin"],
]) {
  test.meta({ login, role })(`sign in as ${login}`, async (t) => {
    // login y role aparecen como parámetros en el reporte
    // ...
  });
}

Establecer etiquetas globalmente

Cualquier etiqueta, incluyendo etiquetas personalizadas, puede establecerse mediante variables de entorno en tu sistema operativo. Aquí tienes un ejemplo (asumiendo que usas el gestor de paquetes npm):

MacOS/LinuxWindows

bash

export ALLURE_LABEL_epic=WebInterface
npx testcafe --config-file .testcaferc.cjs

powershell

$Env:ALLURE_LABEL_epic = "WebInterface"
npx testcafe --config-file .testcaferc.cjs

Alternativamente, establece globalLabels en la configuración del reporter (solo API del runner) para aplicar etiquetas a cada resultado de prueba en la ejecución. Consulta Configuración.

Adjuntar archivos

Los reportes generados por Allure pueden incluir cualquier archivo adjunto a la prueba usando allure.attachment() o allure.attachmentPath(). Consulta Adjuntos.

const { attachment, attachmentPath } = require("allure-js-commons");
const { ContentType } = require("allure-js-commons");
const path = require("node:path");

fixture`Authentication`.page`https://example.com/login`;

test("sign in", async () => {
  // ...

  await attachment("Server response", JSON.stringify({ status: "ok" }), "application/json");

  await attachmentPath("Config file", path.join(__dirname, "config.txt"), ContentType.TEXT);
});

Capturas de pantalla y videos automáticos

Cuando TestCafe está configurado para capturar capturas de pantalla o grabar videos, el reporter los adjunta automáticamente al resultado de prueba correspondiente. No se necesita configuración adicional más allá de tu setup de TestCafe.

Las capturas de pantalla tomadas al fallar se adjuntan al paso de acción fallido cuando TestCafe proporciona suficiente información para vincularlas. Las capturas de pantalla solicitadas explícitamente mediante t.takeScreenshot() aparecen como adjuntos en el paso takeScreenshot.

Al ejecutar pruebas en varios navegadores, las capturas de pantalla y videos se atribuyen al resultado correspondiente por navegador. Además, se añade automáticamente un parámetro Browser a cada resultado, mostrando el nombre del navegador.

Modo cuarentena

Cuando TestCafe ejecuta pruebas en modo cuarentena, el reporter adjunta un archivo JSON Quarantine que resume el resultado de cada intento. Si la prueba se marca como inestable por TestCafe — es decir, aprobó después de fallos previos en la misma ejecución — el reporter también añade automáticamente un tag "unstable" al resultado.

Advertencias y errores

Si TestCafe produce advertencias durante una prueba, se adjuntan automáticamente como un archivo de texto Warnings en el resultado afectado. Cuando una prueba produce múltiples errores, o cuando un solo error no tiene información de diagnóstico completa, se añade un adjunto de texto formateado Errors al resultado.

Seleccionar pruebas mediante un archivo de plan de pruebas

Cuando la variable de entorno ALLURE_TESTPLAN_PATH está definida y apunta a un archivo existente, el helper createAllureTestPlanFilter() filtra las pruebas para incluir solo las listadas en el plan.

Crea un archivo de plan de pruebas de Allure:

json

{
  "version": "1.0",
  "tests": [
    {
      "selector": "tests/auth.test.js#Authentication#sign in"
    },
    {
      "id": "42"
    }
  ]
}

El formato de selector es <file>#<fixture>#<test>, donde <test> es el nombre limpio de la prueba, sin anotaciones en el título. Las pruebas también pueden coincidir por su Allure ID, establecida mediante la clave meta "allure.id" o la anotación de título @allure.id=<value>. Debido a que el filtrado ocurre antes de que se ejecute el cuerpo de la prueba, la función en tiempo de ejecución allureId() no puede usarse para registrar una prueba para selección por plan.

Establece ALLURE_TESTPLAN_PATH y ejecuta normalmente. El filtro solo tiene efecto cuando la variable está definida:

MacOS/LinuxWindows

bash

export ALLURE_TESTPLAN_PATH=testplan.json
npx testcafe --config-file .testcaferc.cjs

powershell

$Env:ALLURE_TESTPLAN_PATH = "testplan.json"
npx testcafe --config-file .testcaferc.cjs

El filtrado por plan de pruebas requiere un archivo de configuración JS/CJS o la API del runner para que createAllureTestPlanFilter() pueda conectarse como función de filtro de TestCafe. No es posible usar esta función con un archivo de configuración JSON.

Información del entorno

Para incluir detalles del entorno en la página principal del reporte, pasa pares clave-valor en la opción environmentInfo al usar la API del runner. Consulta Configuración.

Instalación y Actualización

Instalación y Actualización

Primeros pasos con Allure TestCafe

Configuración

1. Prepara tu proyecto

2. Configura el reporter

API del runner

3. Ejecuta pruebas

4. Genera un reporte

Escribir pruebas

Añadir metadatos

Organizar pruebas

Divide una prueba en pasos

Hooks

Describe pruebas parametrizadas

Establecer etiquetas globalmente

Adjuntar archivos

Capturas de pantalla y videos automáticos

Modo cuarentena

Advertencias y errores

Seleccionar pruebas mediante un archivo de plan de pruebas

Información del entorno

Powered by

Suscríbete a nuestro boletín

Allure TestOps

Compañía

Primeros pasos con Allure TestCafe ​

Configuración ​

1. Prepara tu proyecto ​

2. Configura el reporter ​

API del runner ​

3. Ejecuta pruebas ​

4. Genera un reporte ​

Escribir pruebas ​

Añadir metadatos ​

Organizar pruebas ​

Divide una prueba en pasos ​

Hooks ​

Describe pruebas parametrizadas ​

Establecer etiquetas globalmente ​

Adjuntar archivos ​

Capturas de pantalla y videos automáticos ​

Modo cuarentena ​

Advertencias y errores ​

Seleccionar pruebas mediante un archivo de plan de pruebas ​

Información del entorno ​

Powered by

Suscríbete a nuestro boletín

Allure TestOps

Compañía

Primeros pasos con Allure TestCafe

Configuración

1. Prepara tu proyecto

2. Configura el reporter

API del runner

3. Ejecuta pruebas

4. Genera un reporte

Escribir pruebas

Añadir metadatos

Organizar pruebas

Divide una prueba en pasos

Hooks

Describe pruebas parametrizadas

Establecer etiquetas globalmente

Adjuntar archivos

Capturas de pantalla y videos automáticos

Modo cuarentena

Advertencias y errores

Seleccionar pruebas mediante un archivo de plan de pruebas

Información del entorno