Blog
PyUnit/Unittest pruebas unitarias en Python
- Publicado por: Hebert
- Categoría: Blog

Este framework es uno de los más utilizados en Python para crear pruebas unitarias o crear las llamadas “tuberías de pruebas”, Unittest permite la posibilidad de realizar pruebas desde el propio código heredando de la clase unittest.TestCase.
Cada una de las pruebas tiene la posibilidad de retornar como resultado lo siguiente:
- OK: Es para indicarnos que la prueba se ha superado de manera exitosa.
- FAIL: Indica que la prueba no ha sido exitosa y es necesario hacer un try/except
- ERROR: Para indicar que la prueba no ha pasado éxitosamente, pero el resultado en lugar de ser una aserción es otro error.
Hagamos una prueba simple para conocer un poco de este framework, voy a crear un archivo llamado pruebas.py:
import unittest class PruebaUnitaria(unittest.TestCase): def test(self): pass if __name__ == "__main__": unittest.main()
Al ejecutar esta prueba obtendrémos por pantalla lo siguiente:
λ python pruebas.py . ---------------------------------------------------------------------- Ran 1 test in 0.000s OK
Dentro del objeto o clase PruebaUnitaria cada método sera una prueba que realizaremos, para este caso solamente tenémos una función que unicamente ejecuta un “pass” y por ende la prueba finaliza correctamente.
Mi intención acá es mostrarte los diferentes resultados, entonces vamos con el siguiente resultado y es el que se obtiene cuando nuestra prueba encuentra una excepción, para ello vamos a simular una exceción invocandola:
import unittest class PruebaUnitaria(unittest.TestCase): def test(self): raise AssertionError() if __name__ == "__main__": unittest.main()
Ahora notemos lo que obtenemos por consola:
λ python pruebas.py F ====================================================================== FAIL: test (__main__.PruebaUnitaria) ---------------------------------------------------------------------- Traceback (most recent call last): File "c:\Users\gamersnautas\Desktop\pruebas.py", line 6, in test raise AssertionError() AssertionError ---------------------------------------------------------------------- Ran 1 test in 0.001s FAILED (failures=1)
Nos devuelve un FAIL lo que nos indica que la prueba unitaria ha fallado y esto nos indica que debemos hacer una excepción para solucionar la ejecución del programa. Ahora veamos que pasa si en lugar de un error de aserción obtenemos otro tipo de error:
import unittest class PruebaUnitaria(unittest.TestCase): def test(self): raise FileNotFoundError if __name__ == "__main__": unittest.main()
Ahora al ejecutar obtendríamos por consola lo siguiente:
λ python pruebas.py E ====================================================================== ERROR: test (__main__.PruebaUnitaria) ---------------------------------------------------------------------- Traceback (most recent call last): File "c:\Users\gamersnautas\Desktop\pruebas.py", line 6, in test raise FileNotFoundError FileNotFoundError ---------------------------------------------------------------------- Ran 1 test in 0.001s FAILED (errors=1)
Ahora la ejecución de la prueba vuelve a fallar pero, en lugar de devolver una “F” devuelve una “E”, con esto ya conocemos los distintos resultados que devuelven las pruebas.
También es importante mencionar, que cada método es una prueba como mencioné antes. Pero tambien, cada método debe comenzar obligatoriamente por la palabra “test” para que el framework pueda reconocerla.
➡ ¿Quieres aprender Python Gratis y obtener un Certificado?
Mejor Curso de Python para Principiantes:
Excepciones Asertivas
Esta tabla que se muestra a continuación tiene los distintos métodos asertivos que son propios del framework y que nos sirven para realizar pruebas:
Sabiendo esto, vamos a relizar un pequeño script para que haga unas pruebas por nosotros utilizando algunos de los métodos que nos proporciona este cuadro. Voy a crear un nuevo archivo llamado pruebas_texto.py:
import unittest def numero(a): return a + 20 def alumno(nombre): return nombre class PruebasUnitarias(unittest.TestCase): def test_numero(self): self.assertEqual(numero(5), 20) def test_alumno(self): self.assertIsNotNone(alumno(None)) if __name__ == '__main__': unittest.main()
Al correr este código obtenemos por consola:
λ python pruebas_texto.py FF ====================================================================== FAIL: test_alumno (__main__.PruebasUnitarias) ---------------------------------------------------------------------- Traceback (most recent call last): File "c:\Users\gamersnautas\Desktop\pruebas.py", line 12, in test_alumno self.assertIsNotNone(alumno(None)) AssertionError: unexpectedly None ====================================================================== FAIL: test_numero (__main__.PruebasUnitarias) ---------------------------------------------------------------------- Traceback (most recent call last): File "c:\Users\gamersnautas\Desktop\pruebas.py", line 9, in test_numero self.assertEqual(numero(5), 20) AssertionError: 25 != 20 ---------------------------------------------------------------------- Ran 2 tests in 0.002s FAILED (failures=2)
Si nos fijamos bien, obtenemos una “FF” (doble F) para indicarnos que hemos obtenido 2 fallos en las pruebas. Los fallos producidos fueron en la función test_alumno y en la función test_numero.
Estos fallos se han producido porque el tipo de prueba para test_alumno es una excepción asertiva del tipo assertIsNotNone, lo que hace es verificar que lo devuelto no sea None y en este caso le hemos pasado None como argumento de la función y al verificar que retorna None entonces invoca la aserción.
Lo mismo sucede con test_numero que utiliza una excepción asertiva del tipo assertEqual, donde esta se encarga de verificar que lo retornado sea igual al segundo argumento que le pasamos por parámetro, como 25 es distinto a 20 invoca la aserción, y de hecho, si nos fijamos bien podemos notar que por consola no los notifica que 25 != 20.
Bien, estos son los principios básicos de la librería pero te invito a leer más su documentación oficial en https://docs.python.org/3/library/unittest.html.
Con este framework se puede hacer pruebas mucho más complejas, es cuestión de saber mezclarse con sus métodos y propiedades para construir una tubería de pruebas mucho más sólidas que las expuestas en este post.