Testing

Estos son los principales objetivos de las Pruebas de Software.

1. Identificación de errores: Detectar defectos en el código antes de que el software llegue a producción, evitando que sean los usuarios los que descubran los errores en el desarrollo.
2. Verificación y validación:
   • Verificación: Asegurar que el software cumple con las especificaciones que se han definido en la etapa de requisitos.
   • Validación: Confirmar que el software satisface las necesidades del usuario, produciendo los efectos deseados.
3. Mejorar la robustez del software y la experiencia de los usuarios: Reducir fallos y garantizar una mejor experiencia de usuario.
4. Minimizar riesgos: Evitar problemas en producción que puedan causar pérdidas económicas o de reputación de las aplicaciones o las marcas.
5. Garantizar la mantenibilidad: Facilitar la introducción de funcionalidades en el software sin que éstas tengan el riesgo de romper otras partes de las aplicaciones. Gracias a las pruebas por tanto será más fácil integrar futuras modificaciones y mejoras sin problemas.

Habilitar flujos de desarrollo más óptimos y consistentes

De todo lo anterior se puede deducir que los flujos de desarrollo y mantenimiento se realizarán de una manera más optimizada. Pero aún las pruebas nos habilitan para incorporar prácticas de las aplicaciones modernas como las siguientes:

• Integración y despliegue continuos: Las prácticas de CI/CD no se conciben sin realizar el adecuado testing, que nos garantice un mayor grado de confianza a la hora de hacer despliegues continuos en el software.
• Refactoring: La práctica de refactoring, una de las que más nos ayudan a mejorar la calidad del software y su diseño, resulta imposible sin tener una buena red de seguridad como la que nos ofrecen las pruebas.

En el mundo del testing hay una gran afluencia de nombres que hacen referencia a distintos tipos de testing. Esto a veces crea una nomenclatura confusa y unas fronteras difusas entre unos y otros tipos de testing.

En resumen podemos hablar de distintas clasificaciones de testing según distintos enfoques o criterios:

Según el nivel de las pruebas

• Pruebas Unitarias: Son las pruebas más atómicas. En ellas se prueban componentes individuales del código (funciones, clases, métodos).
• Pruebas de Integración: Se evalúa cómo interactúan los distintos módulos que participan en las aplicaciones.
• Pruebas de Sistema: Se prueba el software completo en un entorno lo más parecido posible al real, donde va a estar desplegado el software y tal como se vaya a usar.
• Pruebas de Aceptación: Se verifica si el software cumple con los requisitos del cliente o los del usuario final.

Según el propósito de las pruebas

• Pruebas Funcionales: Validan que el software cumple con los requisitos especificados, es decir, las funcionalidades que deben de aportar las aplicaciones.
• Pruebas No Funcionales: Evalúan aspectos como rendimiento, usabilidad, seguridad y escalabilidad.
• Pruebas de Regresión: Aseguran que los cambios o correcciones en el código no afecten funcionalidades previas.
• Pruebas de Carga y Rendimiento: Determinan cómo se comporta el sistema bajo diferentes niveles de estrés.

Según el método de ejecución

• Pruebas Manuales: Son ejecutadas por testers (personas que prueban las aplicaciones de manara manual) sin automatización.
• Pruebas Automatizadas: Se utilizan herramientas y scripts para realizar pruebas repetitivas en los momentos en los que se necesita pero de manera automática, lo que aumenta la eficiencia y reduce costos.

Las pruebas son esenciales para realizar un software más robusto y con mayor calidad. No debería haber desarrollo sin pruebas, ya que todo software que no está probado es susceptible de tener más errores o que los errores se detecten en producción, lo que puede tener consecuencias muy problemáticas dependiendo del tipo de aplicación que se está desarrollando.

Pero a la vez permiten un mayor control y automatización de las flujos de desarrollo, ya que nos ayudan a incorporar prácticas muy recomendables en numerosas áreas como el desarrollo o despliegue, encaminadas a entregar software de calidad de forma rápida y continua.

El test es un paso esencial en metodologías ágiles, en prácticas como TDD (Test-Driven Development), donde el desarrollo del código está guiado por pruebas desde el inicio. También son necesarias para la incorporación de flujos "DevOps".

