27. Verificación, validación y gestión de defectos

27.1 Introducción

Las pruebas de software aportan información sobre calidad y riesgo. Dentro de ese contexto, dos conceptos son fundamentales: verificación y validación. Además, cuando se encuentran problemas, el equipo necesita gestionarlos de manera ordenada mediante una buena gestión de defectos.

Verificar y validar ayudan a responder si el sistema fue construido correctamente y si realmente resuelve la necesidad. Gestionar defectos ayuda a registrar, priorizar, corregir y aprender de los problemas encontrados.

En este tema veremos cómo se conectan estas actividades y por qué son importantes para la Ingeniería de Software.

27.2 Verificación

La verificación busca comprobar si el software, los documentos o los componentes fueron construidos de acuerdo con lo especificado. Responde a la pregunta: ¿estamos construyendo correctamente el producto?

Ejemplos de verificación:

  • Revisar que un requisito esté implementado según lo acordado.
  • Ejecutar pruebas unitarias sobre una función.
  • Comprobar que una API responde con el formato documentado.
  • Verificar que una regla de negocio fue codificada correctamente.
  • Revisar código contra estándares del equipo.
  • Validar que una migración de base de datos se ejecuta sin errores.
Idea clave: la verificación compara el producto contra especificaciones, diseños, criterios o estándares definidos.

27.3 Validación

La validación busca comprobar si el software resuelve la necesidad real del usuario o del negocio. Responde a la pregunta: ¿estamos construyendo el producto correcto?

Ejemplos de validación:

  • Mostrar un prototipo a usuarios y confirmar que el flujo resulta útil.
  • Validar una funcionalidad con referentes del negocio.
  • Realizar pruebas de aceptación con criterios acordados.
  • Observar si el sistema mejora el proceso real.
  • Comparar la solución entregada con los objetivos del proyecto.
  • Confirmar que el usuario puede completar una tarea sin pasos innecesarios.

La validación es esencial porque un sistema puede cumplir la especificación y aun así no resolver el problema correcto.

27.4 Diferencia entre verificación y validación

Aspecto Verificación Validación
Pregunta ¿Construimos correctamente lo especificado? ¿Construimos lo que realmente se necesita?
Referencia Requisitos, diseño, estándares, criterios técnicos. Necesidades de usuarios, objetivos de negocio, contexto real.
Ejemplo La reserva se cancela según la regla de dos horas. El flujo de cancelación resulta comprensible para usuarios reales.
Participantes Equipo técnico, testers, revisores. Usuarios, clientes, referentes de negocio y equipo.

27.5 Actividades de verificación y validación

Estas actividades pueden aparecer durante todo el ciclo de vida del software.

  • Revisión de requisitos para detectar ambigüedades.
  • Revisión de diseño y arquitectura.
  • Revisión de código.
  • Pruebas unitarias, de integración, sistema y aceptación.
  • Prototipos y demostraciones con usuarios.
  • Validación de criterios de aceptación.
  • Pruebas de rendimiento, seguridad o usabilidad.
  • Verificación posterior al despliegue.

No todo se verifica con pruebas ejecutables. Algunas verificaciones se realizan revisando documentos, modelos, código o decisiones.

27.6 Defecto

Un defecto es un problema en el producto, código, configuración, diseño, documentación o datos que puede provocar un comportamiento incorrecto o indeseado.

Ejemplos de defectos:

  • Una fórmula calcula mal un impuesto.
  • Una validación permite reservas duplicadas.
  • Un botón ejecuta una acción incorrecta.
  • Una API devuelve un formato distinto al documentado.
  • Un mensaje de error confunde al usuario.
  • Una configuración apunta al ambiente equivocado.
  • Una regla de seguridad no se aplica a cierto rol.

Los defectos no siempre están en el código. También pueden estar en requisitos, documentación, datos, configuración o procesos.

27.7 Gestión de defectos

La gestión de defectos es el proceso de registrar, analizar, priorizar, corregir, verificar y cerrar defectos. Su objetivo es que los problemas encontrados no se pierdan y puedan tratarse según su impacto.

