> ## Content Index
> Fetch the complete content index at: https://cesarbeassuarez.dev/llms.txt
> Use this file to discover other available public pages before exploring further.

# Un verde que no validó nada
- URL: https://cesarbeassuarez.dev/un-verde-que-no-valido-nada/
- Published: 2026-10-23T04:37:56.000Z
- Updated: 2026-10-25T18:49:27.000Z
- Description: Las tres formas de fabricar un falso negativo en una suite, y cómo los medí: 50 aserciones mutadas, 0 sobrevivientes. Con prueba de mutación.
- Author: César Beas Suárez
- Tags: QA Estratégico, #destacado

Corrí la suite con todos los valores esperados desplazados a propósito, por encima de su tolerancia. La idea: si un test seguía en verde con el esperado cambiado, esa aserción no estaba midiendo nada. Primera medición: 50 aserciones mutadas, 0 sobrevivientes, 4 en el punto ciego del instrumento y las 4 legítimas.

Esa corrida existe porque meses antes encontré tests que no se podían poner en rojo ni con la app devolviendo cualquier disparate. Tildes verdes sobre comparaciones que no comparaban nada.

Este post es el camino de una cosa a la otra: las tres formas de fabricar un verde que no valida, y los dos mecanismos que puse para dejar de depender de que yo los revise a mano.

---

## El vocabulario, antes que nada

Lo que trata este post se llama falso negativo: el test no detecta un defecto que sí está. Su opuesto es el falso positivo, el test que acusa un defecto que no existe. Están definidos así en el glosario de ISTQB, con la misma lógica que en medicina: positivo quiere decir que se detectó algo.

Y aun así se confunden todo el tiempo. Los vi usados al revés más de una vez, en documentación y en conversaciones de equipo.

Por eso, cuando hablo de corridas concretas, los digo en términos de lo que se ve en el reporte:

- Falso rojo: el test da rojo y la app está bien. Es el falso positivo.
- Falso verde: el test da verde y la app está mal. Es el falso negativo.

No cuestan lo mismo.

|             | Qué pasa después                                     | Costo                                     |
| ----------- | ---------------------------------------------------- | ----------------------------------------- |
| Falso rojo  | alguien investiga, reproduce a mano, corrige el test | caro, pero visible                        |
| Falso verde | nadie se entera                                      | la suite deja de proteger y nadie lo sabe |

El falso rojo te come días y acusa al producto. El dev que lo recibe pierde la tarde buscando un bug que no existe. Pero se nota. Alguien lo levanta, alguien lo discute, alguien lo arregla.

El falso verde no tiene a nadie del otro lado. La suite sigue corriendo, el reporte sigue saliendo verde, el mail de la release sigue diciendo que está todo bien. El día que la app se rompe de verdad, el test que tenía que avisar había dejado de avisar meses atrás.

---

## Tres formas de fabricar un falso verde

De menos a más grave. La gravedad es inversa a lo fácil que es verlas.

### 1 · El test no valida nada

Navegó, no se cayó, tilde verde. Pasos que abren pantallas, hacen clicks, y terminan sin comparar un valor contra nada.

Se ve leyendo el código. El más fácil de encontrar y de arreglar.

### 2 · La aserción es débil

```typescript
await expect(elemento).toBeVisible();

```

...donde la regla de negocio pide un importe. El test comprueba que la pantalla dibujó algo, no que ese algo sea el número correcto. Si el descuento se calcula mal, el elemento sigue visible y el test sigue verde.

También se ve leyendo, pero cuesta más: hay que saber qué pedía la tarjeta.

### 3 · El esperado sale de la app

```typescript
const precioLeido = await carrito.leerPrecioUnitario();
const total = await carrito.leerTotalDelRenglon();
expect(total).toBeCloseTo(precioLeido * 3, 2);
```

Hay un esperado. Hay comparación. En el reporte sale en verde: `esperado $14.380,77 · leído $14.380,77`.

