Metadatos de las pruebas de Playwright

probara le cuenta al reporter más cosas sobre una prueba, desde el cuerpo de la prueba, un hook o un fixture. Impórtalo del paquete del reporter:

import { test } from '@playwright/test';
import { probara } from '@probara/playwright-reporter';

test('pays with a card', async () => {
  probara.title('Pays with a saved card').suite(['Payments', 'Cards']).tags('smoke');
});

Los helpers

Helper	Qué hace	Llamadas repetidas
`id(id \| ids)`	Vincula casos existentes (vincular)	Se suman
`title(text)`	Título del caso que crea el informe	Gana la última
`suite(title \| titles)`	Ruta de suites del caso que crea el informe	Gana la última
`comment(text)`	Un comentario, al principio de las notas del resultado, antes del error	Gana la última
`ignore()`	Deja fuera este intento: no se envía	—
`tags(...names)`	Etiquetas del caso que crea el informe	Se suman, cada una una vez
`fields(record)`	Campos del caso que crea el informe: campos de sistema, campos personalizados, `description`	Se combinan por nombre
`parameters(record)`	Parámetros del resultado, que se muestran con él	Se combinan por nombre
`attach({ name, path \| body, ... })`	Adjunta un archivo (adjuntos)	Cada una adjunta
`step(action, expected?, data?)`	Un título de `test.step` que declara un paso del caso nuevo (pasos)	Cada una declara un paso

Cada helper síncrono devuelve probara, así que las llamadas se encadenan; attach() devuelve una promesa que debes esperar con await. Cada helper se aplica solo al intento en curso: un reintento empieza vacío.

Solo casos creados

title, suite, tags, fields y los pasos declarados describen el caso que un informe crea, la primera vez que se envía una prueba. Un caso existente nunca cambia: Probara conserva lo que las personas escribieron en él. La clave de automatización tampoco cambia (claves), así que un título renombrado sigue encontrando el mismo caso.

import { test } from '@playwright/test';
import { probara } from '@probara/playwright-reporter';

test('pays', async () => {
  probara
    .title('Pays with a saved card')
    .suite(['Payments', 'Cards'])
    .tags('smoke', 'payments')
    .fields({
      description: 'A returning customer pays with the card saved in their profile.',
      severity: 'critical',
      priority: 'high',
      'Risk area': 'Checkout',
    });
});

Lo que Probara recibe para esa prueba:

[
  {
    "automationKey": "payments.spec.ts > pays",
    "title": "Pays with a saved card",
    "suitePath": ["Payments", "Cards"],
    "case": {
      "description": "A returning customer pays with the card saved in their profile.",
      "tags": ["smoke", "payments"],
      "fields": { "severity": "critical", "priority": "high", "Risk area": "Checkout" }
    }
  }
]

Campos

fields() acepta nombres y valores; los números y los booleanos se convierten en texto.

Nombre	Qué define
`description`	La descripción del caso
`severity`, `priority`, `type`, `layer`, `behavior`, `status`, `is_flaky`	Los campos de sistema, por el nombre de una opción (`high`)
`preconditions`, `postconditions`	Los campos de texto de sistema
Cualquier otro nombre, como `'Risk area'`	El campo personalizado con ese nombre

Probara resuelve los nombres y las opciones al crear el caso. Un campo o una opción que no conoce se omite y se registra como advertencia; el resultado se registra igualmente. Un campo con el valor vacío se omite sin aviso.

Título y suite

El título de un caso creado es el título de la prueba, sin los IDs de caso, salvo que title() indique otro. Su ruta de suites es el archivo y los títulos de describe (payments.spec.ts > Cards) salvo que suite() indique una: suite('Payments'), o suite(['Payments', 'Cards']) para suites anidadas, que se crean según haga falta bajo suiteUlid.

Comentario

comment() escribe una línea al principio de las notas del resultado, antes del error y de su stack:

import { test } from '@playwright/test';
import { probara } from '@probara/playwright-reporter';

