Las pruebas unitarias son clave para poder garantizar la calidad del cualquier código. Al escribir pruebas unitarias se automatiza el control de calidad, al mismo tiempo que se crea una documentación viva de las funcionalidades y APIs implementadas. En esta entrada es realiza una introducción a la escritura de pruebas unitarias en Python utilizando la librería unittest.
¿Por qué escribir pruebas unitarias?
Existen múltiples motivos por los que escribir pruebas unitarias mientras se crean conjuntos de funciones. Entre estos motivos se puede destacar:
- Al disponer de un conjunto de pruebas se puede garantizar que el código funciona correctamente si este supera la batería de pruebas.
- Introducir modificaciones en el código se hace más rápido y sencillo. En caso de que las prueban fallen después de la modificación indica la existencia de un nuevo fallo. Por otro lado, al pasar las pruebas se garantiza que las funcionalidades existentes siguen funcionando.
- Además, las pruebas unitarias son la única documentación que se mantendrá actualizada durante todo el ciclo de vida del software. Ya que estas se han de actualizar con las funcionalidades.
Funcionamiento básico
A modo de ejemplo se puede probar el funcionamiento de una función básica que realice la suma de dos valores. Una primera definición de esta función puede ser:
def add(x, y):
return x * yAhora, para la creación de las pruebas se ha de importar unittest. Una vez hecho esto se puede crear una clase con un método en el que se puede probar que la función realiza correctamente la operación de sumar dos números.
import unittest
class TestAdd(unittest.TestCase):
def test_add_two_integers(self):
self.assertEqual(4, add(2, 2))En este trozo de código se puede ver que la clase que se ha definido se hereda de unittest.TestCase. En estas se ha definido un método, test_add_two_integers, en el que se comprueba que la función devuelve 4, el valor esperado, cuando se los dos valores son 2. Por convenio el nombre de la clase comienza por Test. El nombre de los métodos comienza también por test además de contener la función y lo que se prueba. En una nueva celda de notebook se puede escribir la siguiente línea para ejecutar las pruebas
unittest.main(argv=['ignored', '-v'], exit=False)
Aquí se indica que se ejecuten las pruebas y no al terminar no se cierre el notebook. Al ejecutar esta celda se obtiene el siguiente resultado:
test_add_two_integers (__main__.TestAdd) ... ok ---------------------------------------------------------------------- Ran 1 test in 0.001s OK
Indicando que la función que se ha definido anteriormente supera la prueba. En este punto es una buena idea incluir más pruebas para garantizar que funciona correctamente en todos los casos. Por ejemplo, se puede comprobar la suma de 2 y -2:
class TestAdd(unittest.TestCase):
def test_add_two_integers(self):
self.assertEqual(4, add(2, 2))
self.assertEqual(0, add(2, -2))
unittest.main(argv=['ignored', '-v'], exit=False)Cuando se ejecuta la celda se tiene
test_add_two_integers (__main__.TestAdd) ... FAIL ====================================================================== FAIL: test_add_two_integers (__main__.TestAdd) ---------------------------------------------------------------------- Traceback (most recent call last): File "<ipython-input-5-f2009544d903>", line 4, in test_add_two_integers self.assertEqual(0, add(2, -2)) AssertionError: 0 != -4 ---------------------------------------------------------------------- Ran 1 test in 0.001s FAILED (failures=1)
Lo que se observa en esta ocasión es que la prueba ha fallado. El método ha devuelto -4 cuando lo que se esperaba es un valor de 0. Al revisar la función add se puede comprobar el fallo esta en haber utilizado el operador multiplicador en lugar de suma. Corrigiendo esto se puede volver a lanzar las pruebas.
def add(x, y):
return x + yConsiguiendo finalmente pasar las pruebas definidas.
test_add_two_integers (__main__.TestAdd) ... ok ---------------------------------------------------------------------- Ran 1 test in 0.001s OK
Precisión en número reales
Hasta ahora se ha trabajado con enteros, pero en una gran cantidad de ocasiones las pruebas se han de definir para trabajar con enteros. Es sabido que los valores de reales no se han de comparar directamente. La precisión finita de los ordenadores puede hacer que dos valores que deberían ser iguales no lo sea. En estas ocasiones se ha de comprobar que los números sean iguales con cierta precisión. En el siguiente ejemplo se comprueba que la suma de 1,999 y 2,002 sea igual a 4 con dos cifras de precisión.
class TestAdd(unittest.TestCase):
def test_add_two_integers(self):
self.assertEqual(4, add(2, 2))
self.assertEqual(0, add(2, -2))
def test_add_two_floats(self):
self.assertAlmostEqual(4, add(1.999, 2.002), places=2)
unittest.main(argv=['ignored', '-v'], exit=False)A pesar de que el resultado sea 4,001 las pruebas han pasado.
test_add_two_floats (__main__.TestAdd) ... ok test_add_two_integers (__main__.TestAdd) ... ok ---------------------------------------------------------------------- Ran 2 tests in 0.003s OK
Conclusiones
En esta entrada se ha realizado una introducción a la utilización de pruebas unitarias en Python con el framework unittest. Una vez se coge soltura con las pruebas unitarias se puede trabajar con metodologías de trabajo como TDD o BDD que permiten garantizar código de gran calidad.
Deja una respuesta