Y no puede fallar nunca.

Si la app devuelve el precio mal, lo devuelve mal en los dos lugares. El test la compara contra sí misma y confirma que es coherente consigo misma, que es la única cosa que no hace falta probar.

Esta es la que importa, porque tiene forma de test correcto. Las otras dos se ven de lejos. Esta hay que ir a buscarla, y en una suite de varios cientos de casos nadie la va a ir a buscar.

Ya me pasó. Un test comparaba el precio de una sucursal sólo contra el de la empresa principal: habría dado verde con el precio roto en las dos. El comentario que dejé en el spec después de esa:

> La referencia es FIJA, del dato — no derivada de otra lectura de la misma pantalla.

---

## Por qué esto empeora cuando los tests los escribe una IA

Un agente escribe código más rápido de lo que yo lo leo línea por línea. Si un falso verde se me escapaba escribiendo 8 tests por día, se me escapa más escribiendo 150.

Pero el volumen no es lo peor. Un agente escribe el test mirando la app que ya funciona. Le pedís que cubra una funcionalidad, abre la pantalla, ve que el total dice $14.380,77 y pone $14.380,77 como esperado. El test pasa a la primera, se ve impecable, y lo único que garantiza es que la app sigue haciendo hoy lo que hacía el día que se escribió el test.

Si ese día la app estaba mal, el test pasa a defender el defecto.

No es culpa del agente. Es lo mismo que hago yo cuando automatizo sobre una app que ya está andando, sólo que más rápido y en más lugares a la vez. La diferencia es que antes podía mirar los 10 tests del día. Ahora no.

Así que dejé de intentar revisarlo todo y puse dos cosas que miden.

---

## Mecanismo 1 · Un solo booleano asevera y reporta

Antes tenía esto:

```typescript
check("Descuento aplicado", 19, descuento, Math.abs(descuento - 19) <= 1);
expect(Math.abs(descuento - 19)).toBeLessThanOrEqual(1);

```

Dos líneas. `check` dibujaba el tick en el reporte con el esperado y el leído, pero no aseveraba nada: el que decidía si el test pasaba era el `expect` de atrás. Un tick verde que no significaba que algo se hubiera validado.

Yo quería lo contrario: que cada tilde del reporte sea una aserción de verdad, y que lo que se lee en Allure sea exactamente lo que decidió el test.

Hoy hay una sola función, `verificar()`, que hace las dos cosas con el mismo booleano:

```typescript
verificar("Descuento aplicado", esperado("descuentoPorCantidad"), descuento);

```

Si es verdadero, el tick sale verde y el test sigue. Si es falso, sale rojo y el test falla. No pueden divergir porque son el mismo dato.

Suena a detalle de implementación. Es el cambio que más resultados falsos me sacó de encima.

---

## Mecanismo 2 · Cada esperado declara de dónde salió

Ningún valor esperado vive en el código. Todos van a un JSON por caso, que edito yo. Cada uno declara un campo `origen`:

```jsonc
{
  "totalDelRenglon": {
    "valor": 13395.06,
    "origen": "regla",
    "_calculo": "4.793,59 × 3 u. × 0,90 (tramo del 10 %) + 150,79 de impuesto por unidad"
  }
}

```

Tres orígenes:

| origen      | Qué es                                                                                                                    | ¿Puede fallar?                          |
| ----------- | ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- |
| regla       | Sale de la regla de negocio, de un cálculo con componentes fijos, o de una medición que una persona confirmó              | sí — es el que le da poder al test      |
| runtime     | Legítimamente dinámico. El caso típico es un número de comprobante autoincremental: no se puede anclar sin romper el test | no, y está bien                         |
| sin-validar | Se copió de la app y todavía nadie lo miró                                                                                | sí, pero no se sabe si mide lo correcto |