Incluye actividades como:

  • Registrar el defecto con información suficiente.
  • Confirmar si realmente es un defecto.
  • Clasificar severidad y prioridad.
  • Asignar responsable de análisis o corrección.
  • Corregir el problema.
  • Verificar la corrección.
  • Cerrar el defecto o reabrirlo si persiste.
  • Analizar causas si el defecto es importante o repetido.

27.8 Reporte de defectos

Un buen reporte de defecto debe permitir comprender el problema y, si es posible, reproducirlo. Cuanta más clara sea la información, más rápido podrá analizarse.

Título Resumen claro del problema.
Descripción Qué ocurre y por qué se considera incorrecto.
Pasos para reproducir Secuencia de acciones que permite observar el problema.
Resultado esperado Qué debería ocurrir.
Resultado obtenido Qué ocurrió realmente.
Ambiente Navegador, versión, sistema, datos o configuración relevante.
Evidencia Captura, video, log, identificador de operación o archivo relacionado.
Impacto Qué usuarios, funciones o procesos se ven afectados.

27.9 Severidad y prioridad

La severidad y la prioridad no significan lo mismo.

Concepto Qué indica Ejemplo
Severidad Impacto técnico o funcional del defecto. El sistema permite cobrar un importe incorrecto.
Prioridad Urgencia con la que debe corregirse. Debe corregirse antes de publicar la versión.

Un defecto puede tener alta severidad pero baja prioridad si ocurre en una función que no se usará en la próxima entrega. También puede tener baja severidad pero alta prioridad si afecta una demostración o mensaje visible importante.

27.10 Ciclo de vida de un defecto

Un defecto suele pasar por distintos estados. Los nombres pueden variar según la herramienta o el equipo, pero un flujo simple es:

Nuevo -> confirmado -> asignado -> en corrección -> corregido -> verificado -> cerrado.

También pueden existir estados como:

  • Reabierto, si la corrección no resolvió el problema.
  • Duplicado, si ya existe otro reporte del mismo defecto.
  • No reproducible, si no se logra observar el problema con la información disponible.
  • No es defecto, si el comportamiento coincide con lo esperado.
  • Postergado, si se decide corregirlo en una versión futura.

27.11 Ejemplo de reporte de defecto

Ejemplo para un sistema de reservas:

Título El sistema permite reservar dos veces el mismo horario.
Pasos Ingresar con dos usuarios, seleccionar el mismo horario disponible y confirmar ambas reservas casi al mismo tiempo.
Resultado esperado Solo una reserva debe confirmarse; la segunda debe informar que el horario ya no está disponible.
Resultado obtenido Ambas reservas quedan confirmadas para el mismo horario.
Impacto Puede generar sobreventa de cupos y conflictos operativos.
Severidad Alta.
Prioridad Alta si la funcionalidad será publicada en la próxima entrega.

27.12 Verificación de correcciones

Cuando un defecto se corrige, debe verificarse que la corrección funciona. Esta verificación no debería limitarse al caso exacto reportado si existen riesgos relacionados.

Conviene revisar:

  • Que el defecto original ya no ocurre.
  • Que se cubren casos similares.
  • Que no se rompieron funcionalidades relacionadas.
  • Que las pruebas nuevas o existentes pasan.
  • Que la documentación o mensajes se actualizaron si corresponde.
  • Que el estado del defecto se actualiza correctamente.

27.13 Defectos y regresión

Una regresión ocurre cuando algo que antes funcionaba deja de funcionar por un cambio reciente. Por eso, al corregir un defecto conviene agregar pruebas que eviten que el mismo problema vuelva a aparecer.

Ejemplo:

  • Se detecta que el sistema permite reservas duplicadas.
  • Se corrige la validación de disponibilidad.
  • Se agrega una prueba automatizada que intenta reservar el mismo horario dos veces.
  • En futuras modificaciones, esa prueba ayuda a detectar si el problema vuelve.

