QA Bug Fix Verification
Esta guía explica qué hace el engine de NEO cuando ejecuta este plan. La idea es que puedas leerla, entender qué pasa en cada paso sin que nadie intervenga, y saber qué hace falta para que el trabajo salga bien.
En resumen
- Para qué sirve: confirmar, con pruebas, que el arreglo de un bug realmente funciona, y dejar un reporte con el "antes" (en rojo) y el "después" (en verde).
- Cuándo se ejecuta: después de que el developer aplicó el arreglo de un bug que antes pasó por el plan QA Bug Coverage.
- Qué necesita: la misma referencia al bug que se usó en QA Bug Coverage, y que ya exista la prueba que captura ese bug.
- Qué deja: las pruebas del bug ejecutadas (y reparadas si fallaban por motivos menores) y un reporte final de verificación con el antes y el después.
- Pasos: 4 — releer el bug, buscar sus pruebas, ejecutarlas hasta que pasen y reportar. Sin pausas.
¿Qué es un plan? (si es la primera vez que ves uno)
Un plan es una receta que ejecuta una máquina en lugar de una persona. Igual que un playbook, encadena varias skills en un orden fijo. La diferencia es que el playbook lo sigue el asistente de IA junto a vos, con pausas para que decidas; el plan lo ejecuta el engine de NEO solo, de punta a punta.
Ver Planes para la comparación completa entre plan y playbook.
1. ¿Qué hace este plan?
Es la segunda mitad del ciclo de un bug: después del arreglo, confirma que la prueba que antes fallaba ahora pasa. La primera mitad (confirmar el bug y crear esa prueba) la hace el plan QA Bug Coverage.
Su intención es que ningún bug se dé por cerrado "de palabra": el cierre tiene que estar respaldado por la misma prueba que demostró el bug, ahora en verde. Para eso, el plan:
- Vuelve a leer el bug, igual que lo hizo QA Bug Coverage. No depende de lo que haya quedado de esa ejecución anterior: arma su propio contexto desde cero.
- Busca las pruebas que cubren el bug: la prueba que generó QA Bug Coverage, más las que ya cubrían esa funcionalidad.
- Ejecuta solo esas pruebas y repara las que fallen por motivos menores, hasta que pasen.
- Escribe el reporte final, comparando el antes (la evidencia del bug) con el después (este resultado).
El plan no aplica ni sugiere ningún arreglo: asume que el developer ya lo aplicó.
2. ¿Cuándo se ejecuta?
| Situación | Ejemplo de negocio |
|---|---|
| El developer aplicó el arreglo de un bug que ya tiene su prueba en rojo | El developer de TechStore corrigió el control de stock del carrito y lo desplegó en staging |
| Hay que cerrar el bug con evidencia | El líder de QA de TechStore no cierra TS-BUG-31 sin un reporte que muestre la prueba en verde |
Se dispara una vez que el arreglo está listo: en texto libre (Modelo 2: el engine elige este plan), o desde el pipeline de CI con la regla que defina cada proyecto (por ejemplo, un push a la rama del arreglo, o una ejecución manual cuando el developer considera que el arreglo está listo).
Importante
- Primero tiene que haber pasado QA Bug Coverage. Este plan busca la prueba que captura el bug; si no la encuentra, se detiene sin ejecutar nada.
- El arreglo tiene que estar desplegado en la URL donde se ejecutan las pruebas. Si no, las pruebas validan la versión anterior y van a seguir en rojo.
- Conviene usar la misma referencia al bug que en QA Bug Coverage, así ambos planes encuentran las mismas pruebas y el mismo identificador.
3. ¿En qué se diferencia del playbook?
Este plan hace, sin nadie del otro lado, la segunda mitad del playbook Bug Fix Cycle:
| Playbook Bug Fix Cycle | Este plan | |
|---|---|---|
| Quién lo ejecuta | El asistente de IA, conversando con vos | El engine, solo |
| Cómo sabe que el arreglo está listo | Vos le avisás, después de la pausa | Se ejecuta cuando el CI o una persona lo dispara, después del arreglo |
| Qué pruebas ejecuta | La prueba del bug y después la regresión del módulo | Solo las pruebas que cubren el bug (la del bug más las que ya cubrían esa funcionalidad), no el módulo completo |
| Contexto | Lo trae de los pasos anteriores de la misma conversación | Lo arma desde cero: vuelve a leer el bug |
| Reporte | Antes y después | Antes y después, igual |
4. Ejemplo guía: "TechStore" corrige el control de stock
Seguimos con el caso del plan QA Bug Coverage. En TechStore, el carrito dejaba agregar más unidades de las que había en stock (TS-BUG-31). QA Bug Coverage confirmó el bug y dejó una prueba en rojo. Ahora el developer aplicó el arreglo y lo desplegó en staging: el carrito muestra un error al superar el stock.
4.1 Lo que el plan necesita recibir
| Dato | Obligatorio | Qué es | Ejemplo con TechStore |
|---|---|---|---|
bug_report |
Sí | La referencia al bug: la ruta a un archivo, la URL de un ticket de Jira o Azure DevOps, o el texto del reporte. La misma que se usó en QA Bug Coverage | https://techstore.atlassian.net/browse/TS-BUG-31 |
identifier |
Sí | El identificador del bug | TS-BUG-31 |
credentials |
Sí | Credenciales de prueba para entrar a la aplicación | Usuario y contraseña de prueba de staging |
4.2 Cómo se dispara
neo run plans/qa-bug-fix-verification.yaml --input-file input.json --workspace .
Donde input.json tiene los datos de la tabla anterior. Con el Modelo 2, el engine también puede elegir este plan a partir de un pedido como "ya se arregló el bug TS-BUG-31, verificalo".
4.3 Paso a paso
Paso 1 de 4 — Volver a leer el bug
Skill que se usa: lippia-neo-read-bug-report
Qué pasa: lee el reporte del bug igual que lo hizo QA Bug Coverage, para recuperar su identificador, sus criterios de aceptación y la URL de la aplicación. No reutiliza nada de la ejecución anterior: así el plan funciona aunque se ejecute días después.
Paso 2 de 4 — Buscar las pruebas del bug
Skill que se usa: lippia-neo-find-existing-tests
Qué pasa: busca en la carpeta de pruebas del proyecto las que cubren el bug. Ahí tiene que aparecer la prueba que generó QA Bug Coverage, más las que ya cubrían esa funcionalidad.
Con TechStore: encuentra la prueba nueva "no permitir superar el stock" y las pruebas del carrito que ya existían.
Punto de corte: sin pruebas, no hay nada que verificar
Si no encuentra ninguna prueba que cubra el bug, el plan se detiene acá (stopped). Ejecutar otras pruebas no demostraría que el bug reportado quedó arreglado. Normalmente significa que todavía no se ejecutó QA Bug Coverage para ese bug.
Paso 3 de 4 — Ejecutar las pruebas hasta que pasen
Skill que se usa: lippia-neo-run-and-heal
Qué pasa: ejecuta solo las pruebas que encontró el Paso 2. Si alguna falla por un motivo menor (un selector que cambió con el arreglo, una espera corta), la repara y vuelve a ejecutar, hasta 3 veces.
| Resultado | Qué significa |
|---|---|
| ✅ Todas las pruebas pasan | El arreglo funciona: la prueba del bug pasó de rojo a verde |
| ❌ Alguna prueba sigue fallando | El arreglo no resuelve el bug, o rompió otra cosa de esa funcionalidad |
Repara pruebas, no la aplicación
Si la prueba del bug sigue fallando porque el bug sigue ocurriendo, este paso no la "arregla" para que pase: queda como fallo en el reporte.
Con Lippia se ejecuta el módulo completo
Ejecutar solo algunas pruebas funciona con Playwright. Si el proyecto usa Lippia, no se puede acotar por archivo y se ejecuta el módulo completo.
Paso 4 de 4 — Reporte final: antes y después
Skill que se usa: lippia-neo-write-test-report
Qué pasa: escribe el reporte de verificación comparando dos momentos:
- Antes del arreglo: la evidencia de que el bug se reproducía, que dejó QA Bug Coverage.
- Después del arreglo: el resultado del Paso 3.
El reporte se escribe siempre, pasen o no las pruebas: tiene que reflejar el resultado real, no solo el caso feliz.
Qué queda: el reporte, con fecha y hora, en la carpeta de reportes del proyecto (por defecto test-results/reports/).
4.4 ¿Cómo termina?
| Cómo terminó | Estado del plan | Qué significa | Qué se hace |
|---|---|---|---|
| ✅ Las pruebas pasan | success |
El arreglo funciona | Cerrar el bug adjuntando el reporte |
| 🔴 Alguna prueba sigue fallando | success |
El plan funcionó, pero el arreglo no alcanza | Revisar el reporte con el developer y volver a ejecutar después del nuevo arreglo |
| ⏹ No había pruebas que cubrieran el bug | stopped |
No hay nada que verificar | Ejecutar primero QA Bug Coverage |
| ❌ Una skill devolvió algo mal formado, o algo se rompió | failed / error |
Falla del paso, no de la aplicación | Revisar el log y result.json |
Pruebas en rojo no es un error del engine
Si el arreglo no funciona, el plan igual termina en success: el engine hizo su trabajo y el resultado de las pruebas queda en el reporte y en result.json. Si el pipeline tiene que bloquearse en ese caso, la regla la define el CI leyendo ese resultado.
5. Problemas comunes (y qué hacer)
| Lo que ves | Por qué puede pasar | Qué hacer |
|---|---|---|
El plan termina stopped en el Paso 2 |
Todavía no se ejecutó QA Bug Coverage para este bug, o se usó otra referencia al bug | Ejecutar QA Bug Coverage primero, o usar la misma referencia que se usó ahí |
| La prueba del bug sigue en rojo | El arreglo no está desplegado en la URL de pruebas, o no resuelve el bug | Confirmar el despliegue; si está desplegado, revisar el reporte con el developer |
| Fallan otras pruebas además de la del bug | El arreglo rompió otra parte de la misma funcionalidad | No cerrar el bug; revisar con el developer |
| El reporte no muestra el "antes" | No se encontró la evidencia de reproducción que deja QA Bug Coverage | Confirmar que QA Bug Coverage se ejecutó en el mismo proyecto y con el mismo identificador de bug |
6. Resumen visual del flujo
flowchart TD
Z([QA Bug Coverage dejó<br/>la prueba del bug en rojo]) -.->|el developer aplica el arreglo| A
A([🔧 Arreglo desplegado<br/>ej: TechStore, control de stock]) --> B["<b>Paso 1</b> — Volver a leer el bug"]
B --> C["<b>Paso 2</b> — Buscar las pruebas del bug"]
C --> D{¿Encontró<br/>pruebas?}
D -->|No| X([⏹ stopped: ejecutar antes QA Bug Coverage])
D -->|Sí| E["<b>Paso 3</b> — Ejecutar y reparar<br/>hasta que pasen"]
E --> F["<b>Paso 4</b> — Reporte: antes y después"]
F --> G{¿Pasaron?}
G -->|Sí| H([✅ Bug cerrado con evidencia])
G -->|No| I([🔴 El arreglo no alcanza])
Plan original
El archivo del plan es plans/qa-bug-fix-verification.yaml, en el repositorio del engine (crowdar-engine-mvp). La referencia del formato está en Anatomía de un plan.