# Solución de problemas del reporter de Vitest > Problemas de @probara/vitest-reporter y sus soluciones, cada línea que registra el reporter, PROBARA_DEBUG, y cómo comprobar qué se enviaría sin enviarlo. Cada entrada parte de lo que ves, y después explica por qué y qué hacer. El reporter escribe en stderr, en líneas `[probara]`; [`PROBARA_DEBUG=true`](#probara_debug) añade cada petición. Sea cual sea el problema, el código de salida de Vitest sigue siendo el de las pruebas. La [última sección](#cada-línea-que-registra-el-reporter) recoge cada línea que registra el reporter. ## No se reporta nada, y no se registra nada **Por qué.** Sin un token y un proyecto, el reporter queda desactivado y en silencio, a propósito: las ejecuciones locales y los builds de forks no envían nada. Solo lo indica en debug: ```text $ PROBARA_DEBUG=true npx vitest run [probara] Probara reporting is not configured: set PROBARA_API_TOKEN and PROBARA_PROJECT to enable it ``` **Solución.** Pasa al paso que ejecuta `vitest` el secreto `PROBARA_API_TOKEN`, y define el proyecto (`projectId` o `PROBARA_PROJECT`). Comprueba que el reporter está en los `reporters` de la configuración raíz que usa Vitest: `--reporter` en la línea de comandos sustituye los reporters de la configuración, así que `vitest run --reporter=dot` se ejecuta sin el reporter, y sin ninguna línea `[probara]`. ## El envío está desactivado: un problema de configuración ```text $ PROBARA_RUN_ULID=R-12 npx vitest run [probara] Probara reporting is off: PROBARA_RUN_ULID is not a ULID ``` **Por qué.** Un ajuste tiene un valor incorrecto, o solo está definido uno de los dos, el token o el proyecto. Cada problema se registra, nombrando la opción o la variable afectada (nunca su valor), y no se envía nada. Los más habituales: `The API token is not set: pass apiToken or set PROBARA_API_TOKEN` y `The project is not set: pass projectId or set PROBARA_PROJECT`. **Solución.** Corrige el ajuste que nombra la línea ([opciones](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#opciones)). ## Probara responde 401 o 403 ```text $ npx vitest run [probara] Sending 3 results of 3 tests (3 passed, 0 failed, 0 skipped, 0 blocked) [probara] 3 results were not sent: Probara answered 401 unauthorized: . No run was created or updated ``` **Por qué.** `401`: el token es incorrecto, está revocado o es de otro Probara (`baseUrl`). `403`: el token no puede reportar en ese proyecto, o la organización está en el plan Free (el envío de resultados desde CI necesita un plan de pago). **Solución.** Crea un token de aplicación nuevo desde la tarjeta **Vitest** ([primeros pasos](https://docs.probara.net/es/developers/ci-integrations/vitest/#1-crea-un-token-de-aplicación)) y actualiza el secreto; comprueba el ID del Proyecto; comprueba el plan de la organización. ## La ejecución quedó abierta La línea de error termina con `The run R-4 was left open: `, o, si ni siquiera llegó el primer informe, con `No run was created or updated`. Tras los reintentos, el motivo dice algo como `Could not send the report after 5 attempts: the last one timed out after 30000 ms`. **Por qué.** Un informe falló tras sus reintentos (Probara inalcanzable, un informe rechazado): los informes posteriores no se envían, y una ejecución que ya tiene resultados queda abierta, para que nada parezca completo cuando no lo está. La ejecución de una [sesión watch](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#modo-watch) y una ejecución reutilizada (`run.ulid`) quedan abiertas a propósito. **Solución.** Define un [archivo de resultados](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#archivo-de-resultados): lo que no se envió va ahí, con la ejecución a la que pertenece, y `probara import results` lo envía a esa ejecución y la cierra. Si no, cierra la ejecución a mano con `npx @probara/cli run close --run-ulid `, y vuelve a ejecutar las pruebas. ## Un job envía después de cerrarse su ejecución En GitHub Actions los jobs de un mismo workflow comparten una ejecución, y un job final la cierra. Un job que envía después de ese cierre recibe `409 ci_run_closed` (la ejecución ya estaba cerrada): el reporter registra el motivo, no envía nada más, y las pruebas conservan su código de salida. **Por qué.** Un job que envía no está en el `needs` del job final, así que el job final cerró la ejecución antes de que ese job enviara. O un job en paralelo cerró la ejecución al terminar porque no tenía `PROBARA_CLOSE_RUN: false`, y los jobs posteriores reciben el mismo error. **Solución.** Mantén cada job que envía en el `needs` del job final, y define `PROBARA_CLOSE_RUN: false` en cada job en paralelo. La sección [jobs en paralelo](https://docs.probara.net/es/developers/ci-integrations/vitest/ci-providers/#jobs-en-paralelo-una-ejecución-cerrada-por-el-job-final) tiene el workflow completo. ## Resultados no registrados (unmatched) ```text $ PROBARA_CREATE_MISSING_CASES=false npx vitest run --no-file-parallelism [probara] Sending 3 results of 3 tests (3 passed, 0 failed, 0 skipped, 0 blocked) [probara] Recorded 1 result (0 new cases, 2 unmatched) in R-1 (closed): https://app.probara.net/projects/SHOP/runs/R-1 [probara] 2 results were not recorded (case_not_found): tests/cart.test.ts > cart > removes an item; tests/login.test.ts > login > logs in with a valid password ``` **Por qué.** Un resultado nombra un caso que no existe (una errata en un ID, un caso de otro proyecto), o no coincide con ningún caso mientras `createMissingCases` está desactivado. Probara registra los demás e indica cuáles se dejaron fuera, con el motivo. **Solución.** Corrige el ID, crea el caso, o deja que el reporter cree los casos que faltan (el valor por defecto). ## Cada ejecución crea casos nuevos **Por qué.** Las claves de automatización cambiaron: se renombró o se movió una prueba, un `describe` o un archivo, `vitest` se ejecuta con otra raíz que antes (las claves son relativas a ella), cambió `keyIncludesFile` ([qué cambia una clave](https://docs.probara.net/es/developers/ci-integrations/vitest/linking/#claves-de-automatización)), o una actualización de Vitest escribe de otra forma algunos títulos de `test.each` ([de Vitest 4 a 5](https://docs.probara.net/es/developers/ci-integrations/vitest/migrating/#de-vitest-4-a-5)). **Solución.** Nombra los casos en los títulos ([vincular](https://docs.probara.net/es/developers/ci-integrations/vitest/linking/)), para que un cambio de nombre los conserve. Define `rootDir` cuando `vitest` se ejecute desde directorios distintos. Antes de una refactorización o de una actualización, [compara las claves](#comprobar-qué-se-enviaría). ## Un archivo de prueba no se reporta **Por qué.** Vitest nunca lo ejecutó: `--bail` detuvo antes la ejecución, o la ejecución se interrumpió (`Ctrl+C`). No tiene ninguna prueba que reportar, y una advertencia cuenta esos archivos: `Vitest did not run 1 test file of this run: nothing of it is reported`. Un archivo que Vitest ejecutó pero no pudo cargar sí se reporta: un resultado fallido con el nombre del archivo ([errores fuera de una prueba](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#errores-fuera-de-una-prueba)). **Solución.** Vuelve a ejecutar las pruebas sin `--bail`, o deja que la ejecución termine. Las pruebas que Vitest dejó en espera en un archivo que había empezado se envían como omitidas, con la nota `Not run: the test run was interrupted` ([estados](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#estados)). ## Solo se envió el último intento de una prueba reintentada **Por qué.** El archivo de setup del reporter no se ejecutó en esas pruebas, así que sus intentos anteriores no dejaron registro, y una advertencia dice cuántas: `Vitest retried or repeated 1 test whose earlier attempts were not recorded: only its final attempt is reported`. O bien un shard se ejecutó con `--reporter=blob` solo en la línea de comandos, que sustituye los reporters de la configuración, o el reporter no pudo añadir su archivo de setup a un proyecto (una advertencia al empezar nombra el proyecto). **Solución.** Nombra el reporter junto a `blob` en la línea de comandos de los shards, `--reporter=blob --reporter=@probara/vitest-reporter` ([el reporter va junto a `blob`](https://docs.probara.net/es/developers/ci-integrations/vitest/sharding/#el-reporter-va-junto-a-blob)). ## Un helper advierte que solo funciona mientras corre una prueba **Por qué.** Se llamó a un helper `probara.*` fuera de una prueba: al principio de un archivo, en el cuerpo de un `describe`, en `beforeAll` o en `afterAll`. No se registra nada, y la prueba continúa. La advertencia está en la salida del archivo de prueba (`stderr | tests/...`), una vez por helper y archivo. **Solución.** Llámalo en la prueba, en `beforeEach`, en `afterEach` o en `onTestFinished` ([dónde llamar a los helpers](https://docs.probara.net/es/developers/ci-integrations/vitest/metadata/#dónde-llamar-a-los-helpers)). ## Se descartó una llamada a un helper | Ves | Por qué, y qué hacer | | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `probara.() is dropped in a concurrent test: this worker cannot tell which test calls it without the reporter's runner` | Una prueba `test.concurrent` donde no se ejecuta el runner del reporter: en [modo navegador](https://docs.probara.net/es/developers/ci-integrations/vitest/browser-mode/), o con un `runner` propio que Node no puede importar. Haz la prueba secuencial, o escribe el runner en JavaScript | | `the runner of project "" is , which Node does not import: the reporter keeps it as it is` | El `runner` propio del proyecto es un archivo que el `import()` de Node no puede cargar (`.jsx`, `.tsx`): el reporter lo deja tal cual. Los intentos se siguen registrando; las llamadas de sus pruebas `test.concurrent` se descartan. Escribe el runner en `.js` o `.mjs` | | `the runner of project "" is TypeScript, which this Node cannot import: the reporter keeps it as it is` | Lo mismo, para un runner `.ts` en un Node que no puede ejecutar TypeScript por sí mismo. Usa un Node más reciente, o escribe el runner en JavaScript | | `the probara.* helpers cannot see the running test: ` | Falló en ese worker la forma que tiene Vitest de nombrar la prueba en curso (un Vitest que el reporter aún no conoce): sus llamadas a los helpers se descartan. Repórtalo, con la versión de Vitest | | `probara.() could not be recorded: ` | El helper falló por dentro, y la llamada se ignora. Repórtalo | | Ninguna advertencia, y nada registrado | El reporter no está entre los reporters de la ejecución (`--reporter` en la línea de comandos): cada helper no hace nada, y `probara.step()` sigue ejecutando su cuerpo | ## La selección ejecutó todas las pruebas **Por qué.** Con `runCasesOnly`, el reporter no pudo saber qué pruebas pertenecen a la ejecución, así que todas las pruebas se ejecutaron y se reportaron, en lugar de ninguna. Una advertencia dice por qué: no hay `PROBARA_RUN_ULID`, no se pudieron leer los casos de la ejecución (un ULID incorrecto, un token de otra organización), un proyecto de navegador, o un shard que escribe un blob. **Solución.** Sigue lo que dice la advertencia ([cuando no puede seleccionar](https://docs.probara.net/es/developers/ci-integrations/vitest/run-selection/#cuando-no-puede-seleccionar)). Si en cambio se omitieron todas las pruebas, ninguna pertenece a la ejecución: comprueba el ULID, y que las pruebas nombran los casos de la ejecución o tienen sus claves. ## captureOutput no adjunta nada **Por qué.** `captureOutput` está desactivado (el valor por defecto), o la salida es de un tipo que deja fuera: una prueba `test.concurrent` (una advertencia las cuenta), salida escrita fuera de una prueba (el código del propio archivo, un `beforeAll` o un `afterAll`), o una prueba reintentada cuyos intentos no se registraron ([salida de consola](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#salida-de-consola)). **Solución.** Activa `captureOutput`, y escribe con `console` dentro de la prueba, de un `beforeEach` o de un `afterEach`, en una prueba que no sea `test.concurrent`. ## Falta un adjunto **Por qué.** El registro nombra cada archivo que dejó fuera, y por qué: el archivo no existía cuando se ejecutó `probara.attach()` (se copia en ese momento), es una carpeta o pesa más de 32 MiB, una imagen de más de 10 MiB o de 8192 px, un tipo de contenido rechazado, más de 20 archivos en un resultado, o, en una fusión, una copia que nombra el blob y que no llegó con el `attachmentsDir` ([límites](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#límites-y-qué-se-omite)). Un archivo adjuntado dentro de un paso va a ese paso, no al resultado. **Solución.** Adjunta un archivo que exista cuando llamas a `probara.attach()`, espera la llamada con `await`, mantén los archivos dentro de los límites, y lleva el `attachmentsDir` con los blobs ([dónde se guardan las copias](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#dónde-se-guardan-las-copias)). ## Modo navegador | Ves | Por qué, y qué hacer | | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `probara.attach() did not attach "": Vite does not serve "" (server.fs.allow or server.fs.deny)` | El archivo está fuera de las carpetas que sirve Vite, o Vite lo deniega. Adjunta un archivo dentro del proyecto, o un cuerpo ([`probara.attach()` en un navegador](https://docs.probara.net/es/developers/ci-integrations/vitest/browser-mode/#probaraattach-en-un-navegador)) | | `probara.attach() did not attach "": Vite's file rules are not reachable from this run, so "" is not served` | El reporter no pudo cargar el Vite con el que se ejecuta el Vitest del proyecto, así que no lee ninguna ruta. Adjunta un cuerpo, y repórtalo | | `probara.attach() "" of "" settled after the test ended, so it is not attached. Await probara.attach() before the test ends` | La prueba no esperó la llamada: `await probara.attach(...)` | | `Vite has no isFileLoadingAllowed (it arrived in 5.4): the browser attach follows its isFileServingAllowed` | Un aviso, una vez por proceso: Vite 5.0 a 5.3 tienen una comprobación de archivos más antigua, que es la que decide. Actualiza Vite a 5.4 o posterior para tener sus reglas actuales | | `Vite exports neither isFileLoadingAllowed nor isFileServingAllowed: the browser attach refuses every path` | Un aviso, una vez por proceso: ese Vite no tiene comprobación de archivos, así que no se lee ninguna ruta. Adjunta cuerpos, o actualiza Vite | | `runCasesOnly does not apply in browser mode yet: the tests of project "" run and are reported` | La selección de pruebas aún no está disponible en modo navegador: todas las pruebas del proyecto se ejecutan y se reportan | | `could not add the browser setup file to project "" (): ...` | Ese proyecto no registra ningún intento ni ninguna llamada a los helpers. Repórtalo, con la versión de Vitest | | `could not add the browser commands to project "" (): ...`, `could not give the browser commands to project "": ` | `probara.attach()` no copia ningún archivo en ese proyecto. Repórtalo, con la versión de Vitest | ## Un shard no envía nada `Sharded run with the blob reporter: the results are reported by vitest --merge-reports` es lo esperado: un shard que escribe un blob no envía nada, para que ningún resultado se envíe dos veces. Ejecuta `vitest --merge-reports` con el reporter en su configuración: esa ejecución reporta todos los shards ([patrón 1](https://docs.probara.net/es/developers/ci-integrations/vitest/sharding/#patrón-1-fusionar-los-informes-blob)). Un shard con `--reporter=blob` solo en la línea de comandos se ejecuta sin el reporter, y no registra nada. ## Los errores no gestionados no se envían **Por qué.** Los errores que no pertenecen a ninguna prueba (una promesa que ninguna prueba esperó, un error lanzado desde un temporizador) no son resultados. Vitest hace fallar la ejecución por ellos; Probara no recibe ningún resultado, porque no falló ninguna prueba, y una advertencia los cuenta ([errores fuera de una prueba](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#errores-fuera-de-una-prueba)): `Vitest reported 2 unhandled errors outside the tests: they are not results, and nothing is sent for them`. **Solución.** Corrige el código: la salida de Vitest, encima de las líneas `[probara]`, muestra el error completo. ## Probara responde 429 (demasiadas peticiones) **Por qué.** El límite de peticiones de la organización (60 peticiones por minuto en Free, 1.200 en Pro y 3.000 en Enterprise) lo comparten todos los tokens y pipelines. Los adjuntos cuestan dos peticiones por resultado ([límite de peticiones](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#límite-de-peticiones)). **Solución.** El reporter espera y reintenta por sí solo. En baterías grandes, adjunta menos, reduce `attachmentConcurrency`, o reparte en el tiempo los pipelines con sharding. ## Depuración ### El registro El reporter escribe solo en **stderr**, a través del propio logger de Vitest, con cada línea precedida de `[probara]`. Stdout sigue siendo de Vitest: un reporter que imprime JSON ahí (`--reporter=json`) nunca recibe una línea del reporter. Una ejecución que reporta registra dos líneas: ```text $ npx vitest run [probara] Sending 3 results of 3 tests (3 passed, 0 failed, 0 skipped, 0 blocked) [probara] Recorded 3 results (2 new cases, 0 unmatched) in R-1 (closed): https://app.probara.net/projects/SHOP/runs/R-1 ``` | Línea | Qué dice | | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | `Sending N results of M tests (...)` | Antes de enviar nada: un resultado por intento y caso, por estado después de `statusMapping`, y lo que se dejó fuera | | `Recorded N results (...) in R-1` | Por ejecución: lo que registró Probara, los casos que creó, los resultados que no pudo asociar, y el enlace | | `N results were not recorded (...)` | Los resultados no asociados, por motivo, con sus casos o claves | | `Attached N files to results (...)` | Subidas: adjuntadas, omitidas y fallidas | | `N results were not sent: ...` | Un informe fallido: el motivo, y la ejecución que quedó abierta | | `Wrote ... to ` | Lo que fue al archivo de resultados | | `Ran only the tests of run : ...` | Selección de pruebas: cuántas pruebas coincidieron con los casos de la ejecución, y cuántas se omitieron y se dejaron fuera | | `Watch mode: every re-run reports into R-1 of SHOP, ...` | Modo watch: la única ejecución de la sesión, que queda abierta, y el comando que la cierra | | `Sharded run with the blob reporter: ...` | Un shard que escribe un blob: no envía nada, y `vitest --merge-reports` reporta sus resultados | | `Probara reporting is off: ...` | Un problema de configuración: no se envía nada ([el envío está desactivado](#el-envío-está-desactivado-un-problema-de-configuración)) | ### Advertencias Una advertencia que se repetiría se registra una vez, la primera; con `PROBARA_DEBUG`, el registro del reporter muestra también las repeticiones. Su origen decide dónde aparece y cómo termina: | Advertencia sobre | Se registra | | ------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- | | Una llamada o un archivo de una prueba, o las pruebas de la ejecución | Una vez por ejecución, terminando en `(first seen in the run; repeats are logged at debug)` | | Un resultado al enviarse (un adjunto omitido, un paso descartado) | Una vez por ejecución, terminando en `(first seen in ""...; repeats are logged at debug)` | | Una llamada `probara.*` donde no corre ninguna prueba, o que ninguna prueba puede reclamar | En la salida del archivo de prueba (`stderr \| tests/...`), una vez por archivo | | La configuración de la ejecución (una opción desconocida, un proyecto) | Una vez, cuando arranca Vitest | Dos pruebas que adjuntan el mismo archivo inexistente, por ejemplo: ```ts // tests/checkout.test.ts import { probara } from '@probara/vitest-reporter'; import { test } from 'vitest'; test('pays by card', async () => { await probara.attach({ name: 'receipt', path: 'receipt.txt' }); }); test('pays by transfer', async () => { await probara.attach({ name: 'receipt', path: 'receipt.txt' }); }); ``` ```text $ npx vitest run [probara] probara.attach() did not attach "receipt": it does not exist (first seen in the run; repeats are logged at debug) [probara] Sending 2 results of 2 tests (2 passed, 0 failed, 0 skipped, 0 blocked) [probara] Recorded 2 results (2 new cases, 0 unmatched) in R-1 (closed): https://app.probara.net/projects/SHOP/runs/R-1 ``` El token nunca aparece en ninguna línea, ni siquiera cuando la respuesta de Probara lo repite. ### `PROBARA_DEBUG` `debug: true` (`PROBARA_DEBUG=true`) añade una línea por cada petición y por cada intento de ella, las repeticiones de las advertencias, y dice por qué el envío está desactivado cuando lo está: ```text $ PROBARA_DEBUG=true npx vitest run [probara] Sending 3 results of 3 tests (3 passed, 0 failed, 0 skipped, 0 blocked) [probara] Sending report 4f8d2c1a-9b3e-4c5d-8e7f-0a1b2c3d4e5f (attempt 1 of 5) [probara] Recorded 3 results (2 new cases, 0 unmatched) in R-1 (closed): https://app.probara.net/projects/SHOP/runs/R-1 ``` El ID que sigue a `report` es la `Idempotency-Key` de la petición ([idempotencia](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#idempotencia)). Mantén debug desactivado en las ejecuciones normales: es muy detallado, aunque nunca registra el token ni los cuerpos. ### Comprobar qué se enviaría El reporter no tiene un modo de simulación propio, pero un archivo de resultados cumple esa función: ejecuta las pruebas con el envío desactivado y un archivo de resultados, y deja que la CLI imprima lo que enviaría. No llega nada a Probara, y no hace falta token: ```text $ PROBARA_ENABLED=false PROBARA_PROJECT=SHOP PROBARA_RESULTS_FILE=probara-results.json npx vitest run --no-file-parallelism [probara] Wrote 3 results to /work/shop/probara-results.json: send them with probara import results /work/shop/probara-results.json $ npx @probara/cli import results probara-results.json --dry-run passed SHOP-12 tests/cart.test.ts > cart > adds an item passed - tests/cart.test.ts > cart > removes an item passed - tests/login.test.ts > login > logs in with a valid password Total: 3 results from 1 file (3 passed, 0 failed, 0 skipped, 0 blocked) ``` El primer comando escribe en stderr; la simulación imprime en stdout, una línea por resultado, en el orden en que se escribieron los resultados (`--no-file-parallelism` lo mantiene igual de una ejecución a otra): el estado, el caso (`-` si no se nombra ninguno) y la clave de automatización. `--dry-run` nunca toca el archivo; elimínalo después, o impórtalo de verdad (un archivo que se queda ahí hace que la siguiente ejecución escriba `probara-results-2.json`). `--json` imprime en cambio el documento completo, cada entrada tal como la recibiría Probara ([`probara import results`](https://github.com/cynch-me/probara-sdk/blob/main/packages/cli/docs/commands.md#probara-import-results)). Úsalo para comparar claves antes de una refactorización, de una actualización de Vitest o del reporter, o de un cambio de `keyIncludesFile`: escribe un archivo por ejecución, y compara las dos simulaciones con `diff`. Da a cada ejecución su propio nombre de archivo y empieza sin ellos: con un archivo ya en esa ruta, una ejecución escribe en un hermano (`before-2.json`) y la simulación de `before.json` mostraría una ejecución anterior, lo que ocultaría la diferencia. ```bash rm -f before.json after.json PROBARA_ENABLED=false PROBARA_PROJECT=SHOP PROBARA_RESULTS_FILE=before.json npx vitest run --no-file-parallelism # Change the code, or upgrade Vitest or the reporter, then: PROBARA_ENABLED=false PROBARA_PROJECT=SHOP PROBARA_RESULTS_FILE=after.json npx vitest run --no-file-parallelism npx @probara/cli import results before.json --dry-run > before.txt npx @probara/cli import results after.json --dry-run > after.txt diff before.txt after.txt ``` Cualquier línea que cambió es una prueba cuya clave o vínculo con un caso cambió: recibiría un caso nuevo. ### Lo que el reporter nunca le hace a la ejecución - **Nunca hace fallar la ejecución.** Cualquier cosa que salga mal al reportar es una línea `[probara]`, y el código de salida de `vitest` es el que dan las pruebas: un informe fallido o un token rechazado lo dejan como está. - **Nunca cambia el resultado de una prueba.** El archivo de setup que añade el reporter registra cada intento sin lanzar errores dentro de la prueba, y una llamada `probara.*` que no se puede registrar es una advertencia, nunca un error de la prueba. Las únicas pruebas que omite son las que quedan fuera de la ejecución de [`runCasesOnly`](https://docs.probara.net/es/developers/ci-integrations/vitest/run-selection/), cuando lo activas. - **Nunca escribe en stdout**, así que un reporter que imprime ahí mantiene limpia su salida. ## Cada línea que registra el reporter Cada línea `[probara]`, tanto las del propio reporter como las de la biblioteca de envío que comparte con los demás reporters de Probara y con la CLI. `<...>` representa lo que cambia. Una advertencia que puede repetirse termina con `(first seen in the run; repeats are logged at debug)`, o nombra el resultado en el que se vio por primera vez, y después se registra solo en debug. **Dónde** es el registro del reporter en stderr (registro), o la salida del archivo de prueba, que Vitest imprime bajo `stderr | tests/...` (salida de la prueba). El token nunca aparece en ninguna línea, ni siquiera cuando la respuesta de Probara lo repite. ### Configuración e inicio | Línea | Nivel | Qué hacer | | ------------------------------------------------------------------------------------------------------------------------------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Probara reporting is not configured: set PROBARA_API_TOKEN and PROBARA_PROJECT to enable it` | debug | [No se reporta nada](#no-se-reporta-nada-y-no-se-registra-nada) | | `Probara reporting is disabled by PROBARA_ENABLED` (o `by the enabled option`) | debug | El envío se desactivó a propósito | | `Probara reporting is off: ` | error | [Un problema de configuración](#el-envío-está-desactivado-un-problema-de-configuración) | | `Probara reporting is off: options must be an object` | error | Pasa las opciones como un objeto: `['@probara/vitest-reporter', { projectId: 'SHOP' }]` | | `Ignored the unknown option "" of @probara/vitest-reporter` | warn | Una errata en el nombre de una opción ([opciones](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#opciones)) | | `Ignored : a reused run (run.ulid) keeps its own` | warn | Una ejecución reutilizada conserva su nombre y sus ajustes ([una ejecución existente](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#una-ejecución-existente)) | | `Truncated the run name to 200 characters`, `Truncated the run description to 2000 characters` | warn | Acórtalos | | `Dropped run tags beyond the limit of 50` | warn | Envía menos etiquetas de ejecución | | `Ignored source.: it must be a string`, `Ignored a blank source branch`, `Ignored a source ...` | warn | Corrige el campo de `source` o su variable ([origen de la ejecución](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#origen-de-la-ejecución)) | | `Ignored the run of in PROBARA_RUN_ULIDS: is not the project nor one of projects` (o `run.ulids`) | warn | Lista el proyecto en `projects`, o quita su ejecución ([varios proyectos](https://docs.probara.net/es/developers/ci-integrations/vitest/sharding/#varios-proyectos-de-probara)) | | `The run of is reused (...), but has no run in run.ulids: ...` | warn | Da una ejecución a cada proyecto ([jobs con sharding](https://docs.probara.net/es/developers/ci-integrations/vitest/sharding/#jobs-con-sharding-y-varios-proyectos)) | | `Sent with the run of only: they belong to one project. ...` | warn | Crea las ejecuciones de los otros proyectos con los suyos ([una ejecución por proyecto](https://docs.probara.net/es/developers/ci-integrations/vitest/sharding/#una-ejecución-por-proyecto)) | | `could not register project "": ` | warn | Ese proyecto puede ejecutarse sin el archivo de setup del reporter. Repórtalo | | `could not add the setup file to project "" (): its retries and repeats are reported as their final attempt only` | warn | Repórtalo, con la versión de Vitest | | `could not give project "" its attachments folder (): its files are not attached` | warn | Repórtalo | | `the runner of project "" is , which Node does not import: the reporter keeps it as it is` | warn | [Se descartó una llamada a un helper](#se-descartó-una-llamada-a-un-helper) | | `the runner of project "" is TypeScript, which this Node cannot import: the reporter keeps it as it is` | warn | [Se descartó una llamada a un helper](#se-descartó-una-llamada-a-un-helper) | | `could not wrap the runner of project "" (): the reporter keeps it as it is` | warn | Repórtalo | ### Envío y registro | Línea | Nivel | Qué hacer | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Sending results of tests (...)`, y después `; left out by statusFilter`, `; ignored with probara.ignore()` o `; linked only to cases of unlisted projects` | info | Lo que la ejecución entrega a Probara ([el registro](#el-registro)) | | `Recorded results ( new cases, unmatched) in R-1 (closed): `, `in R-1 of ` con varios proyectos | info | Nada: la ejecución está en Probara | | `Filtered out results by their status (statusFilter): not sent` | info | [Filtro de estados](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#mapeo-y-filtro-de-estados) | | ` results were not recorded (): ` | warn | [Resultados no registrados](#resultados-no-registrados-unmatched) | | ` results were not sent: . No run was created or updated`, `... The run R-1 was left open: ` | error | [401 o 403](#probara-responde-401-o-403), [quedó abierta](#la-ejecución-quedó-abierta) | | `Probara warned: ` | warn | Lee la advertencia de Probara, como el recuento de [assignFailedTo](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#asignar-resultados-fallidos) | | `Did not send the results linked to cases of : is neither the project () nor one of projects (PROBARA_PROJECTS)` | warn | [Qué va a dónde](https://docs.probara.net/es/developers/ci-integrations/vitest/sharding/#qué-va-a-dónde) | | ` attempt of got ; retrying in ms`, `... timed out after ms; ...`, `... failed: ; ...` | warn | Nada: la petición se reintenta ([reintentos y backoff](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#reintentos-y-backoff)) | | `Sending (attempt of )` | debug | [`PROBARA_DEBUG`](#probara_debug) | | `The run R-1 was already closed or aborted` | info | Nada: alguien cerró la ejecución antes que el reporter | | `Could not close the run R-1: . It was left open: ` | error | Ciérrala a mano: `npx @probara/cli run close --run-ulid ` | | `Wrote the results that were not sent to : send them with probara import results ` | warn | [Archivo de resultados](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#archivo-de-resultados) | | `Wrote results to : send them with probara import results ` (envío desactivado) | info | [Envío desactivado: guardarlo todo](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#envío-desactivado-guardarlo-todo) | | `Could not write the results file : ` | error | Comprueba que se puede escribir en la carpeta del archivo | | `Could not keep a copy of the attachment () next to the results file (): ...` | warn | El archivo apunta al original: impórtalo antes de que ese archivo desaparezca | ### Modo watch y shards | Línea | Nivel | Qué hacer | | ----------------------------------------------------------------------------------------------------------------------------------- | ----- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Watch mode: every re-run reports into R-1 of , which stays open: close it in Probara, or with probara run close ...` | info | Cierra la ejecución cuando termine la sesión ([modo watch](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#modo-watch)) | | `The run R-1 of was closed: sent the results of this re-run into a new run` (o `deleted`) | info | Nada: la sesión continúa en la ejecución nueva | | `The run R-1 of was closed: sent the results it did not record into a new run; the rest of this re-run is in R-1` | info | Nada: la nueva ejecución de las pruebas queda repartida entre las dos ejecuciones | | `The run R-1 of was closed: the results file keeps this re-run, but names R-1, which refuses it: send it with ...` | info | Importa el archivo a una ejecución abierta ([cuando se cierra la ejecución](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#cuando-se-cierra-la-ejecución-durante-la-sesión)) | | `Sharded run with the blob reporter: the results are reported by vitest --merge-reports` | info | [Un shard no envía nada](#un-shard-no-envía-nada) | ### Selección de pruebas | Línea | Nivel | Qué hacer | | ----------------------------------------------------------------------------------------------------------------------------------- | ----- | ----------------------------------------------------------------------------------------------------- | | `Ran only the tests of run : of tests match its cases; skipped and not reported` | info | Nada ([selección de pruebas](https://docs.probara.net/es/developers/ci-integrations/vitest/run-selection/)) | | `No test matches the cases of the run : every test was skipped, and none is reported` | warn | Comprueba el ULID ([la selección ejecutó todas las pruebas](#la-selección-ejecutó-todas-las-pruebas)) | | `runCasesOnly needs the run whose tests to run: set run.ulid or PROBARA_RUN_ULID. Every test runs and is reported` | warn | Define el ULID | | `runCasesOnly: could not read the cases of the run (). Every test runs and is reported` | warn | Comprueba el ULID y el token | | `runCasesOnly does not apply to a sharded run with the blob reporter: every test runs, and vitest --merge-reports reports them all` | warn | [Configuraciones](https://docs.probara.net/es/developers/ci-integrations/vitest/run-selection/#configuraciones) | | `runCasesOnly does not apply in browser mode yet: the tests of project "" run and are reported` | warn | [Modo navegador](https://docs.probara.net/es/developers/ci-integrations/vitest/browser-mode/#aún-no-disponible) | | `runCasesOnly needs the setup file in project "": its tests run and are reported` | warn | No se pudo añadir el archivo de setup a ese proyecto: repórtalo | | `could not give project "" the cases of the run (): its tests all run and are reported` | warn | Repórtalo, con la versión de Vitest | ### Helpers Se registran una vez por ejecución, salvo que **Dónde** indique la salida de la prueba. | Línea | Dónde | Qué hacer | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `probara.() only works while a test runs (in a test, or a beforeEach or afterEach hook)` | salida de la prueba | [Un helper advierte](#un-helper-advierte-que-solo-funciona-mientras-corre-una-prueba) | | `probara.() is dropped in a concurrent test: this worker cannot tell which test calls it without the reporter's runner` | salida de la prueba | [Se descartó una llamada a un helper](#se-descartó-una-llamada-a-un-helper) | | `the probara.* helpers cannot see the running test: ` | salida de la prueba | [Se descartó una llamada a un helper](#se-descartó-una-llamada-a-un-helper) | | `probara.id() takes a case id or a list of case ids, such as PRB-12`, `probara.title() takes a string`, `probara.suite() takes a suite title or a list of suite titles`, `probara.comment() takes a string` | registro | Un argumento incorrecto: la llamada se ignora ([metadatos](https://docs.probara.net/es/developers/ci-integrations/vitest/metadata/)) | | `probara.parameters() takes an object of strings, numbers or booleans`, `probara.fields() takes an object of strings, numbers or booleans`, `probara.tags() takes strings` | registro | Un argumento incorrecto: la llamada se ignora ([metadatos](https://docs.probara.net/es/developers/ci-integrations/vitest/metadata/)) | | `probara.link() takes an absolute http(s) URL of at most 2048 characters`, `probara.link() takes the name as a string`, `probara.issue() takes an issue id (a string), such as PRB-7` | registro | Un argumento incorrecto: la llamada se ignora ([enlaces e incidencias](https://docs.probara.net/es/developers/ci-integrations/vitest/metadata/#enlaces-e-incidencias)) | | `probara.() ignores blank ` | registro | Una etiqueta, un ID o una suite vacíos: se dejan fuera | | `probara.() could not be recorded: ` | registro | Repórtalo | | `probara.step() takes an action (a string)`, `probara.step() takes the expected result as a string`, `probara.step() takes the data as a string`, `probara.step() takes its options as an object ({ expected, data })`, `probara.step() takes a function as its body` | registro | Corrige la llamada ([pasos](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#probarastep)) | | `Dropped the issues of probara.issue(): no issueUrlTemplate turns their ids into links` | registro | Define `issueUrlTemplate` ([`probara.issue()`](https://docs.probara.net/es/developers/ci-integrations/vitest/metadata/#probaraissue-e-issueurltemplate)) | | `Dropped a link without an absolute http(s) URL of at most 2048 characters` | registro | Pasa a `probara.link()` una URL `http(s)` absoluta ([reglas de los enlaces](https://docs.probara.net/es/developers/ci-integrations/vitest/metadata/#reglas-de-los-enlaces)) | | `Ignored malformed probara metadata (type "")` | registro | Algo escribió en `task.meta.probara`, que es del reporter ([cómo viajan los metadatos](https://docs.probara.net/es/developers/ci-integrations/vitest/metadata/#cómo-viajan-los-metadatos)) | La advertencia de una llamada que no pertenece a ninguna prueba se imprime en la salida de la prueba, sea cual sea su texto. ### Adjuntos y salida | Línea | Nivel | Qué hacer | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `probara.attach() did not attach "": it does not exist`, `it cannot be read`, `it is not a file`, `it is larger than 32 MiB`, `it cannot be copied ()` | warn | [Falta un adjunto](#falta-un-adjunto) | | `probara.attach() takes { name, path } or { name, body }`, `probara.attach() could not attach "": its contentType is not a string`, `... it has neither a path nor a body` | warn | Corrige la llamada ([`probara.attach()`](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#probaraattach)) | | `probara.attach() could not attach "": this run has no attachments folder` | warn | El proyecto no recibió carpeta de adjuntos: una advertencia al empezar dice por qué | | `Attached files to results ( skipped, failed)` | info | Nada; una advertencia cuando alguno falló | | `Skipped an attachment: (first seen in "", ; ...)` | warn | [Límites](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#límites-y-qué-se-omite) | | `Skipped the attachments beyond the first 20 uploadable ones of a result` | warn | Adjunta menos archivos por prueba | | `Could not attach files to the result of "": ` | warn | El resultado se registra sin ellos; comprueba la red ([red](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#red)) | | `Skipped an annotate file "": Vitest 3 loses some bytes of a binary body, so it cannot be sent intact; attach the file with a path instead` | warn | [Anotaciones de Vitest](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#anotaciones-de-vitest) | | ` annotated files are left out: the attempt each belongs to cannot be told apart` | warn | [Solo se envió el último intento](#solo-se-envió-el-último-intento-de-una-prueba-reintentada) | | `The console output of tests are left out: Vitest attributes the writes of concurrent tests to the wrong test, ...` | warn | [captureOutput no adjunta nada](#captureoutput-no-adjunta-nada) | | `[probara] The output of this test was cut here: an attachment holds at most 32 MiB` | — | Una línea dentro de `stdout.log` o `stderr.log`, no del registro ([límites de la salida](https://docs.probara.net/es/developers/ci-integrations/vitest/steps-and-attachments/#límites-de-la-salida)) | ### La ejecución de Vitest | Línea | Nivel | Qué hacer | | ----------------------------------------------------------------------------------------------------------------------- | ----- | --------------------------------------------------------------------------------------------- | | `Vitest did not run test files of this run: nothing of them are reported` | warn | [Un archivo de prueba no se reporta](#un-archivo-de-prueba-no-se-reporta) | | `Vitest retried or repeated tests whose earlier attempts were not recorded: only their final attempts are reported` | warn | [Solo se envió el último intento](#solo-se-envió-el-último-intento-de-una-prueba-reintentada) | | `Vitest reported unhandled errors outside the tests: they are not results, and nothing is sent for them` | warn | [Errores no gestionados](#los-errores-no-gestionados-no-se-envían) | ### En modo navegador | Línea | Nivel | Qué hacer | | --------------------------------------------------------------------------------------------------------------------------------------- | ----- | --------------------------------------- | | `probara.attach() did not attach "": Vite does not serve "" (server.fs.allow or server.fs.deny)` | warn | [Modo navegador](#modo-navegador) | | `probara.attach() did not attach "": Vite's file rules are not reachable from this run, so "" is not served` | warn | [Modo navegador](#modo-navegador) | | `probara.attach() "" of "" settled after the test ended, so it is not attached. Await probara.attach() ...` | warn | Espera la llamada (salida de la prueba) | | `Vite has no isFileLoadingAllowed (it arrived in 5.4): the browser attach follows its isFileServingAllowed` | warn | [Modo navegador](#modo-navegador) | | `Vite exports neither isFileLoadingAllowed nor isFileServingAllowed: the browser attach refuses every path` | warn | [Modo navegador](#modo-navegador) | | `could not add the browser setup file to project "" (): its retries and repeats are reported as their final attempt only` | warn | Repórtalo, con la versión de Vitest | | `could not add the browser commands to project "" (): its probara.attach() copies no file` | warn | Repórtalo, con la versión de Vitest | | `could not give the browser commands to project "": ` | warn | Repórtalo, con la versión de Vitest | ### Límites de un resultado Los límites de Probara por resultado, cada uno una advertencia que nombra el primer resultado en el que se vio: | Línea | Límite | | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | | `Dropped the steps beyond the first 200 of a result`, `Dropped the steps nested deeper than 10 levels` | Pasos de un resultado | | `Dropped the case steps beyond the first 500`, `Dropped a case step without an action` | Pasos de un caso creado | | `Dropped the parameters beyond the first 20 of a result`, `Truncated a parameter name longer than 100 characters` | Parámetros | | `Ignored a parameter with a blank name`, `Ignored a parameter whose name repeats another once trimmed` | Parámetros | | `Dropped the case tags beyond the first 50` | Etiquetas de un caso creado | | `Dropped the case fields beyond the first 50`, `Ignored a case field whose name is longer than 200 characters` | Campos de un caso creado | | `Ignored a case field with a blank name`, `Ignored a case field whose name repeats another once trimmed and compared ignoring case` | Campos de un caso creado | | `Dropped the links beyond the first 20 of a result`, `Truncated a link name longer than 255 characters` | Enlaces | | `Ignored a caseDisplayId longer than 64 characters` | IDs de caso | ### Errores que hay que reportar Estas líneas indican que el reporter encontró algo que no esperaba. La ejecución continúa, y lo que nombra la línea se pierde (una prueba, un archivo, la salida de consola de una prueba) o queda como estaba (las copias de los archivos de la ejecución). Repórtalos en [github.com/cynch-me/probara-sdk/issues](https://github.com/cynch-me/probara-sdk/issues), con las líneas `[probara]` de una ejecución con `PROBARA_DEBUG=true` y la versión de Vitest. | Línea | Nivel | | ------------------------------------------------------------------------------------------------------------------------------------------------ | ----- | | `Probara reporting is off: the reporter could not start: ` | error | | `Could not report : `, `Could not report "": `, `Could not report the failure of : ` | error | | `Could not finish reporting: `, `Could not read the cases of the run: `, `Could not keep the console output of a test: ` | error | | `Could not remove the attachment copies of this run: ` (elimina `/probara/` a mano) | error | | `Skipped the invalid result of "": `, `Ignored results added after complete()` | warn | | `Ignored that is not `, como `Ignored steps that are not a list`, e `Ignored a blank caseDisplayId` | warn | Relacionado: [Configuración](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/) · [Red](https://docs.probara.net/es/developers/ci-integrations/vitest/configuration/#red) · [Archivo de resultados](https://docs.probara.net/es/developers/ci-integrations/vitest/results-and-retries/#archivo-de-resultados) · Fuente: [troubleshooting.md](https://github.com/cynch-me/probara-sdk/blob/main/packages/vitest-reporter/docs/troubleshooting.md), [debugging.md](https://github.com/cynch-me/probara-sdk/blob/main/packages/vitest-reporter/docs/debugging.md)