¿Qué puedes hacer con import unittest en Python?

Cuando codificamos en Python o en cualquier lenguaje, uno de los procesos que debemos implementar es el de asegurarnos que el código que creamos funcione como debería antes de ser lanzado al mundo. Cuando descubrí el módulo de import unittest de Python, entendí cómo debo proteger mi código frente a errores no esperados. Este módulo es una herramienta que nos permite probar, organizar y automatizar la validación de aplicaciones. El día de hoy te quiero mostrar qué es lo que hace import unnitest en Python y cómo funciona.

¿Qué es import unittest?

Como tal, unittest es un módulo integrado en Python que nos permite realizar pruebas unitarias en nuestro código. Import unittest es la forma en la que podemos implementar nuestro código dentro de Python.

Las pruebas unitarias son pequeños fragmentos de código que han sido diseñados para comprobar que ciertas funciones y métodos individuales trabajen correctamente. Este es un módulo que toma inspiración de herramientas como JUnit de Java y actualmente es bastante usado.

Con el módulo de import unittest puedes:

• Crear y ejecutar pruebas unitarias automatizadas.
• Organizar las pruebas en grupos lógicos.
• Obtener informes detallados sobre el resultado de las pruebas.

¿Cómo funciona import unittest?

Import unittest funciona por medio de clases y métodos. Para comenzar, es necesario crear una clase que herede de TestCase, que es donde se define cada prueba como un método cuyo nombre comienza con test. Veamos un ejemplo:

import unittest

class TestStringMethods(unittest.TestCase):

    def test_upper(self):
        self.assertEqual('hello'.upper(), 'HELLO')

    def test_isupper(self):
        self.assertTrue('HELLO'.isupper())
        self.assertFalse('Hello'.isupper())

if __name__ == '__main__':
    unittest.main()

En este ejemplo, la clase TestStringMethods contiene dos pruebas: test_upper y test_isupper. Al ejecutar este código, import unittest verifica cada prueba y genera un informe detallado sobre los resultados.

¿Qué puede hacer import unittest?

Entre las muchas funcionalidades de import unittest, encontramos que este puede hacer:

• Configuración previa y limpieza: El import unittest nos permite preparar configuraciones comunes para múltiples pruebas haciendo uso de los métodos setUp y tearDown. Estos son métodos que se ejecutan antes y después de cada prueba, respectivamente. Ejemplifiquemos:

import unittest

class TestDatabase(unittest.TestCase):

    def setUp(self):
        self.db = connect_to_database()

    def tearDown(self):
        self.db.close()

• Agrupación de pruebas: Si tienes un conjunto de pruebas, lo má sóptimo es organizarlas en un test suite, así podrás ejecutarlas juntas de forma más fácil:

def suite():
    suite = unittest.TestSuite()
    suite.addTest(TestStringMethods('test_upper'))
    suite.addTest(TestStringMethods('test_isupper'))
    return suite

if __name__ == '__main__':
    runner = unittest.TextTestRunner()
    runner.run(suite())

• Pruebas condicionales y fallos esperados: import unittest nos permite omitir pruebas específicas y/o marcarlas como fallos esperados por medio del uso de decoradores como son skip y expectedFailure. Veamos:

import unittest

class TestFeatures(unittest.TestCase):

    @unittest.skip("Funcionalidad no implementada")
    def test_feature(self):
        pass

    @unittest.expectedFailure
    def test_known_issue(self):
        self.assertEqual(1, 0)

Import unittest avanzado: funciones de aserción:

Import unittest es bastante versátil y es posible personalizarlo para así adaptarlo a nuestras necesidades específicas. Una de las formas de hacerlo es creando tus propias funciones de aserción, en caso de que necesites validar condiciones repetidas en múltiples pruebas.

Si, por ejemplo, trabajas con datos en formato JSON y necesitas verificar de forma constante que contengan determinadas claves, lo que puedes hacer esimplementar algo como esto:

import unittest

class TestJSONData(unittest.TestCase):

    def assertHasKeys(self, json_data, keys):
        for key in keys:
            self.assertIn(key, json_data, f'Falta la clave {key} en el JSON')

    def test_valid_json(self):
        data = {"name": "John", "age": 30}
        self.assertHasKeys(data, ["name", "age"])

Otra característica avanzada es la capacidad de integrar unittest con herramientas de análisis de cobertura de código como coverage.py. Esto te permite identificar qué partes de tu aplicación no están siendo probadas y te ayuda a mejorar la calidad de tus pruebas.

¿Cómo puedes sacarle provecho a tus pruebas con unittest?

Sigue estos consejos si quieres tener éxito en tus pruebas:

1. Utiliza subtests para datos repetitivos: Los subtests permiten ejecutar múltiples iteraciones de una prueba sin interrumpir el flujo en caso de fallos. Esto te va a servir mucho si, por ejemplo, necesitas verificar variaciones de entrada:

import unittest

class TestNumbers(unittest.TestCase):

    def test_even_numbers(self):
        for i in range(0, 10, 2):
            with self.subTest(i=i):
                self.assertEqual(i % 2, 0)

2. Organiza tus pruebas por módulos: Si trabajas en proyectos grandes, separa tus pruebas en diferentes archivos y utiliza test discovery para ejecutarlas automáticamente.
3. Integra unittest con tu flujo de trabajo: Configura un pipeline de integración continua que ejecute las pruebas automáticamente en cada cambio de código. Herramientas como GitHub Actions, Jenkins o GitLab CI/CD son excelentes opciones para ello.

Si quieres seguir aprendiendo sobre programación y evolucionando hacia un futuro más próspero a nivel intelectual y económico, no dudes en suscribirte a nuestro bootcamp en programación inicial, donde aprenderás todo lo necesario para incursionar en el mercado laboralñ. ¡No dudes más y da el primer paso hacia tu nueva vida!