Contenido del curso
John Eduard Meneses González
Luis Martinez
Ricardo Jose Carvajal F.
Mario Alexander Vargas Celis
Bryan Castano
Jhonatan Estiven Becerra Pedrozo
Luis Martinez
Ronaldo Jiménez
Ronaldo Jiménez
🧪 SubTest en unittest: optimización de pruebas parametrizadas
✅ ¿Qué es subTest?
subTest es una funcionalidad del módulo unittest que permite ejecutar múltiples variantes de una misma prueba dentro de un solo método, sin duplicar código ni perder visibilidad sobre qué casos fallan.
🚀 Ventajas clave
unittest lo reporta individualmente sin detener los demás.🧠 Ejemplo práctico
import unittest def is_even(n): return n % 2 == 0 class TestMathUtils(unittest.TestCase): def test_is_even(self): test_cases = [ (2, True), (3, False), (0, True), (-4, True), (-1, False) ] for value, expected in test_cases: with self.subTest(value=value): self.assertEqual(is_even(value), expected)
📌 Resultado
Cada subTest se ejecuta como una unidad independiente. Si uno falla, el resto continúa, y el reporte indica exactamente qué entrada falló.
Gran aporte!
En Python, el uso de subTest dentro del módulo unittest permite parametrizar pruebas, facilitando la ejecución de múltiples casos de prueba dentro de una sola función de prueba. Esto es útil cuando quieres probar una función con diferentes entradas y verificar sus resultados sin necesidad de crear múltiples métodos de prueba. Aquí tienes una guía sobre cómo usar subTest para parametrizar pruebas.
### 1. Importar el Módulo Necesario
Primero, asegúrate de importar unittest.
import unittest
### 2. Definir tu Clase de Pruebas
Crea una clase de prueba que herede de unittest.TestCase.
class TestMiFuncion(unittest.TestCase):   def mi\_funcion(self, x):   \# Esta es la función que estás probando   return x \* 2
### 3. Usar subTest para Parametrizar las Pruebas
Dentro de tu método de prueba, utiliza un bucle para iterar sobre los casos de prueba. Usa subTest para encapsular cada caso.
class TestMiFuncion(unittest.TestCase):   def mi\_funcion(self, x):   return x \* 2   def test\_multiplicacion(self):   casos\_de\_prueba = \[   (1, 2),   (2, 4),   (3, 6),   (4, 8),   (5, 10)   ]       for entrada, resultado\_esperado in casos\_de\_prueba:   with self.subTest(entrada=entrada):   resultado = self.mi\_funcion(entrada)   self.assertEqual(resultado, resultado\_esperado)
### 4. Ejecutar las Pruebas
Finalmente, ejecuta las pruebas utilizando la línea de comando.
python -m unittest nombre\_del\_archivo.py
### Ejemplo Completo
Aquí tienes un ejemplo completo que incluye todas las partes mencionadas:
import unittest class TestMiFuncion(unittest.TestCase):   def mi\_funcion(self, x):   return x \* 2   def test\_multiplicacion(self):   casos\_de\_prueba = \[   (1, 2),   (2, 4),   (3, 6),   (4, 8),   (5, 10)   ]       for entrada, resultado\_esperado in casos\_de\_prueba:   with self.subTest(entrada=entrada):   resultado = self.mi\_funcion(entrada)   self.assertEqual(resultado, resultado\_esperado) if \_\_name\_\_ == '\_\_main\_\_':   unittest.main()
### Ventajas de Usar subTest
- **Claridad**: Cada caso de prueba se ejecuta de manera aislada, lo que facilita identificar cuál falló.
- **Mantenimiento**: Evita la duplicación de código, lo que hace que sea más fácil mantener y actualizar las pruebas.
- **Resultados Detallados**: subTest proporciona un informe claro sobre qué subprueba falló, lo que facilita la depuración.
Usar subTest es una excelente manera de mantener tus pruebas organizadas y eficientes, especialmente cuando trabajas con múltiples casos de entrada y salida.
Hola Clase, Yo creo que este codigo es mas correcto para nuestro caso contexto de test_Bank_Account que ya tenemos en ./tests/test_bankAccount.py :
def test_deposit_multiple_amounts(self): test_amounts = [ {"amount": 150, "expected": 1150}, {"amount": 1250, "expected": 2250}, {"amount": 1500, "expected": 2500} ] for case in test_amounts: with self.subTest(amount=case["amount"], expected=case["expected"]): # Reset balance to 1000 for each test self.account.balance = 1000 # Make deposit and verify success self.assertTrue(self.account.deposit(case["amount"]), f"Deposit of ${case['amount']} should succeed") # Check balance self.assertEqual(self.account.get_balance(), case["expected"], f"After depositing ${case['amount']} to $1000")
\n Este Usa setUp y Restart el balance cada iteracion.
En mis pruebas no falla el hecho de no instanciar nuevamente el BankAccount, de igual manera por qué fallaría si según lo visto con el setUp siempre se estaría regenerando este valor?
Sí, usando el del setUp debería bastar, pero si tienes dos con el mismo nombre si deberia fallar.
# test con multiples valores. @pytest.mark.parametrize("deposit_amount, expected_balance", [ (1000, 2000), (3000, 4000), (5000, 6000), ]) def test_deposit_multiple_values(setup_account, deposit_amount, expected_balance): """ Prueba el método deposit con múltiples valores usando parametrización. """ new_balance = setup_account.deposit(deposit_amount) assert new_balance == expected_balance
# test con multiples valores usando un diccionario. @pytest.mark.parametrize("data", [ {"deposit_amount": 1000, "expected_balance": 2000}, {"deposit_amount": 3000, "expected_balance": 4000}, {"deposit_amount": 5000, "expected_balance": 6000}, ]) def test_deposit_multiple_values_dict(setup_account, data): """ Prueba el método deposit con múltiples valores usando un diccionario. """ new_balance = setup_account.deposit(data["deposit_amount"]) assert new_balance == data["expected_balance"]