El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

Las pruebas unitarias son una parte fundamental del desarrollo de software, ya que permiten verificar que las unidades individuales de código (por ejemplo, funciones o métodos) funcionan como se espera. En Python, el módulo unittest proporciona un marco de trabajo robusto para escribir y ejecutar pruebas unitarias.

Contenido

Introducción a unittest
Creación de Pruebas Unitarias
Ejecución de Pruebas
Asserts Comunes
Organización de Pruebas
Ejercicios Prácticos

Introducción a unittest

El módulo unittest es parte de la biblioteca estándar de Python y se inspira en el marco de trabajo JUnit de Java. Proporciona una manera estructurada de escribir pruebas, agruparlas y ejecutarlas.

Para usar unittest, primero debes importarlo:

import unittest

Creación de Pruebas Unitarias

Para crear una prueba unitaria, debes seguir estos pasos:

Crear una clase que herede de unittest.TestCase.
Definir métodos dentro de esta clase que comiencen con test_.

Ejemplo Básico

import unittest

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

class TestSuma(unittest.TestCase):
    
    def test_suma_positivos(self):
        self.assertEqual(suma(1, 2), 3)
    
    def test_suma_negativos(self):
        self.assertEqual(suma(-1, -1), -2)
    
    def test_suma_positivo_negativo(self):
        self.assertEqual(suma(1, -1), 0)

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

Explicación del Código

Definición de la Función: La función suma toma dos argumentos y devuelve su suma.
Clase de Prueba: TestSuma hereda de unittest.TestCase.
Métodos de Prueba: Cada método de prueba comienza con test_ y usa self.assertEqual para verificar que la salida de la función suma es la esperada.

Ejecución de Pruebas

Para ejecutar las pruebas, simplemente ejecuta el script de Python. Si todas las pruebas pasan, verás una salida similar a esta:

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

OK

Si alguna prueba falla, unittest proporcionará un informe detallado de la falla.

Asserts Comunes

unittest proporciona varios métodos de aserción para verificar diferentes condiciones:

Método	Descripción
`assertEqual(a, b)`	Verifica que `a` es igual a `b`.
`assertNotEqual(a, b)`	Verifica que `a` no es igual a `b`.
`assertTrue(x)`	Verifica que `x` es `True`.
`assertFalse(x)`	Verifica que `x` es `False`.
`assertIs(a, b)`	Verifica que `a` es `b` (mismo objeto).
`assertIsNot(a, b)`	Verifica que `a` no es `b` (diferente objeto).
`assertIsNone(x)`	Verifica que `x` es `None`.
`assertIsNotNone(x)`	Verifica que `x` no es `None`.
`assertIn(a, b)`	Verifica que `a` está en `b`.
`assertNotIn(a, b)`	Verifica que `a` no está en `b`.
`assertIsInstance(a, b)`	Verifica que `a` es instancia de `b`.
`assertRaises(exc, fun)`	Verifica que `fun` lanza la excepción `exc`.

Organización de Pruebas

Para mantener el código limpio y organizado, es una buena práctica estructurar las pruebas en módulos y paquetes. Por ejemplo:

project/
│
├── src/
│   └── my_module.py
│
└── tests/
    ├── __init__.py
    └── test_my_module.py

En test_my_module.py, puedes importar el módulo que deseas probar y definir tus clases de prueba.

Ejercicios Prácticos

Ejercicio 1: Prueba de una Función de Multiplicación

Escribe una función multiplica(a, b) que devuelva el producto de a y b. Luego, escribe una clase de prueba para verificar su funcionamiento.

# Implementación de la función
def multiplica(a, b):
    return a * b

# Clase de prueba
class TestMultiplica(unittest.TestCase):
    
    def test_multiplica_positivos(self):
        self.assertEqual(multiplica(2, 3), 6)
    
    def test_multiplica_negativos(self):
        self.assertEqual(multiplica(-2, -3), 6)
    
    def test_multiplica_positivo_negativo(self):
        self.assertEqual(multiplica(2, -3), -6)
    
    def test_multiplica_por_cero(self):
        self.assertEqual(multiplica(2, 0), 0)

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

Ejercicio 2: Prueba de una Función de División

Escribe una función divide(a, b) que devuelva el cociente de a y b. Asegúrate de manejar la división por cero lanzando una excepción ZeroDivisionError. Luego, escribe una clase de prueba para verificar su funcionamiento.

# Implementación de la función
def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("División por cero no permitida")
    return a / b

# Clase de prueba
class TestDivide(unittest.TestCase):
    
    def test_divide_positivos(self):
        self.assertEqual(divide(6, 3), 2)
    
    def test_divide_negativos(self):
        self.assertEqual(divide(-6, -3), 2)
    
    def test_divide_positivo_negativo(self):
        self.assertEqual(divide(6, -3), -2)
    
    def test_divide_por_cero(self):
        with self.assertRaises(ZeroDivisionError):
            divide(6, 0)

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

Conclusión

En esta sección, hemos aprendido cómo usar el módulo unittest para escribir y ejecutar pruebas unitarias en Python. Hemos cubierto los conceptos básicos, desde la creación de pruebas hasta su ejecución y organización. Además, hemos practicado con ejercicios que refuerzan estos conceptos. En el siguiente tema, exploraremos técnicas avanzadas de depuración para mejorar aún más la calidad de nuestro código.

Pruebas Unitarias con unittest

Contenido

Introducción a unittest

Creación de Pruebas Unitarias

Ejemplo Básico

Explicación del Código

Ejecución de Pruebas

Asserts Comunes

Organización de Pruebas

Ejercicios Prácticos

Ejercicio 1: Prueba de una Función de Multiplicación

Ejercicio 2: Prueba de una Función de División

Conclusión

Curso de Programación en Python

Módulo 1: Introducción a Python

Módulo 2: Estructuras de Control

Módulo 3: Funciones y Módulos

Módulo 4: Estructuras de Datos

Módulo 5: Programación Orientada a Objetos

Módulo 6: Manejo de Archivos

Módulo 7: Manejo de Errores y Excepciones

Módulo 8: Temas Avanzados

Módulo 9: Pruebas y Depuración

Módulo 10: Desarrollo Web con Python

Módulo 11: Ciencia de Datos con Python

Módulo 12: Proyecto Final