Y la regla que lo ata: ningún caso se valida sólo contra sí mismo. Cada caso necesita al menos un esperado que no haya salido de la app en esa misma corrida.

### El estado incómodo: `sin-validar`

De los tres, el que más me costó aceptar fue el tercero. Mi primer impulso fue que no debía existir: si un esperado no está validado, el test no debería estar escrito.

Duró poco. Así trabajo de verdad. El test se escribe tomando los valores que muestra la app, después corro, reproduzco a mano, y recién ahí decido si ese número es la regla de negocio o un valor circunstancial.

Sin ese estado, "lo copié de la pantalla y nadie lo miró" es indistinguible de "ésta es la regla de negocio". Que es exactamente la confusión que produce falsos verdes.

No es un estado de reposo. Es deuda. Pero es deuda contada.

### Un cálculo hereda el peor de sus componentes

Si un esperado se calcula a partir de otros, es `regla` sólo si todos sus componentes lo son. Alcanza con que uno se lea de la app para que el resultado entero sea `runtime`.

Si el IVA debería ser 5 y un día la app devuelve 4, un esperado calculado con ese 4 confirma que 4 × lo que sea da lo que la app calculó con 4\. El test deja de medir el negocio y pasa a medir la coherencia de la app consigo misma, con la forma de un cálculo legítimo. Por eso cuesta verlo.

La forma más simple de cumplirlo: no calcular en el spec. El valor ya resuelto va al JSON y la fórmula a su `_calculo`. Los componentes quedan fijos por construcción y el número se puede recalcular a mano cuando cambie el negocio.

### Los dos tipos de comparación, y por qué van juntos

Hay dos formas de comparar, y hacen cosas distintas.