test('searches the catalog', async () => {
  probara.comment('Ran against the staging catalog');
});

[
  {
    "automationKey": "search.spec.ts > searches the catalog",
    "notes": "Ran against the staging catalog"
  }
]

Parámetros

parameters() registra los valores con los que se ejecutó un intento, que se muestran con su resultado, como el usuario o el conjunto de datos de una prueba guiada por datos. Nunca forman parte de la clave: la prueba es un solo caso sean cuales sean sus parámetros. Cuando el caso declara un parámetro con el mismo nombre, el resultado se registra en el caso de ejecución con esos valores, y Probara añade ese caso de ejecución si la ejecución todavía no lo tiene. Un parámetro que el caso no declara se queda en el resultado solo para mostrarlo. El proyecto de Playwright se envía como parámetro de contexto: se muestra en el resultado y nunca se convierte en un parámetro de un caso que un reporte crea.

import { test } from '@playwright/test';
import { probara } from '@probara/playwright-reporter';

for (const role of ['admin', 'viewer']) {
  test(`opens the dashboard as ${role}`, async () => {
    probara.parameters({ role, seats: 5 });
  });
}

[
  {
    "automationKey": "users.spec.ts > opens the dashboard as admin",
    "parameters": { "role": "admin", "seats": "5" }
  },
  {
    "automationKey": "users.spec.ts > opens the dashboard as viewer",
    "parameters": { "role": "viewer", "seats": "5" }
  }
]

Una prueba cuyo título contiene el parámetro, como la de arriba, es un caso por valor. Mantén el título fijo y pasa el valor con parameters() para tener un solo caso con todos los valores en su historial.

Ignorar un intento

ignore() deja fuera el intento en curso: se sigue ejecutando, y Playwright lo informa, pero Probara no lo recibe. El recuento del registro dice cuántos se dejaron fuera.

import { test } from '@playwright/test';
import { probara } from '@probara/playwright-reporter';

test('tries the new checkout', async () => {
  probara.ignore();
});

test('pays', async () => {});

$ npx playwright test
[probara] Sending 1 result of 1 test (1 passed, 0 failed, 0 skipped, 0 blocked); 1 ignored with probara.ignore()
[probara] Recorded 1 result (1 new case, 0 unmatched) in R-1 (closed): https://app.probara.net/projects/SHOP/runs/R-1

Dónde llamar a los helpers

En el cuerpo de la prueba, en beforeEach, en afterEach o en un fixture de prueba: se aplican al intento en curso. No en beforeAll, afterAll ni en un fixture de worker, donde no se ejecuta una prueba concreta.
Un helper nunca lanza errores dentro de la prueba. Un argumento incorrecto, o una llamada cuando no se ejecuta ninguna prueba, es una advertencia [probara] en el stderr de la prueba, y la llamada se ignora.

Un fixture de prueba puede definir metadatos para todas las pruebas que lo usan:

import { test as base } from '@playwright/test';
import { probara } from '@probara/playwright-reporter';

export const test = base.extend<{ account: string }>({
  account: async ({}, use) => {
    probara.parameters({ account: 'demo' });
    await use('demo');
  },
});

import { test } from './fixtures';

test('shows the account', async ({ account }) => {
  test.info().annotations.push({ type: 'note', description: account });
});

[{ "automationKey": "account.spec.ts > shows the account", "parameters": { "account": "demo" } }]

Cómo viajan los metadatos

Playwright ejecuta las pruebas en procesos worker y el reporter en el proceso principal. Los helpers envían sus metadatos como pequeños adjuntos llamados _probara (application/vnd.probara.metadata+json), que pertenecen a un intento, sobreviven a los informes blob y a merge-reports, y nunca se suben. El informe HTML de Playwright los lista con el intento; en Playwright 1.42 cada llamada aparece además ahí como un paso attach. Los IDs de caso viajan como anotaciones probara_case, que el reporter JUnit de Playwright también escribe.

Siguiente: pasos y adjuntos, o traduce tus llamadas qase.* en migrar desde Qase.