La gestión de defectos no solo corrige problemas actuales; también ayuda a prevenir repetición.

27.14 Análisis de causa raíz

Cuando un defecto es grave o se repite, conviene analizar su causa raíz. La pregunta no es solo "¿qué línea de código falló?", sino "¿por qué el defecto llegó hasta aquí?".

Posibles causas:

  • Requisito ambiguo.
  • Regla de negocio no documentada.
  • Diseño inadecuado.
  • Falta de pruebas en un caso importante.
  • Revisión de código insuficiente.
  • Configuración incorrecta.
  • Comunicación incompleta entre áreas.

Analizar causas permite mejorar el proceso, no solo corregir síntomas.

27.15 Métricas básicas de defectos

Las métricas deben usarse con cuidado, pero pueden aportar información útil.

  • Cantidad de defectos abiertos.
  • Cantidad de defectos cerrados por versión.
  • Defectos por severidad.
  • Tiempo promedio de resolución.
  • Defectos reabiertos.
  • Defectos detectados en producción.
  • Áreas del sistema con más defectos.

Las métricas no deben usarse para culpar personas. Deben ayudar a entender riesgos, calidad y oportunidades de mejora.

27.16 Roles en la gestión de defectos

Varias personas pueden participar:

  • Quien detecta el defecto lo registra con claridad.
  • Un analista puede aclarar si el comportamiento esperado está bien definido.
  • Un desarrollador analiza causa y corrige.
  • Un tester verifica la corrección.
  • El responsable del producto prioriza según impacto de negocio.
  • Soporte aporta información de usuarios reales.
  • Operaciones puede aportar logs, monitoreo y contexto del ambiente.

La gestión de defectos funciona mejor cuando el equipo colabora en lugar de tratar el defecto como un problema de un solo rol.

27.17 Errores comunes

Al gestionar defectos suelen aparecer errores como:

  • Reportar defectos sin pasos ni resultado esperado.
  • Confundir severidad con prioridad.
  • Cerrar defectos sin verificar la corrección.
  • No analizar regresiones.
  • No relacionar defectos con requisitos o pruebas.
  • Ignorar defectos pequeños que se repiten mucho.
  • Usar métricas para culpar en lugar de mejorar.
  • No registrar defectos encontrados informalmente.
  • No actualizar el estado del defecto.

27.18 Buenas prácticas

Algunas buenas prácticas son:

  • Registrar defectos con información reproducible.
  • Definir severidad y prioridad con criterios claros.
  • Relacionar defectos con requisitos, versiones y pruebas.
  • Verificar correcciones antes de cerrar.
  • Agregar pruebas de regresión para defectos importantes.
  • Analizar causas en defectos graves o repetidos.
  • Comunicar defectos críticos de forma temprana.
  • Usar métricas para mejorar el proceso.
  • Mantener un flujo de estados simple y conocido por el equipo.

27.19 Qué debes recordar de este tema

  • La verificación pregunta si construimos correctamente lo especificado.
  • La validación pregunta si construimos lo que realmente se necesita.
  • Un defecto puede estar en código, requisitos, diseño, configuración, datos o documentación.
  • Un buen reporte de defecto debe permitir comprender y reproducir el problema.
  • Severidad indica impacto; prioridad indica urgencia de corrección.
  • Los defectos deben pasar por un ciclo de vida claro.
  • Analizar causas ayuda a mejorar el proceso y prevenir repetición.

27.20 Conclusión

Verificación, validación y gestión de defectos son prácticas centrales para construir software con mayor calidad. Permiten comprobar cumplimiento, validar utilidad real y tratar los problemas encontrados de forma ordenada.

Para quien comienza, la idea principal es esta: un defecto bien gestionado no solo se corrige; también deja información útil para mejorar el producto, las pruebas y el proceso de desarrollo.

En el próximo tema veremos calidad del producto software y atributos de calidad, ampliando la mirada más allá de defectos funcionales hacia características generales del producto.