# Solución de problemas del reporter de Cypress

> Problemas de @probara/cypress-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 registra en
líneas `[probara]` en **stdout**, entre la salida propia de Cypress; `PROBARA_DEBUG=true`
([depuración](#depuración)) añade cada petición. Sea cual sea el problema, `cypress run` sigue
terminando con el número de sus propias pruebas fallidas: reportar no cambia nada de eso.

## No se reporta nada, y no se registra nada

```text
$ PROBARA_DEBUG=true npx cypress run
[probara] Probara reporting is not configured: set PROBARA_API_TOKEN and PROBARA_PROJECT to enable it
```

**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 dice en debug.

**Solución.** Pasa el secreto `PROBARA_API_TOKEN` al paso que ejecuta `cypress run`, y define el
proyecto (`projectId` en `reporterOptions`, o `PROBARA_PROJECT`). Comprueba que el reporter es el
`reporter` del bloque de configuración que ejecutó Cypress (`e2e`), y que ejecutaste `cypress run`:
`cypress open` no reporta nada
([modo interactivo](https://docs.probara.net/es/developers/ci-integrations/cypress/configuration/#modo-interactivo)).

## El envío está desactivado: un problema de configuración

```text
$ PROBARA_RUN_ULID=R-12 npx cypress 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.

**Solución.** Corrige el ajuste que nombra la línea
([opciones](https://docs.probara.net/es/developers/ci-integrations/cypress/configuration/#opciones)).

## Probara responde 401 o 403

```text
$ npx cypress 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: <message from Probara>. 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 **Cypress**
([primeros pasos](https://docs.probara.net/es/developers/ci-integrations/cypress/#1-crea-un-token-de-aplicación)) y actualiza
el secreto; comprueba el ID del Proyecto; comprueba el plan de la organización. Para conservar lo que
no se envió, define un
[archivo de resultados](https://docs.probara.net/es/developers/ci-integrations/cypress/results-and-retries/#archivo-de-resultados).

## Se reportan los resultados, pero no las capturas, el vídeo ni los helpers

```text
$ npx cypress run
[probara] Results are reported, but the screenshots, the videos and the probara.* helpers are not: add setupNodeEvents(on, config) { return probaraNodeEvents(on, config); } (from '@probara/cypress-reporter/setup') to the Cypress config, and require('@probara/cypress-reporter/support') in the support file
```

**Por qué.** La configuración de Cypress registra el reporter pero no el plugin. Se sigue enviando
cada resultado, pero en **una ejecución por spec**, cada una cerrada al terminar su spec, así que un
`cypress run` con varias specs crea varias ejecuciones. Sin el plugin no hay capturas, ni vídeo, ni
helpers `probara.*`.

**Solución.** Registra el plugin, y devuelve su configuración desde `setupNodeEvents` como hace
`probaraNodeEvents(on, config)`
([registro](https://docs.probara.net/es/developers/ci-integrations/cypress/configuration/#registro)). Regístralo una sola
vez: un segundo registro en la misma ejecución se queda sin resultados.

## Otro plugin dejó de funcionar, o este

**Por qué.** Cypress guarda un solo manejador por evento de `setupNodeEvents`: cuando dos plugins
registran el mismo evento con el mismo `on`, gana el último registrado y el otro nunca se ejecuta,
sin aviso. Con `probaraNodeEvents` registrado el último, el otro plugin pierde su manejador;
registrado el primero, este pierde el suyo:

| El evento que perdió este plugin | Qué falta                                                                                                   |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `after:run`                      | Todo: no se envía nada ni se crea ninguna ejecución, sin ninguna línea `[probara]` al final de la ejecución |
| `after:spec`                     | Los resultados de cada spec, y el resultado fallido de una spec que Cypress no pudo ejecutar                |
| `after:screenshot`               | Las capturas de los intentos fallidos                                                                       |
| `before:spec`                    | Las capturas no se asocian a su spec                                                                        |
| `before:run`                     | El parámetro `browser` de cada resultado                                                                    |

Las tareas se combinan, así que la tarea `probara` nunca se pierde de esta forma.

**Solución.** Pasa a cada plugin el `on` de
[cypress-on-fix](https://github.com/bahmutov/cypress-on-fix), que ejecuta por turnos cada manejador
de un evento ([con otros plugins](https://docs.probara.net/es/developers/ci-integrations/cypress/configuration/#con-otros-plugins)):

```js
setupNodeEvents(cypressOn, config) {
  const on = require('cypress-on-fix')(cypressOn);
  require('cypress-split')(on, config);
  probaraNodeEvents(on, config);
  return config;
}
```

## La ejecución queda abierta

| Línea                                                                                                           | Por qué, y qué hacer                                                                                                                                                    |
| --------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `The run <R> of <P> stays open: close it in Probara, or with probara run close --project <P> --run-ulid <ULID>` | Este `cypress run` no creó la ejecución (`run.ulid`), o `closeRun` está desactivado: ciérrala con ese comando, o en Probara                                             |
| `The run <R> was left open: <url>`                                                                              | Un informe falló tras sus reintentos (Probara inalcanzable, un informe rechazado). Guarda lo que no se envió con un archivo de resultados, o cierra la ejecución a mano |
| `The run <R> was already closed or aborted`                                                                     | Alguien la cerró mientras se enviaba la ejecución; no hay nada que hacer                                                                                                |
| `Could not close the run <R>: <reason>. It was left open: <url>`                                                | Los resultados llegaron, pero el cierre falló: ciérrala a mano                                                                                                          |

Una ejecución que el reporter no creó (`run.ulid`, `run.ulids`) nunca se cierra, salvo que `closeRun`
lo indique ([cierre](https://docs.probara.net/es/developers/ci-integrations/cypress/results-and-retries/#cierre)).

## 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/cypress/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 cypress run
[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): cypress/e2e/cart.cy.js > Cart removes an item; cypress/e2e/login.cy.js > Login logs in with a valid password
```

**Por qué.** Un resultado nombra un caso que no existe (un error en un ID, un caso de otro
proyecto), o no coincide con ningún caso mientras `createMissingCases` está desactivado. Probara
registra los demás y dice 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 movió una spec, un `describe` o un
`it`, se lanzó `cypress run` desde otro directorio, o cambió `keyIncludesFile`
([qué cambia una clave](https://docs.probara.net/es/developers/ci-integrations/cypress/linking/#qué-cambia-una-clave)). Si
vienes de `probara import junit`, puede que los informes JUnit se escribieran sin el atributo `file`
de su suite raíz.

**Solución.** Nombra los casos en los títulos
([vincular](https://docs.probara.net/es/developers/ci-integrations/cypress/linking/)), para que un cambio de nombre los
conserve. Antes de una refactorización, [compara las claves](#comprobar-qué-se-enviaría); si vienes
de la importación JUnit, consulta
[migrar](https://docs.probara.net/es/developers/ci-integrations/cypress/migrating/#desde-la-importación-junit).

## Un helper dijo algo que no pertenece a ninguna prueba

```text
$ npx cypress run
[probara] Left out 1 probara.* call in cypress/e2e/helpers.cy.js: what it said belongs to no attempt that ran (probara.title() of a hook that runs no test) (first seen in cypress/e2e/helpers.cy.js; repeats are logged at debug)
```

**Por qué.** Un helper `probara.*` se ejecutó sin ningún intento en curso, por ejemplo en el hook
`before` de un `describe`, que Cypress ejecuta antes de que empiece su primera prueba. Lo que dijo
nunca se da a otra prueba.

**Solución.** Llama a los helpers en la prueba, en un `beforeEach` o en un `afterEach`
([dónde llamar a los helpers](https://docs.probara.net/es/developers/ci-integrations/cypress/metadata/#dónde-llamar-a-los-helpers)).

## Una prueba perdió sus pasos, archivos o metadatos

**Por qué.** Dos pruebas de una spec con el mismo título completo (dos `it` con un mismo título en un
`describe`, o `a b` › `c` junto a `a` › `b c`) no se pueden distinguir, así que lo que dijeron sus
helpers se omite en lugar de dárselo a la prueba equivocada. También comparten clave, y por tanto
caso.

**Solución.** Da a cada prueba su propio título.

## Los helpers no hicieron nada

| Lo que ves                                                                                              | Por qué, y qué hacer                                                                                                                                                                  |
| ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `The probara.* helpers do nothing: nothing was found at Cypress.expose('probara') when the spec ran, …` | La configuración no registra ningún plugin, o `setupNodeEvents` no devuelve la configuración que devuelve `probaraNodeEvents`, así que Cypress nunca entrega sus ajustes al navegador |
| `The probara.* helpers could not send what they were told: there is no cy chain in this frame`          | Un helper se ejecutó donde no hay cadena `cy`, como el código de nivel superior de una spec. No se registra nada                                                                      |
| `probara.* could not send what it was told: <reason>`                                                   | Se rechazó el `cy.task('probara', …)` de la llamada. La prueba sigue ejecutándose                                                                                                     |
| `probara.attach() takes { name, path } or { name, body }`                                               | Un argumento incorrecto en `probara.attach()`. La llamada se ignora                                                                                                                   |
| `probara.attach() could not attach "<name>": its contentType is not a string`                           | Un `contentType` que no es texto. El archivo no se adjunta                                                                                                                            |
| `probara.attach() could not attach "<name>": it has neither a path nor a body`                          | Un adjunto sin `path` ni `body`                                                                                                                                                       |
| `probara.attach() could not read "<path>" (<reason>): it is not attached`                               | El archivo de un `path` no existe o no se puede leer (`ENOENT`, `EISDIR`): la prueba sigue sin él                                                                                     |
| `probara.step() takes a function as its body`                                                           | Un cuerpo que no es una función                                                                                                                                                       |
| `probara.step() takes its options as an object ({ expected, data })`                                    | Unas opciones que no son un objeto                                                                                                                                                    |
| `probara.<helper>() could not be recorded: <reason>`                                                    | Un helper de metadatos (`id`, `title`, `suite`, `comment`, `ignore`, `parameters`, `tags`, `fields`, `link`, `issue`) recibió un valor que no puede usar                              |
| `probara.<helper>() takes ...`                                                                          | Una advertencia por cada argumento incorrecto, como `probara.id() takes a case id or a list of case ids, such as PRB-12`                                                              |
| `Ignored malformed probara metadata (type "…")`                                                         | Un mensaje del archivo de soporte de otra versión del paquete; reinstálalo para que ambos lados coincidan                                                                             |

Sin el plugin, estas advertencias se escriben en la **consola del navegador** y en ningún otro
sitio. Con él, llegan al registro de la ejecución, indicando de dónde vienen:
`[probara] <message> (first seen in cypress/e2e/cart.cy.js › Cart adds an item)`. Una advertencia
sobre algo dentro de una spec se registra cuando termina esa spec, no al final de la ejecución.

## Se omitió una captura

```text
$ PROBARA_DEBUG=true npx cypress run
[probara] Left out the screenshots of cypress/e2e/cart.cy.js that name no failed test: Checkout -- pays with voucher (failed)
```

**Por qué.** Es solo una línea de debug. El reporter adjunta una captura únicamente al resultado del
intento cuyo nombre lleva. Una captura con otro nombre (`cy.screenshot('my-name')`, o un intento
fallido que Cypress reintentó sin una segunda captura) no pertenece a ningún resultado.

**Solución.** Deja que Cypress tome las capturas de los fallos; adjunta una captura propia con
`probara.attach()`
([capturas de pantalla](https://docs.probara.net/es/developers/ci-integrations/cypress/steps-and-attachments/#capturas-de-pantalla)).

## La selección ejecutó todas las pruebas

**Por qué.** Con `runCasesOnly`, el plugin 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é:

| Advertencia                                                                                                                                         | Por qué                                                                                                                |
| --------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `runCasesOnly needs the run whose tests to run: set run.ulid or PROBARA_RUN_ULID. Every test runs and is reported`                                  | No hay ninguna ejecución de la que tomar las pruebas                                                                   |
| `runCasesOnly: could not read the cases of the run <ULID> (<reason>). Every test runs and is reported`                                              | No se pudieron leer los casos de la ejecución: un ULID incorrecto, un token de otra organización, Probara inalcanzable |
| `runCasesOnly needs the support file: require('@probara/cypress-reporter/support') in the Cypress support file, or every test runs and is reported` | Falta el archivo de soporte: sin él no se puede omitir ninguna prueba                                                  |

**Solución.** Sigue la advertencia
([cuando no puede seleccionar](https://docs.probara.net/es/developers/ci-integrations/cypress/run-selection/#cuando-no-puede-seleccionar)).
Si en cambio se omitieron todas las pruebas, ninguna pertenece a la ejecución:

```text
[probara] No test matches the cases of the run 01J9Z3K4M5N6P7Q8R9S0T1V2W3: every test was skipped, and none is reported
```

## Resultados dejados fuera a propósito

| Lo que ves                                                                                                             | Por qué                                                                       |
| ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| `Sending 4 results of 4 tests (3 passed, 0 failed, 1 skipped, 0 blocked); 1 left out by statusFilter`                  | El estado está en `statusFilter`                                              |
| `Sending 3 results of 4 tests (3 passed, 0 failed, 0 skipped, 0 blocked); 1 ignored with probara.ignore()`             | La prueba llamó a `probara.ignore()`                                          |
| `Sending 2 results of 3 tests (2 passed, 0 failed, 0 skipped, 0 blocked); 1 linked only to cases of unlisted projects` | Cada caso que vincula el resultado es de un proyecto que `projects` no indica |

La línea `Sending` es el resumen de toda la ejecución: se escribe una vez, cuando termina la
ejecución.

## Falta un adjunto

**Por qué.** El registro nombra cada archivo que omitió y por qué: 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 un
archivo que `probara.attach()` no pudo leer
([límites](https://docs.probara.net/es/developers/ci-integrations/cypress/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()`, mantén los archivos
dentro de los límites y adjunta menos archivos por resultado.

## Probara responde 429 (demasiadas peticiones)

**Por qué.** El límite de peticiones de la organización lo comparten todos los tokens y pipelines.
Los adjuntos cuestan dos peticiones por resultado, y sin el plugin cada spec paga por una ejecución
propia ([límite de peticiones](https://docs.probara.net/es/developers/ci-integrations/cypress/configuration/#límite-de-peticiones)).

**Solución.** El reporter espera y reintenta por su cuenta. En baterías grandes, adjunta menos,
reduce `attachmentConcurrency`, o escalona en el tiempo los pipelines repartidos.

## Depuración

### El registro

El reporter y su plugin escriben en stdout, con cada línea precedida de `[probara]`. Un
`cypress run` que reporta registra dos líneas, después de la última spec y antes de la tabla
`(Run Finished)` de Cypress:

```text
$ npx cypress run
[probara] Sending 5 results of 4 tests (3 passed, 2 failed, 0 skipped, 0 blocked)
[probara] Recorded 5 results (2 new cases, 0 unmatched) in R-1 (closed): https://app.probara.net/projects/SHOP/runs/R-1
```

Una advertencia que se repite en cada prueba se registra la primera vez, indicando dónde se vio por
primera vez, y en debug a partir de ahí. 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 (método, ruta, estado, tiempo)
y cada reintento, las repeticiones de las advertencias, y dice por qué el envío está desactivado
cuando lo está:

```bash
PROBARA_DEBUG=true npx cypress run
```

Déjalo 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 prueba propio, pero un archivo de resultados lo es: 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 cypress run
[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	cypress/e2e/cart.cy.js > Cart adds an item
passed	-	cypress/e2e/cart.cy.js > Cart removes an item
passed	-	cypress/e2e/login.cy.js > Login logs in with a valid password
Total: 3 results from 1 file (3 passed, 0 failed, 0 skipped, 0 blocked)
```

Una línea por resultado: el estado, el caso (`-` cuando no nombra ninguno) y la clave de
automatización. `--dry-run` nunca toca el archivo; bórralo después, o una ejecución posterior
escribirá `probara-results-2.json`.

Para comparar claves antes de una refactorización, una actualización o un cambio de
`keyIncludesFile`, escribe un archivo por ejecución y compara las dos pruebas en seco con `diff`.
Empieza sin los archivos: si ya hay uno en la ruta, una ejecución escribe en un hermano, y la prueba
en seco mostraría la ejecución anterior.

```bash
rm -f before.json after.json
PROBARA_ENABLED=false PROBARA_PROJECT=SHOP PROBARA_RESULTS_FILE=before.json npx cypress run
# Change the code, or upgrade the reporter, then:
PROBARA_ENABLED=false PROBARA_PROJECT=SHOP PROBARA_RESULTS_FILE=after.json npx cypress run
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
```

Cada línea que cambió es una prueba cuya clave o cuyo vínculo de caso cambió: recibiría un caso
nuevo.

## Cada línea que registra el reporter

La biblioteca de envío que el reporter comparte con los demás reporters y con la CLI escribe las
líneas comunes (`Sending`, `Recorded`, `not recorded`, `not sent`, `Wrote`, `Probara warned`,
`Probara reporting is off: <problem>`). Estas son las líneas propias del reporter de Cypress.

### No se reportó nada

| Línea                                                                                             | Nivel | Significado y 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), a propósito                                              |
| `Probara reporting is disabled by <option or variable>`                                           | debug | `enabled: false`, o `PROBARA_ENABLED`                                                                                     |
| `Probara reporting is off: <problem>`                                                             | error | [Un problema de configuración](#el-envío-está-desactivado-un-problema-de-configuración)                                   |
| `Probara reporting is off: the reporter could not start: <reason>`                                | error | Repórtalo: el reporter nunca lanza errores dentro de Cypress, y dice por qué se detuvo                                    |
| `Probara reporting is off: the reporter could not be loaded; reinstall @probara/cypress-reporter` | error | No se pudo cargar el paquete: reinstálalo                                                                                 |
| `Ignored the unknown option "<name>" of @probara/cypress-reporter`                                | warn  | Un error en el nombre de una opción. El envío continúa sin ella                                                           |
| `Results are reported, but the screenshots, the videos and the probara.* helpers are not: ...`    | warn  | [Sin plugin](#se-reportan-los-resultados-pero-no-las-capturas-el-vídeo-ni-los-helpers)                                    |
| `Could not report a spec without setupNodeEvents: <reason>`                                       | error | Los resultados de una spec no se pudieron enviar en su propia ejecución (sin plugin). Las demás specs no se ven afectadas |

### Se dejaron fuera algunos resultados

| Línea                                                                                                              | Nivel | Significado y qué hacer                                                                                           |
| ------------------------------------------------------------------------------------------------------------------ | ----- | ----------------------------------------------------------------------------------------------------------------- |
| `Could not report an attempt of "<test>": <reason>`                                                                | error | Repórtalo: ese intento se pierde, y la ejecución continúa                                                         |
| `Left out <n> probara.* call(s) in <spec>: what it said belongs to no attempt that ran (<labels>)`                 | warn  | [Un helper se ejecutó sin prueba](#un-helper-dijo-algo-que-no-pertenece-a-ninguna-prueba)                         |
| `Left out the screenshots of <spec> that name no failed test: <names>`                                             | debug | [Una captura no pertenece a ningún intento](#se-omitió-una-captura)                                               |
| `Ignored malformed probara metadata (type "…")`                                                                    | warn  | Un mensaje del archivo de soporte de otra versión ([los helpers no hicieron nada](#los-helpers-no-hicieron-nada)) |
| `Dropped the issues of probara.issue(): no issueUrlTemplate turns their ids into links`                            | warn  | Define `issueUrlTemplate`                                                                                         |
| `probara.<helper>() takes ...`, `probara.attach() could not attach "<name>": <reason>`, `probara.step() takes ...` | warn  | Un argumento incorrecto; la llamada se ignora y la prueba nunca falla por ello                                    |
| `Could not write the results file <path>: <reason>`                                                                | error | No se pudo escribir el archivo de resultados: comprueba la ruta y su carpeta                                      |
| `Skipped the invalid result of <what>: <reason>`                                                                   | warn  | Un resultado que no se pudo construir; repórtalo                                                                  |
| `Skipped an attachment: <reason>`                                                                                  | warn  | Se omitió un archivo ([falta un adjunto](#falta-un-adjunto))                                                      |

### La ejecución

| Línea                                                                                                           | Nivel | Significado y qué hacer                                                                                    |
| --------------------------------------------------------------------------------------------------------------- | ----- | ---------------------------------------------------------------------------------------------------------- |
| `Ran only the tests of run <ULID>: <k> of <m> tests match its cases; <s> skipped and not reported`              | info  | La [selección de pruebas](https://docs.probara.net/es/developers/ci-integrations/cypress/run-selection/) funcionó                  |
| `No test matches the cases of the run <ULID>: every test was skipped, and none is reported`                     | warn  | Ninguna prueba pertenece a la ejecución                                                                    |
| `The run <R> of <P> stays open: close it in Probara, or with probara run close --project <P> --run-ulid <ULID>` | info  | Una ejecución reutilizada, o `closeRun: false` ([la ejecución queda abierta](#la-ejecución-queda-abierta)) |
| `Could not create the Probara run: <reason>` / `Could not create the run: <reason>`                             | error | No se pudo crear la ejecución; no se envió nada                                                            |
| `Could not close the run <R>: <reason>. It was left open: <url>`                                                | error | [Ciérrala a mano](#la-ejecución-queda-abierta)                                                             |
| `The run <R> was already closed or aborted`                                                                     | info  | Alguien la cerró mientras tanto                                                                            |
| `<n> results were not sent: <reasons>. <No run was created or updated \| The run <R> was left open: <url>>`     | error | Probara rechazó el envío o no estaba disponible; define un archivo de resultados                           |

Reporta un problema 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`.

Relacionado: [Configuración](https://docs.probara.net/es/developers/ci-integrations/cypress/configuration/) ·
[Red](https://docs.probara.net/es/developers/ci-integrations/cypress/configuration/#red) ·
[Archivo de resultados](https://docs.probara.net/es/developers/ci-integrations/cypress/results-and-retries/#archivo-de-resultados) ·
Fuente:
[troubleshooting.md](https://github.com/cynch-me/probara-sdk/blob/main/packages/cypress-reporter/docs/troubleshooting.md),
[debugging.md](https://github.com/cynch-me/probara-sdk/blob/main/packages/cypress-reporter/docs/debugging.md)