how-it-works · agentic-qa · sprint-testing

La Trifuerza — Probar Features por Capas

UI · API · DB. Pruebes lo que pruebes en una feature o historia de usuario, piensas SIEMPRE en las tres capas: una pantalla verde puede esconder una API rota y un trigger que falla en silencio. Smoke primero, luego las tres capas, con sondas de seguridad e integridad.

Smoke → UI → API → DBTu lente al probar cualquier feature en el sprint
Encuadre: la Trifuerza no es una técnica exclusiva de testing exploratorio — es el lente con el que pruebas CUALQUIER feature o historia de usuario. Cada vez que validas una funcionalidad, piensas en sus tres capas. Las tres fuerzas: UI (oro), API (magenta), DB (cian).

la verdad que duele

201 ≠ DB ✓

Un 201 Created no prueba que la base de datos quedó correcta — los triggers pueden no ejecutarse en silencio. La capa que responde bien no es la capa que persiste bien. Por eso se prueban las tres.

La regla cross-layer más importante: un 201 no prueba persistencia correcta. La pantalla verde, el status code OK y la fila en DB son tres verdades distintas. La Trifuerza existe para no confundirlas.

qué cubriremos

Probar Toda Feature, por Capas

00Ejes del testing — capas (la Trifuerza) vs niveles vs tipos, y cómo se cruzanel marco
01Smoke first — el gate Go/No-Go que valida el ambiente antes de probar a fondoel gate
02Capa UI — el loop por AC, edge cases, transiciones inválidas, DevToolsoro
03Capa API — la matriz de status codes y la sonda de RLS A/Bmagenta
04Capa DB — sondas de constraints, barridos de integridad, RLS en SQLcian
05Disciplina — triage bloqueante/no-bloqueante, TTL, sin NOT RUN, evidenciael oficio

3 quizzes interactivos a lo largo del recorrido — haz clic en las respuestas.

Seis partes: el marco de ejes (capas vs niveles vs tipos), el gate de smoke, las tres capas (UI/API/DB) y la disciplina transversal. El corazón es entender qué prueba cada capa — y que las capas se atraviesan SIEMPRE, sin importar el nivel o tipo de prueba.

el modelo

Tres Capas, Tres Verdades

UI

Lo que el usuario ve. ¿Renderiza, fluye, da feedback? Puede mostrar datos cacheados o mock.

API

El contrato. ¿Status correcto, schema válido, auth y RLS? El 2xx no garantiza la DB.

DB

La verdad persistida. ¿La fila existe, el trigger corrió, los constraints aguantan?

Tipo de featureOrden de capas
UI-focusedUI → API → DB
API-firstAPI → DB → UI
Data-focusedDB → API → UI
Full-stacklas tres
El orden de capas lo decide el tipo de feature. UI-focused empieza por UI; data-focused por DB. Smoke siempre va primero, antes de cualquier capa.

tres ejes, no uno

Capas · Niveles · Tipos

La Trifuerza es UN eje: las capas — dónde sondeas (UI · API · DB). Es ortogonal a otros dos ejes que el tester decide en cada prueba. No compiten: se combinan.

Capas — ¿dónde sondeas?

La Trifuerza. UI · API · DB. Cada feature se atraviesa por sus tres capas, siempre.

Niveles — ¿qué alcance?

component → integration → end-to-end (e2e). Cuánto del sistema entra en la prueba.

Tipos — ¿con qué intención?

funcional · regresión · smoke · seguridad · performance · usabilidad…

Cómo se cruzan

Una misma historia de usuario se prueba eligiendo un nivel y un tipo — pero SIEMPRE atravesando las tres capas. Ej.: un e2e funcional del checkout y una prueba de seguridad de la API distinta en nivel y tipo, idénticas en que ambas piensan UI/API/DB.

El marco mental clave: la Trifuerza es el eje de CAPAS (dónde), ortogonal a NIVELES (alcance: component/integration/e2e) y TIPOS (intención: funcional/regresión/smoke/seguridad/performance/usabilidad). El tester elige nivel + tipo por prueba, pero las tres capas se atraviesan siempre. Esto evita el malentendido de que la Trifuerza es solo para exploratorio.

