¿Qué es el testing?

El testing es el proceso de evaluar tu código para asegurarte de que funciona correctamente. En Python, el testing es una parte fundamental del desarrollo de software porque te ayuda a identificar y corregir errores, mejorar la calidad del código y asegurarte de que las nuevas actualizaciones no rompan el funcionamiento existente.

¿Por qué es importante el testing?

• Previene errores: Detecta errores en el código antes de que lleguen a producción.
• Mejora la calidad: Asegura que tu código funcione como se espera.
• Facilita el mantenimiento: Permite hacer cambios en el código con confianza, sabiendo que las pruebas te avisarán si algo se rompe.

Tipos de pruebas en Python

1. Pruebas unitarias: Prueban partes individuales del código, como funciones o métodos, para asegurarse de que funcionan correctamente de manera aislada.
2. Pruebas de integración: Aseguran que diferentes partes del sistema funcionan bien juntas.
3. Pruebas de aceptación: Verifican que el sistema cumple con los requisitos funcionales.

¡Vamos a aprender sobre las pruebas unitarias en Python usando el módulo unittest!

Lección 8.1: Pruebas unitarias

Las pruebas unitarias son una técnica clave en el desarrollo de software que te permite verificar que las partes individuales de tu código (como funciones o métodos) funcionan correctamente. Python incluye un módulo llamado unittest que facilita la creación y ejecución de estas pruebas.

1. Introducción a unittest

El módulo unittest es una herramienta estándar en Python para escribir y ejecutar pruebas automáticas. Te permite crear casos de prueba, agruparlos en clases, y ejecutar todos los casos de prueba de una vez. También proporciona funcionalidades para verificar que los resultados de las funciones sean los esperados.

2. Creación de pruebas unitarias

Para crear una prueba unitaria en Python, sigue estos pasos:

1. Importa el módulo unittest.
2. Crea una clase de prueba que hereda de unittest.TestCase.
3. Define métodos de prueba en esa clase. Cada método debe comenzar con test_ para que unittest los reconozca como pruebas.
4. Usa métodos de aserción (como assertEqual, assertTrue, assertFalse) para verificar los resultados.

Ejemplo: Creación de una prueba unitaria

Supongamos que tienes una función suma que suma dos números. Vamos a escribir una prueba unitaria para verificar que esta función funciona correctamente.

Archivo: mi_codigo.py

1def suma(a, b):
2    return a + b

Ahora, crearemos un archivo separado para las pruebas.

Archivo: test_mi_codigo.py

1import unittest
2from mi_codigo import suma
3
4class TestMiCodigo(unittest.TestCase):
5    
6    def test_suma_positivos(self):
7        self.assertEqual(suma(3, 5), 8)
8    
9    def test_suma_negativos(self):
10        self.assertEqual(suma(-1, -1), -2)
11    
12    def test_suma_cero(self):
13        self.assertEqual(suma(0, 0), 0)
14
15if __name__ == '__main__':
16    unittest.main()

• ¿Qué hace este código?:
  • Importa unittest y la función suma que quieres probar.
  • Define una clase TestMiCodigo que hereda de unittest.TestCase.
  • Dentro de la clase, define varios métodos de prueba (test_suma_positivos, test_suma_negativos, test_suma_cero), cada uno verificando un aspecto diferente de la función suma.
  • Usa self.assertEqual para comparar el resultado de suma(a, b) con el valor esperado.
  • unittest.main() ejecuta todas las pruebas cuando se ejecuta el archivo de prueba.

3. Ejecutar pruebas y reportes

Para ejecutar las pruebas, simplemente ejecuta el archivo test_mi_codigo.py. Puedes hacerlo desde la línea de comandos:

1python test_mi_codigo.py

Si todas las pruebas pasan, verás algo como esto:

...
----------------------------------------------------------------------
Ran 3 tests in 0.001s

OK

• Resultado en pantalla:

  ...
  ----------------------------------------------------------------------
  Ran 3 tests in 0.001s
  
  OK

Esto indica que todas las pruebas se ejecutaron correctamente y los resultados fueron los esperados.

¿Qué sucede si una prueba falla?

Si alguna prueba falla, unittest te lo mostrará, indicando qué prueba falló y por qué:

1def test_suma_falla(self):
2    self.assertEqual(suma(2, 2), 5)  # Esto debería fallar

Si ejecutas esta prueba, verás algo como:

F
======================================================================
FAIL: test_suma_falla (__main__.TestMiCodigo)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_mi_codigo.py", line 13, in test_suma_falla
    self.assertEqual(suma(2, 2), 5)
AssertionError: 4 != 5

----------------------------------------------------------------------
Ran 4 tests in 0.001s

FAILED (failures=1)

Esto indica que la prueba test_suma_falla falló porque suma(2, 2) no es igual a 5 (lo cual es correcto, ya que debería ser 4).

Resumen de los conceptos clave

• unittest: Un módulo en Python para escribir y ejecutar pruebas unitarias.
• Casos de prueba: Métodos dentro de una clase que hereda de unittest.TestCase.
• Aserciones: Métodos como assertEqual que comparan el resultado de tu código con el resultado esperado.
• unittest.main(): Ejecuta todas las pruebas cuando se corre el archivo de prueba.

Conclusión

Las pruebas unitarias son esenciales para garantizar que tu código funcione correctamente y que los cambios futuros no introduzcan errores inesperados. Con unittest, puedes escribir pruebas que validen el comportamiento de tus funciones y obtener retroalimentación inmediata sobre su corrección. ¡Practica creando tus propias pruebas para familiarizarte con esta poderosa herramienta en Python!