![App rota que devuelve $5.200,00 donde la regla dice $4.793,59. Contra el valor del JSON no coincide: rojo. Entre dos pantallas de la app coinciden igual: verde.](https://cesarbeassuarez.dev/content/images/2026/10/diagrama-dos-tipos-de-comparacion-1.png)

La misma app rota: el valor fijo la detecta, la comparación entre pantallas no.

Una es contra un valor fijo del JSON: "el precio unitario tiene que ser $4.793,59". Le digo ancla, porque es lo que sujeta el caso a un número que no sale de la app.

La otra es entre dos lecturas de la app: "el precio en la sucursal tiene que ser el mismo que en la empresa principal". No digo cuál es el precio, digo que los dos tienen que coincidir.

|                               | Qué detecta                                   | Qué no detecta                    |
| ----------------------------- | --------------------------------------------- | --------------------------------- |
| Contra un valor fijo del JSON | que el precio esté mal                        | nada: es el piso                  |
| Entre dos lecturas de la app  | que una pantalla lo muestre distinto que otra | que esté mal en las dos por igual |

Comparar dos lecturas entre sí no está prohibido, y agarra cosas que un valor fijo no ve. Lo que no se puede es un caso que tenga sólo eso: si el precio está roto en las dos pantallas, coinciden igual y el test da verde.

Por eso van juntas. Ninguna de las dos sobra.

---

## El instrumento: mutar los esperados

Una regla que nadie mide se degrada sola. El contrato garantiza que el esperado existe. Falta comprobar que tiene poder.

Corro la suite con un flag que desplaza todos los esperados por encima de su tolerancia. Entonces: todo test que pase es sospechoso.

Es la versión de bolsillo de lo que la industria llama mutation testing. La versión completa muta un valor por corrida, o sea N corridas. Con diez minutos por corrida eso es inviable, así que muto todos juntos en una sola. Es más débil. Prefiero decirlo.

Lo que sale al final, en una corrida donde sí hubo sobrevivientes:

```
🧬 MUTACIÓN — 13 tests · 34 aserciones mutadas
   ✔ 31 detectaron el cambio
   ✖  2 SOBREVIVIERON  ← revisar, no están midiendo
   ⊘  1 no mutable (origen: runtime)

```

Esos dos rojos no son defectos de la app. Son dos aserciones que no se enteraron de que les cambié el número debajo.

### El punto ciego del instrumento

Una aserción cuyo esperado no vino del JSON —una lectura previa de la app, un literal escrito en el spec— no se puede desplazar. No aparece en esas cuentas.

Y ésa es justo la forma del falso verde que más importa.

Por eso el resumen las lista aparte, y no en rojo:

```
🔍 4 aserciones comparan contra un valor que NO vino del JSON.
   No son un defecto por sí solas — hay tres formas legítimas.

```

Esa decisión la tomé después de la primera corrida. Si las marcaba en rojo, mi primera reacción iba a ser "arreglar" cuatro cosas que estaban bien. El listado es para clasificar, no para corregir:

| Cae en                                                            | Qué hacer                                                 |
| ----------------------------------------------------------------- | --------------------------------------------------------- |
| Verificación de acción (que el cliente que pedí sea el que quedó) | nada: aparecen siempre, es su naturaleza                  |
| Comparación entre dos lecturas de la app                          | confirmar que el caso tenga además un valor fijo del JSON |
| Valor leído de la app comparado contra la app                     | esto sí: agregarle un valor fijo del JSON                 |

En la primera corrida salieron cuatro y las cuatro eran correctas. Un instrumento que no explica sus propios falsos positivos no se usa dos veces.

---

## Por qué la validación manual no reemplaza esto

Esto fue lo que más me costó entender de todo el asunto.

Cuando reproduzco un caso a mano, compruebo una cosa: que el test hace los mismos pasos que hago yo y lee los mismos números. Eso sirve, pero sólo me dice que el test retrata bien cómo se comporta la app hoy.

La otra pregunta es la que importa: si mañana la app devuelve un número equivocado, ¿este test se pone rojo?

La validación manual no la responde, porque para responderla habría que ver la app rota, y la app no está rota. El reporte tampoco: muestra `esperado $15.694,87 · leído $15.694,87` y no dice nada sobre si ese verde podía haber sido rojo.

El principio viejo es "nunca confíes en un test que no viste fallar". En TDD te lo garantiza el orden: escribís el test antes que el código, así que lo ves en rojo sí o sí. Nosotros automatizamos sobre una app que ya funciona. Ese paso no existe. Hay que reemplazarlo con algo.

---

## Estado actual

- La mutación la corrí en algunas suites, no en todas. La foto completa no existe.
- Quedan esperados en `sin-validar` que tengo que ir confirmando de a uno.
- El gate que frenaría un commit con esperados sin `origen` está apagado a propósito. Con la deuda todavía grande frenaría cada commit sin dar nada a cambio. Lo prendo cuando la deuda esté acotada.

Esa última es la decisión más discutible de las tres y la sostengo igual: un gate que frena todo el tiempo deja de ser un control y pasa a ser algo que la gente aprende a saltear.

---

## Lo que aprendí

Cuando escribía los tests a mano sabía perfectamente cómo estaba hecho cada uno. Dónde se guardaba el valor esperado, cómo entraba desde el JSON o desde el Excel, qué línea hacía la comparación. Si algo no me cerraba, lo debuggeaba y lo miraba pasar paso por paso.

La desconfianza en los verdes ya existía entonces. Pero la tapaba con conocimiento directo: había leído ese test.

Hoy no debuggeo. Se escriben muchos más tests de los que puedo recorrer línea por línea, y no los escribí yo. Lo que perdí no es tiempo: es la certeza de haber visto por dónde pasaba la validación.

Entonces necesito poder confiar en que un test puede fallar sin haberlo leído. Eso es lo que hacen el contrato de esperados y la mutación: miden lo que antes yo comprobaba con el debugger.

La pregunta no es cuántos tests tengo ni qué porcentaje está en verde. Es cuántos de mis verdes podían haber sido rojos.

Hoy tengo un número para algunas suites. Me faltan las demás.