EL GATE

Smoke First
Valida el Ambiente, no la Feature

5-10 minutos de Go/No-Go. Nunca entres a probar a fondo hasta que el smoke pase. Un ambiente roto produce reportes de bug falsos.

Smoke es obligatorio y primero. Valida que el ambiente esté vivo, no que la feature funcione — son preguntas distintas, ambas necesarias.

en orden, ≤10 min

El Checklist de Smoke

1

Acceso básico

La app carga, sin 500, assets renderizan, consola sin errores rojos (warnings amarillos OK).

2

Autenticación

Login, la sesión persiste al refrescar, logout funciona (saltar si el ticket es pre-auth).

3

Happy path

El flujo primario del ticket de punta a punta, 3-5 pasos, marca cada uno al funcionar.

4

Integración backend

Network tab durante el happy path: todas las llamadas /api/* en 2xx, los datos persisten tras F5.

SIEMPRE revisa el Network tab — aunque la UI se vea bien

La UI puede renderizar datos cacheados o mock. La red no miente: si la UI muestra algo pero no hubo llamada 2xx, no confíes en la pantalla.

4 pasos en orden. El paso 4 es clave: la UI puede engañar con cache/mock; el Network tab revela la verdad. Siempre revisar la red.

el veredicto y sus reglas

Go / No-Go

✓ PASS → continúa

  • Registra Smoke: PASSED en memory
  • Procede a UI / API / DB
  • Captura evidencia del home
vs

✗ FAIL → STOP

  • Es un bloqueante de ambiente
  • Triagea primero (NO auto-Critical)
  • Surfacea al usuario, NO pruebes a fondo

Las restricciones del smoke

Durante el smoke: no corras edge cases ni negativos · no abras bugs menores (solo bloqueantes) · no excedas 10 minutos. El smoke detecta bloqueantes, no documenta calidad.

PASS→continúa, FAIL→STOP (bloqueante de ambiente, triagea sin auto-Critical). Restricciones: solo bloqueantes, sin edge cases, ≤10min. Reportar bugs falsos por un ambiente roto es el peor desperdicio.

dos preguntas distintas

Smoke ≠ Testing Profundo de la Feature

Smoke pregunta…

"¿El ambiente está vivo?" — ¿carga, autentica, persiste el happy path? Si no, todo lo demás es ruido.

La Trifuerza pregunta…

"¿La feature funciona bien?" — ¿cumple los ACs, aguanta edge cases, es segura e íntegra en sus tres capas?

El orden importa

Un ambiente roto produce reportes de bug falsos. Si smoke falla y pruebas igual, vas a reportar "bugs" que en realidad son el ambiente caído. Smoke valida el ambiente; la Trifuerza valida la feature. Primero uno, luego la otra.

Anti-patrón S7: nunca saltar el smoke antes de la trifuerza. Son preguntas distintas — ambiente vs feature. El reachability gate (Stage Start) es aún anterior: ¿el env responde? Tres gates, tres preguntas.

CAPA 01 · UI

La Capa UI
Lo que el Usuario Ve

Valida los ACs, descubre edge cases, captura evidencia — y desconfía de la pantalla: puede esconder un fallo de la capa de abajo.

UI = oro. El loop por AC + edge cases + transiciones inválidas + reglas de DevTools.

el loop por cada AC

Navega → Observa → Captura

1

Navega + snapshot

Abre la URL de inicio, captura la estructura del DOM / árbol de accesibilidad.

2

Ejecuta + observa

Acciones del happy path paso a paso. ¿Resultado esperado? ¿estado UI raro? ¿consola roja? ¿red 4xx/5xx?

3

Captura + propaga estado

Screenshot en el estado clave ({KEY}-{n}-ac{N}-desc.png) y marca el outline PASSED/FAILED en memory.

Reglas de DevTools

Consola: rojo = log (amarillo OK). Red: filas rojas (4xx/5xx) siempre se anotan aunque la UI se vea bien — la UI puede enmascarar un fallo de API. >5s de carga = hallazgo de Performance. Desactiva el cache.

El loop: navegar→snapshot→ejecutar→observar(consola+red)→capturar→propagar estado. La regla de oro de DevTools: las filas rojas de red siempre cuentan, aunque la UI se vea verde.

el checklist por input / interacción

Edge Cases de la Capa UI

CategoríaQué probar
Boundary (BVA)vacío · min-1·min·min+1 · max-1·max·max+1 · 0 / -1 / MAX_INT · especiales <script>, '; DROP TABLE
UI / sesiónrefrescar a mitad de flujo · botón atrás · pestañas duplicadas · timeout / idle
Estado / transicióncada transición válida, luego una que el estado debe rechazar
Validación de datosemail inválido · password débil · doble submit · edición concurrente
Visualbreakpoints responsive · loading states · layouts rotos · elementos solapados

Si al probar encuentras un caso nuevo…

…que el ATP de Stage 1 no derivó (una partición, un boundary, una transición), añádelo de vuelta al set de outlines. La cobertura es el piso (ACs) más esta capa de riesgo, no el testing improvisado en lugar de la planificación.

El checklist de edge cases UI. Los caracteres especiales (script/DROP TABLE) son sondas de seguridad básicas. Lo encontrado se realimenta al plan, no reemplaza al plan.

donde se esconden los defectos

Transiciones Inválidas — el Punto Ciego

Para cualquier entidad con estado (draft→submitted→approved, cart→paid→shipped): dispara cada transición válida, luego dispara una que el estado actual debería rechazar.

draft submitted approved closed
la sonda: approve(closed) → ¿rechazado? un 200 silencioso sin cambio de estado = bug

El happy path casi siempre funciona

Lo que rompe es cuando alguien intenta hacer lo que el negocio no permite — aprobar algo ya cerrado, cancelar algo ya enviado. Las transiciones inválidas son donde viven los bugs de máquina de estados.

Conecta con la técnica State-Transition: 1 TC por transición inválida. El bug típico: un 200 OK silencioso que no cambia nada deja al usuario confundido.

cuándo bajar una capa

Cuándo Escalar a API / DB

UI renderiza pero el dato se ve mal

→ baja a §DB para confirmar qué se persistió de verdad.

Un botón dispara un request non-2xx

→ baja a §API para reproducir la llamada directamente.

Sospecha de RLS — ves filas que no deberías

→ baja a §API y §DB ambas.

La UI es el síntoma, no el diagnóstico

Cuando algo se ve mal arriba, la causa casi siempre está abajo. Escalar de capa es cómo pasas de "esto se ve raro" a "esto está roto aquí, por esto".

Reglas de escalado: dato mal→DB; non-2xx→API replay; RLS→ambas. La UI te dice QUE algo falla; las capas de abajo te dicen POR QUÉ.

CAPA 02 · API

La Capa API
El Contrato

Confirma contratos, auth, manejo de errores y RLS. Cada status code no es un número — es una prueba de que algo funciona (o no).

API = magenta. La matriz de status codes "qué prueba" + la sonda de RLS A/B. Esta capa enseña a leer status codes como evidencia.

descubrir + autenticar

Preparar el Testing de la Capa API

auth una vez, reutiliza
# credenciales SIEMPRE desde .env — nunca hardcodear
POST /auth/v1/token
  body: { email: {{env.STAGING_USER_EMAIL}}, password: {{env.STAGING_USER_PASSWORD}} }
  store: access_token, refresh_token, user.id

# registra los endpoints del ticket en una tabla en memory:
# | Method | Endpoint | Purpose | AC |

Gotcha de propagación de token

Algunos backends scopean el token por workspace/tenant. Si un request da 200 para un usuario y 403 para otro con el mismo rol, la propagación es la sospechosa — anótalo como descubrimiento, no como bug, hasta confirmarlo con el equipo.

Token una vez desde .env, reutilizar. La gotcha de propagación: mismo rol, distinto resultado = problema de scoping, no necesariamente bug. Confirmar antes de reportar.

cada status PRUEBA algo

La Matriz de Status Codes

EscenarioEsperadoQué prueba
Happy path200 / 201Contrato + data feliz
Campo requerido faltante400Validación viva
Input sobre-largo400 / 413Guardia de tamaño
Sin header de auth401Auth requerida
Token expirado401La rotación de token funciona
Recurso de otro tenant403 / vacíoRLS / aislamiento de tenant
Recurso inexistente200+vacío (PostgREST) / 404Semántica de not-found
Único duplicado409Manejo de conflicto
La idea núcleo de la capa API: un status code es evidencia. 400 prueba que la validación está viva; 403 prueba aislamiento de tenant; 409 prueba manejo de conflicto. No probar el negativo = no saber si la guardia existe.

la sonda de seguridad que casi nadie corre

Sonda de RLS / Autorización — A/B

Crítica para apps multi-tenant. Dos usuarios (A, B), el mismo rol. La pregunta: ¿puede A tocar lo de B?

A intenta acceder a lo de B
1. A lista recursos               solo las filas de A
2. A lee resource?user_id=eq.B    array vacío o 403
3. A hace PATCH a la fila de B     0 filas afectadas o 403

# resultado por sonda:  VERIFIED  o  VULNERABLE

Cualquier VULNERABLE es territorio de bug Critical

Si A puede leer o escribir lo de B, es una fuga cross-tenant — el peor tipo de defecto. Es un finding bloqueante: detiene la pasada de inmediato.

La sonda A/B con dos usuarios del mismo rol: listar-solo-lo-mío, leer-otro-tenant, PATCH-otra-fila. VULNERABLE = Critical = bloqueante. Esta es la sonda de seguridad de mayor valor de la capa API.

el handoff cross-layer

Un 201 No Prueba la DB

La API responde 201 Created

El contrato dice "creado". Pero un POST/PATCH exitoso solo prueba que la API aceptó la petición.

?

¿El trigger corrió? ¿La fila quedó bien?

Los triggers pueden no ejecutarse en silencio. El total calculado, las relaciones, los timestamps — todo eso vive en la DB.

Baja a §DB a confirmar

Tras cada POST/PATCH exitoso, verifica persistencia y ejecución de triggers en la base. La respuesta no es la verdad.

La regla de oro de la Trifuerza

Cada capa prueba su verdad. La API prueba el contrato; solo la DB prueba la persistencia. Confiar en el 201 es confiar en la capa equivocada.

El handoff cross-layer: 201 ≠ DB correcta (triggers silenciosos). Siempre confirmar persistencia en DB tras un write exitoso. Esta es la lección que une las tres capas.

quiz · smoke + UI + API

Las Capas de Arriba

Q1El POST devuelve 201 y la UI muestra "Orden creada". ¿Es suficiente para marcar el AC como PASSED?
ASí — 201 + UI verde = creado correctamente
BNo — un 201 no prueba la DB; baja a confirmar fila + trigger
CSí, si la consola no tiene errores rojos
No. Un 201 prueba que la API aceptó la petición, no que la DB quedó correcta — los triggers pueden no correr en silencio. Confirma persistencia (fila, total calculado, relaciones) en §DB antes de dar PASSED.
Q2El usuario A, con su token, hace GET resource?user_id=eq.B y recibe las filas de B (200). ¿Veredicto?
AVULNERABLE — fuga cross-tenant, bug Critical, finding bloqueante
BVERIFIED — devolvió 200, el endpoint funciona
CObservación menor — depende del rol
VULNERABLE. A no debería ver nada de B. Leer datos de otro tenant es una fuga de aislamiento — Critical, y bloqueante: detiene la pasada de inmediato. La sonda RLS A/B es justo para cazar esto.
Las dos lecciones clave de UI+API: el 201 no prueba la DB, y la sonda RLS A/B caza fugas cross-tenant (VULNERABLE = Critical bloqueante).

CAPA 03 · DB

La Capa DB
La Verdad Persistida

Confirma estado, constraints, triggers y RLS a nivel SQL. Aquí la pregunta cambia: en las sondas negativas, el éxito es el bug.

DB = cian. State verification + constraint probes (éxito=bug) + integrity sweeps + RLS en SQL. La capa donde se invierte la lógica: las sondas negativas deben fallar.

después de una acción API / UI

Verificación de Estado

CheckPatrón de query
La fila existeSELECT * FROM {table} WHERE id = '{id}'
La relaciónJOIN hijo a padre, compara el conteo esperado
El trigger corriócompara el total guardado vs SUM(items)
Timestamps sanoscreated_at reciente, updated_at >= created_at

Aquí se cobra el 201

El "trigger corrió" es exactamente la verdad que el 201 no podía dar: si el total guardado ≠ la suma de los items, el trigger falló en silencio aunque la API respondió 201.

Las 4 verificaciones de estado post-acción. "El trigger corrió" (total guardado vs SUM) es donde se atrapa el trigger silencioso que el 201 ocultó.

la lógica invertida

Sondas de Constraints — el Éxito es el Bug

ConstraintSonda (todas deben ERRORAR)
FKINSERT hijo con parent id inexistente
CHECKUPDATE a un valor de enum inválido
UNIQUEINSERT duplicado de columna única
NOT NULLINSERT con NULL en columna requerida

Si la sonda tiene éxito, el constraint falta — y eso es el bug

Estas sondas deben fallar TODAS. Un INSERT inválido que pasa significa que la base no está protegiendo la integridad. Envuelve cada sonda en una transacción y haz ROLLBACK para no contaminar staging.

La lógica se invierte: en sondas negativas, el éxito = constraint ausente = bug. FK/CHECK/UNIQUE/NOT NULL deben errorar todas. Siempre en transacción + ROLLBACK.

barridos de integridad

Cazar Datos Corruptos

SQL · estas queries deben volver 0 filas
-- huérfanos: hijos sin padre
SELECT c.* FROM child c LEFT JOIN parent p ON c.fk=p.id WHERE p.id IS NULL;

-- calc mismatch: total guardado ≠ suma real
SELECT o.id, o.total, COALESCE(SUM(i.qty*i.unit_price),0) AS calc
FROM orders o LEFT JOIN order_items i ON o.id=i.order_id
GROUP BY o.id, o.total HAVING o.total != calc;

-- estados de dominio imposibles
SELECT * FROM orders WHERE status='delivered' AND payment_status!='completed';

Cualquier fila devuelta es un defecto de integridad

Un pedido "entregado" sin pago "completado" es un estado que el negocio jamás debería permitir. Estos barridos cazan la corrupción que ninguna prueba de UI vería.

Tres barridos: huérfanos, calc mismatch, estados imposibles. Cada uno debe volver 0 filas. Correr periódicamente en features con mucha data. Caza lo que la UI nunca muestra.

RLS real + cascadas

RLS a Nivel SQL y Limpieza

RLS de verdad

El rol qa_team suele saltar RLS. Para probarla real, impersona el JWT:

BEGIN;
SET LOCAL request.jwt.claim.sub = '{user-a}';
SELECT * FROM {table}; -- solo filas de A
ROLLBACK;

Cascadas de limpieza

Tras probar flujos CRUD, verifica que la limpieza cascadea:

  • DELETE padre → ¿los hijos se van?
  • Soft-delete: ¿flag puesto, fila aún presente?
  • Registra CLEANUP COMPLETE / INCOMPLETE

Si el SQL directo salta la RLS

Cae a la sonda API §RLS A/B — esa pasa por el enforcement real de la aplicación. Dos caminos para la misma verdad de seguridad.

RLS real necesita impersonar el JWT (qa_team la salta). Cleanup: cascadas de DELETE y soft-delete. Si el SQL salta RLS, usar la sonda API A/B (enforcement real).

quiz · capa DB

La Verdad Persistida

Q1Sondas la constraint UNIQUE insertando un duplicado, y el INSERT tiene éxito (no errora). ¿Qué significa?
ABien — la base aceptó el dato, todo en orden
BBug — el constraint UNIQUE falta; la sonda negativa debía errorar
CObservación — depende de la columna
Bug. En sondas de constraints la lógica se invierte: el éxito es el defecto. Un duplicado que pasa = la base no protege la unicidad. Por eso las sondas FK/CHECK/UNIQUE/NOT NULL deben errorar todas (en transacción + ROLLBACK).
Q2Tu barrido devuelve un pedido con status='delivered' y payment_status='pending'. ¿Acción?
AIgnorar — la UI no lo muestra, no afecta al usuario
BDefecto de integridad — un estado de dominio imposible que el negocio nunca debe permitir
CNormal — los estados son independientes
Defecto de integridad. "Entregado sin pago completado" es un estado imposible. Los barridos de integridad cazan exactamente esta corrupción silenciosa — invisible en la UI, real en los datos.
Las dos lecciones DB: en sondas de constraints el éxito = bug; y los estados de dominio imposibles son defectos de integridad aunque la UI no los muestre.

EL OFICIO

La Disciplina
Que Hace la Pasada Confiable

Cuándo detenerse y cuándo seguir, cómo tratar el tiempo, y por qué ningún test puede quedar en NOT RUN.

La capa transversal: triage de findings, TTL, status propagation, evidencia. Lo que separa una pasada profesional de un click-around.

la pausa graduada

Bloqueante vs No-Bloqueante

Un FAIL durante el testing de la feature no es automáticamente Critical y no detiene la pasada por sí solo. Triagea primero, luego decide.

Bloqueante → STOP

  • smoke / ambiente caído
  • corrupción / pérdida de integridad
  • seguridad explotable (RLS VULNERABLE, bypass de auth, cross-tenant)
vs

No-bloqueante → log + sigue

  • cosmético, gap de validación menor
  • edge case en un TC no crítico
  • finding de seguridad/framework-default pendiente de recalibración

Por qué no parar por todo

Pausar una pasada de 17 TCs por un hallazgo cosmético desperdicia el dispatch y pierde cobertura. Un finding no-bloqueante se registra y la pasada continúa; todos se surfacean juntos al cierre de Stage 2. Un bloqueante genuino sí detiene de inmediato.

La pausa graduada: bloqueante (env/corrupción/seguridad) detiene; no-bloqueante (cosmético/menor) se registra y la pasada sigue. Un FAIL no es auto-Critical. El objetivo es cobertura completa.

probar el tiempo sin esperar

Casos Dependientes del Tiempo (TTL)

Magic links, OTPs, tokens, sesiones, caches: "a las 14:59 funciona, a las 15:01 no". No se prueban haciendo clic más rápido — necesitas controlar el tiempo. Elige la opción más alta que el stack permita.

1

Fixture / TTL corto

La mejor. Si el env expone un TTL configurable, ponlo en segundos y prueba el borde 14:59/15:01 real. Ejercita el código de expiry verdadero.

2

Clock-mock

Si el stack permite inyectar/congelar el tiempo, avanza el reloj y asegura la expiración — siempre que el mock maneje la lógica real, no una rama de test.

3

Defer manual escrito

Último recurso. Documenta el borde que no pudiste ejercitar, por qué, y el follow-up concreto (ej. "añadir MAGIC_LINK_TTL override").

Nunca un BLOCKED a secas

Marca BLOCKED — needs time fixture con la opción elegida (1/2/3) y una línea de razón. Un BLOCKED sin camino de decisión pierde cobertura en silencio.

La escalera TTL de 3 opciones por prioridad: fixture > clock-mock > defer escrito. Nunca un BLOCKED desnudo — siempre "BLOCKED — needs time fixture" + opción + razón.

cerrar la pasada con rigor

Sin NOT RUN · Evidencia que Sirve

Propagación de estado

Al cerrar Stage 2, cada outline / TC tiene PASSED o FAILED. Sin NOT RUN. Si uno queda NOT RUN: o está fuera de scope (di por qué en Notes) o está incompleto (vuelve al loop).

Disciplina de evidencia

  • Nombre: {KEY}-{n}-ac{N}-desc.png
  • Captura en el estado de fallo, no navegando hacia él
  • evidence/ gitignored, nunca commiteado

El log es el handoff a Stage 3

El bloque Stage-2 de test-session-memory.md (smoke + tablas UI/API/DB + Findings) es lo que Stage 3 consume: los Findings alimentan los bugs, los pass/fail alimentan el ATR.

Sin NOT RUN: todo termina PASSED o FAILED. Evidencia en el estado de fallo, nombrada y gitignored. El memory de Stage 2 es el input de Stage 3 (Findings→bugs, pass/fail→ATR).

quiz · disciplina

El Oficio de la Pasada

Q1En el TC #4 de 17 encuentras un texto desalineado (cosmético). ¿Detienes la pasada?
ASí — todo FAIL detiene la pasada y se reporta de inmediato
BNo — es no-bloqueante: lo registro y sigo; lo surfaceo todo junto al cierre
CSí — abro un bug Critical para no olvidarlo
No, sigue. Un cosmético es no-bloqueante: se registra en Findings, el TC queda FAILED y la pasada continúa para no perder los otros 13 TCs. Solo lo bloqueante (env/corrupción/seguridad) detiene. Un FAIL no es auto-Critical.
Q2Un TC valida que un magic link expira a los 15 min, pero no hay forma de adelantar el reloj hoy. ¿Cómo lo cierras?
ALo dejas en NOT RUN
BBLOCKED a secas — no se pudo correr
CBLOCKED — needs time fixture + la opción elegida y la razón
BLOCKED — needs time fixture. Nunca un BLOCKED desnudo ni un NOT RUN. Documenta el borde, por qué no se pudo, y el follow-up (opción 3: defer escrito). Así la cobertura no se pierde en silencio y viaja a Stage 3.
Las dos reglas de disciplina: cosmético = no-bloqueante (sigue), y nunca BLOCKED/NOT RUN desnudo (siempre con razón + camino).

todo junto

La Pasada Completa de Testing de una Feature

Smoke ✓ UI API DB Findings
El recap del flujo completo: smoke → UI/API/DB (orden por feature) → triage → status → findings a Stage 3. Las tres fuerzas en una pasada.

el checklist del tester

Cómo Hacerlo Bien

  • Smoke antes que todo — un ambiente roto da bugs falsos.
  • Desconfía de la UI — revisa la red aunque se vea verde.
  • Lee los status codes como evidencia — cada uno prueba algo.
  • Corre la sonda RLS A/B — multi-tenant siempre.
  • Confirma en DB tras cada write — el 201 no basta.
  • Sondas negativas: éxito = bug — en transacción + ROLLBACK.
  • Prueba las transiciones inválidas — ahí viven los defectos.
  • Cierra sin NOT RUN — cada TC PASSED o FAILED, con evidencia.

La meta

Que ningún defecto cruce las tres capas sin ser visto: ni el que la UI esconde, ni el que la API maquilla, ni el que la DB corrompe en silencio.

El checklist operativo del cómo hacerlo bien. Cada punto es una palanca contra un punto ciego de capa.

para llevar

Tres Ideas que se Quedan

1

Cada capa, su verdad

La UI muestra, la API contrata, la DB persiste. Un 201 no prueba la base; una pantalla verde no prueba la API.

2

El negativo es el oro

Los status de error, las transiciones inválidas, las sondas de constraint (éxito=bug) y RLS A/B cazan lo que el happy path nunca toca.

3

Disciplina sobre impulso

Smoke primero, triage graduado, sin NOT RUN. La cobertura completa vale más que parar por el primer hallazgo.

Los tres conceptos núcleo: cada capa su verdad, el valor del negativo/seguridad, y la disciplina de la pasada.

Tres Capas. Una Verdad. Ningún Punto Ciego.

Smoke valida el ambiente → la Trifuerza valida la feature: UI (lo que se ve), API (el contrato), DB (lo que persiste). Prueba el negativo, confirma una capa abajo, cierra sin NOT RUN.

← → navegar · S notas del orador · O resumen · T tema

Cierra atando las tres capas y la disciplina. La Trifuerza es cómo un defecto no cruza las tres capas sin ser visto.
⭐ 0/6
← → navegar · O resumen · S presentador · N notas · F pantalla