Gestión de Pruebas de Software: Conceptos Esenciales y Metodologías de Testing

Introducción a la Gestión de Pruebas

Conceptos Fundamentales

• Defectos: Un **defecto** es un error, fallo o discrepancia no deseada, comúnmente conocido como *bug*.
• Causas:
  • Errores en el **código**
  • Falta de **requisitos** claros
  • Gestión inadecuada de **cambios**
  • **Integración defectuosa** de componentes
• Impacto:
  • Fallos en el sistema
  • Poca **seguridad**
  • Baja **satisfacción** del usuario
  • **Costos** elevados
• Solución:
  • Identificación mediante **pruebas**
  • **Reporte detallado** del defecto
  • **Priorización y asignación** para su corrección
  • **Validación post-corrección**

Pruebas y Gestión de Pruebas

Pruebas: Proceso para evaluar la **funcionalidad** de un sistema y determinar si cumple con los **requisitos** establecidos.

Gestión de Pruebas: Proceso de **supervisar, controlar y dirigir** todas las actividades relacionadas con las pruebas de software.

Beneficios de la Gestión de Pruebas

• **Aseguramiento de la calidad**
• **Minimización de riesgos**
• Mejora de la **experiencia de usuario (UX)**

Roles en las Pruebas

• Desarrolladores: Realizan principalmente **pruebas unitarias**.
• Testers: Diseñan y ejecutan **casos de prueba**, realizan **pruebas manuales** o **automatizadas**, y efectúan la **evaluación externa** del software.
• *Stakeholders*: Participan en las **pruebas de aceptación** y proporcionan **retroalimentación**.
• Equipos de Integración: Realizan **pruebas de integración** para asegurar el correcto funcionamiento del sistema en su conjunto.

  ---

Tipos de Pruebas

Pruebas Funcionales

• **Unitarias**
• **Integración**
• **Sistema**
• **Aceptación**

Pruebas No Funcionales

• **Volumen**
• **Estrés**
• **Rendimiento**
• **Usabilidad**
• **Seguridad**
• **Instalación**
• **Documentación**

Pruebas Unitarias

Verifican unidades individuales de software. Consideraciones clave: **aislamiento**, **automatización**, **cobertura**, uso de *mocks* y *stubs*, y que sean **rápidas**.

Pruebas de Integración

Exponen defectos entre las **interfaces** y en las **interacciones** de componentes integrados. Consideraciones: **interfaces**, **integración incremental**, *stubs* y *drivers*, **datos compartidos** y **gestión de errores**.

Pruebas de Sistema

Verificación total del sistema para asegurar su **funcionamiento** global. Consideraciones: cumplimiento de **requisitos**, **entorno** de prueba, **interacción** entre módulos y **rendimiento**.

Pruebas de Aceptación

Verifican el sistema según las expectativas del **cliente**. Consideraciones: **criterios de aceptación**, participación del **cliente**, **escenarios de uso** y **documentación**.

Pruebas de Volumen

Evalúan el sistema con **grandes cantidades de datos**.

Pruebas de Estrés

Evalúan el sistema en **condiciones extremas** o de **sobrecarga**.

Pruebas de Rendimiento

Evalúan el sistema bajo **condiciones específicas de carga** y **concurrencia**.

Pruebas de Usabilidad

Evalúan la **experiencia de usuario (UX)** al interactuar con el sistema.

Pruebas de Seguridad

Identifican **vulnerabilidades** y **amenazas** en el sistema.

Pruebas de Instalación

Evalúan el proceso de **instalación** y **desinstalación** del software.

Pruebas de Documentación

Evalúan la **calidad, claridad y utilidad** de la documentación del software.

Pruebas de Caja Negra

Verifican que el software cumpla con las **especificaciones** y realice las **funciones esperadas** sin considerar su estructura interna. Pueden incluir: **pruebas de partición**, **valores límite** y **tablas de decisión**.

Pruebas de Caja Blanca

Aseguran que todas las **rutas lógicas** sean probadas e identifican errores en **bucles**, **condiciones** y **secuencias**. Pueden incluir: **cobertura de código**, **camino básico** y **pruebas de lazo**.

Pruebas Unitarias

Concepto

Validación individual de componentes de software, como **funciones, métodos o clases**.

Objetivos

• **Detección temprana de errores**
• Facilita la **refactorización** del código
• Promueve un **mejor diseño** de software

Ventajas

• **Reducción de *bugs***
• **Disminución de costos** a largo plazo
• **Mejora la calidad del código**
• Aumenta la **confianza** en el software

Características

• **Automatizables**
• **Completas** (en su alcance)
• **Repetibles**
• **Independientes** entre sí

Desarrollo Dirigido por Pruebas (TDD)

Metodología de desarrollo con un **ciclo corto de retroalimentación**: **escribir la prueba**, **escribir el código** y **refactorizar**. Sus beneficios incluyen: **calidad del código**, **simplicidad** y **confianza** en el software.

JUnit

**JUnit** es un *framework* de **pruebas unitarias para Java**, desarrollado por **Kent Beck y Erich Gamma**. Forma parte de la familia *xUnit*.

Ventajas

• **Popularidad** y amplia comunidad
• **Fácil integración** con entornos de desarrollo
• Facilita la implementación de **TDD**

Anotaciones Comunes

• `@Test`
• `@BeforeAll`
• `@AfterAll`
• `@Disabled`
• `@DisplayName`
• `@RepeatedTest`
• `@ParameterizedTest`

Aserciones Comunes

Evalúan si una condición es verdadera; de lo contrario, la prueba falla. Ejemplos:

• `assertEquals`
• `assertNotEquals`
• `assertTrue`
• `assertFalse`
• `assertNull`
• `assertNotNull`
• `assertArrayEquals`
• `assertThrows`
• `assertTimeout`

Pruebas de Integración

Concepto

Validan la **interacción** entre distintas partes del sistema y evalúan el **funcionamiento conjunto** de los componentes.

Necesidad

Son necesarias para:

• **Detectar problemas** de interfaz
• Asegurar el **flujo de datos** correcto
• Validar la **interoperabilidad** de componentes
• Manejar la **diversidad lógica**
• Adaptarse a **cambios estructurales**

Tipos de Estrategias

• **Top-Down**
• **Bottom-Up**
• **Big Bang**

Momento de Realización

Se realizan:

• Después de las **pruebas unitarias**
• Durante la **integración de funcionalidades**
• Tras **actualizaciones** significativas
• Antes del **despliegue**
• En un *pipeline* de **CI/CD** (Integración Continua/Despliegue Continuo)

Ventajas

• **Resolución temprana** de problemas
• Identificación de **problemas de integración**
• Mayor **cobertura** y **exhaustividad** en las pruebas

Desventajas

• **Complejidad** en la configuración
• **Dependencia de componentes externos**
• **Costo** en tiempo y recursos

Desafíos

• **Complejidad** inherente
• Gestión de **recursos** (costo y tiempo)

Casos de Uso Comunes

• **APIs externas o internas**
• **Bases de datos**
• Módulos de **interfaz de usuario** con *backend*

Técnicas de Diseño

• **Diagramas de secuencia**
• **Casos de prueba** basados en flujos de negocio

Herramientas Comunes

• **JUnit** y **TestNG** (para Java)
• **Pytest** (para Python)
• **Postman** (para APIs)

Automatización

Herramientas como **Jenkins** o **GitLab CI/CD** permiten la automatización, lo que resulta en **rapidez** y **menos errores**.

@Test
    public void testDesplazamientoPositivo(){
        assertEquals("DEFG", Cesar.cifrar("ABCD",3));
    }