En resumen, la disciplina de pruebas de software es clave para asegurar la calidad, fiabilidad y seguridad de las aplicaciones, permitiendo el desarrollo moderno del software y asegurando una detección temprana de errores, antes de su despliegue en producción.

Por aterrizar el concepto, por si queda difuso el término, se puede decir que las pruebas del software son clases (de programación orientada a objetos) que tienen métodos donde se ejecuta un código que permite verificar que el software cumple su función de manera correcta.

Por supuesto, nos referimos en el caso concreto de las pruebas que se hacen a nivel de código y que son capaces de ejecutarse de manera repetitiva y automatizada (las pruebas más frecuentes y deseables).

Las clases de prueba se suelen colocar en una carpeta del proyecto independiente de las carpetas del código que sirven para implementar las funcionalidades. La carpeta de las pruebas se suele llamar "tests", "test" o cualquier cosa parecida. En ella se situan clases que suelen ejecutarse por medio de algún framework de pruebas, como JUnit, PHPUnit, Jest, Mocha, etc. Ese framework se encarga de realizar la ejecución de todos los métodos de esas clases que hayan sido marcados como método de test.

Si las pruebas que se hacen en cada uno de los métodos de test han funcionado bien se dan por "pasadas". Si durante la ejecución se encontraron problemas o se llegaron a estados de la aplicación que no estaban previstos, entonces se dan por "falladas". Durante la ejecución de las pruebas se verifica que todas se han podido ejecutar correctamente y si falla alguna se debe solucionar el problema que el propio fallo nos indique que se está detectando.

Las pruebas se suelen estructurar en tres fases distintas. Según los autores los nombres de las fases pueden cambiar:

• Given // When // Then
• Arrange // Act // Assert

Esta manera normal de estructurar los test se resume en estos pasos:

• Configuración: Given (dado) / Arrange (preparar): Configurar el estado inicial y los datos necesarios para ejecutar el test.
• Ejercitar el sujeto de la prueba: When (cuando) / Act (actuar): Ejecutar el comportamiento que se desea probar.
• **Afirmación y comprobación de las expectativas: Then (entonces) / Assert (Verificar): Validar que los resultados obtenidos sean los esperados.

Sin embargo, a veces estas fases pueden estar un poco difusas. Dado este ejemplo de método de test:

public function testFactorialOne() {
  $factorial = new Factorial();
  $this->assertEquals(1, $factorial->calculate(1));
}

Se encuentran las tres fases, pero de manera implícita. Si lo queremos ver estructurado para identificar bien las distintas etapas tendríamos este código equivalente:

public function testFactorialOne() {
  // Arrange
  $factorial = new Factorial();
  // Act
  $factorialOfOne = $factorial->calculate(1);
  // Assert
  $this->assertEquals(1, $factorialOfOne);
}

Generalmente para escribir los test de las aplicaciones nos basamos en algún framework de testing, o incluso en una combinación de ellos, ya que hay frameworks de test generalistas y otros más específicos para determinados tipos de testing o para la creación de dobles.

Los frameworks de test nos ofrecen múltiples utilidades en ámbitos diversos:

Facilitan la ejecución de las suites de test:

• La posibilidad de ejecutar los test de una vez, mediante comandos de consola
• Configuraciones útiles para personalizar la ejecución de los test
• Organización de una salida fácil de interpretar

A la hora de escribir el código nos ofrecen:

• Una cantidad enorme de aserciones (afirmaciones) con las que comprobar diferentes salidas de los programas
• Creación de dobles de los test
• Una arquitectura definida para el desarrollo de las pruebas

Algunos frameworks populares

Existen decenas de frameworks de test, que principalmente se pueden clasificar por el lenguaje sobre el que trabajan:

• Java: JUnit para los test unitarios o Mockito para los dobles
• Javascript: Jest, Mocha, Jasmine, Cypress
• PHP: PHPUnit, Pest
• Python: pytest, unittest
• C#: xUnit, NUnit, MSTest

Estos son solo algunos, en los lenguajes también más usados. La lista sería interminable porque cada lenguaje tiene sus alternativas.