El método setUp en unittest te permite eliminar código repetido entre pruebas unitarias al ejecutar instrucciones comunes antes de cada test. Si estás aprendiendo testing en Python con clases como TestCase, dominar setUp es clave para escribir suites limpias, mantenibles y profesionales.
Para verlo en acción, dejamos atrás la calculadora del proyecto anterior y trabajamos con una clase BankAccount que permite depositar, retirar y consultar el saldo disponible.
¿Qué hace el método setUp en unittest?
Es un método heredado de TestCase que se ejecuta automáticamente antes de cada prueba dentro de la clase. Por defecto no hace nada, pero existe para que tú lo sobrescribas con la lógica de inicialización que necesites compartir.
¿Qué es setUp en unittest? Es un método especial de la clase TestCase que Python ejecuta antes de cada test del archivo. Sirve para preparar objetos, datos o estados que varias pruebas necesitan, evitando duplicar código.
En la práctica, todo lo que coloques dentro de setUp y guardes en self estará disponible en cada método de prueba como un atributo del objeto.
¿Cómo se prueba una clase BankAccount paso a paso?
Antes de hablar de setUp, conviene escribir las pruebas tal como saldrían de forma natural y luego refactorizar. Esa es la mejor manera de entender por qué setUp existe [00:32].
¿Cómo se estructura el archivo de pruebas?
El primer paso es crear un archivo test_bank_account.py, importar unittest e importar la clase BankAccount. La convención es nombrar la clase de prueba con el mismo nombre del objeto bajo prueba seguido de la palabra Test, y heredar de TestCase para reutilizar la infraestructura que Python ya trae.
¿Cómo escribir pruebas para depósito, retiro y balance?
Con la clase lista, defines tres métodos de prueba. Cada uno instancia una cuenta con un balance inicial de 1000 y valida un comportamiento distinto:
Para correrlas con más detalle, ejecutas el comando con la bandera -v, que activa el modo verbose y muestra el nombre de cada prueba, su ubicación y si pasó OK [02:14].
python import unittest from bank_account import BankAccount
class BankAccountTest(unittest.TestCase): def test_deposit(self): account = BankAccount(balance=1000) new_balance = account.deposit(500) self.assertEqual(new_balance, 1500)
¿Cuándo conviene refactorizar con setUp?
Al revisar las tres pruebas, salta a la vista que cada una repite la misma línea: la creación de la cuenta con balance inicial. Ese patrón es la señal clara de que setUp debe entrar en escena [03:54].
¿Cuándo debo usar setUp? Úsalo cuando dos o más pruebas de la misma clase necesitan el mismo objeto inicial, datos de prueba o configuración. Si solo una prueba lo requiere, déjalo dentro de esa prueba.
¿Cómo eliminar código duplicado entre pruebas?
La solución es mover esa instanciación a setUp y guardarla en self.account. Como setUp corre antes de cada test, cada prueba recibe una cuenta nueva, aislada y consistente. Importante: no necesitas llamar a super().setUp() porque la implementación base no hace nada.
python class BankAccountTest(unittest.TestCase): def setUp(self): self.account = BankAccount(balance=1000)
def test_deposit(self): new_balance = self.account.deposit(500) self.assertEqual(new_balance, 1500) def test_withdraw(self): new_balance = self.account.withdraw(200) self.assertEqual(new_balance, 800) def test_get_balance(self): self.assertEqual(self.account.get_balance(), 1000)
Al ejecutar de nuevo en modo verbose, las tres pruebas siguen pasando, pero el archivo es más corto, más legible y más fácil de mantener.
¿Por qué usar self dentro de setUp?
Porque self es la variable del objeto de prueba. Todo lo que asignes ahí queda disponible como atributo en cualquier método de la clase. Sin self, la cuenta solo viviría dentro del setUp y no podrías usarla en test_deposit, test_withdraw ni test_get_balance.
¿Qué reto puedes resolver para practicar setUp?
Para afianzar lo aprendido, agrega un método transfer a BankAccount que mueva dinero entre dos cuentas. Asegúrate de que levante una excepción cuando el saldo sea insuficiente.
Luego escribe dos pruebas unitarias:
Usa setUp para crear las dos cuentas que ambas pruebas necesitan. ¿Cómo resolverías el caso de la excepción? Comparte tu solución en los comentarios.
class BankAccount: # Inicia con saldo en cero def __init__(self, balance=0): self.balance = balance def deposit(self, amount): self.balance += amount return self.balance def withdraw(self, amount): if amount > 0: self.balance -= amount return self.balance def get_balance(self): return self.balance def transfer(self, amount, target): if self.balance < amount: raise ValueError("No hay fondos suficientes") self.withdraw(amount) target.deposit(amount) # Tests import unittest from src.bank_account import BankAccount class BankAccountTests(unittest.TestCase): # Definir setup ,para no repetir código def setUp(self): self.account = BankAccount(balance=1000) def test_deposit(self): new_balance = self.account.deposit(500) # Nuevo balance es igual a 1500 self.assertEqual(new_balance, 1500) def test_withdraw(self): new_balance = self.account.withdraw(200) self.assertEqual(new_balance, 800) def test_get_balance(self): self.account.deposit(3000) self.account.withdraw(1000) actual_balance = self.account.get_balance() self.assertEqual(actual_balance, 3000) def test_success_transfer(self): target = BankAccount(balance=500) self.account.transfer(200, target) # Balance cuenta emisora self.assertEqual(self.account.get_balance(), 800) # Balance cuenta receptora self.assertEqual(target.get_balance(), 700) def test_insufficient_funds_transfer(self): target = BankAccount(balance=500) with self.assertRaises(ValueError) as context: self.account.transfer(2000, target) self.assertEqual(str(context.exception), "No hay fondos suficientes") ```class BankAccount: # Inicia con saldo en cero def \_\_init\_\_(*self*, *balance*=0): *self*.balance = *balance*   def deposit(*self*, *amount*): *self*.balance += *amount* return *self*.balance   def withdraw(*self*, *amount*): if *amount* > 0: *self*.balance -= *amount* return *self*.balance   def get\_balance(*self*): return *self*.balance   def transfer(*self*, *amount*, *target*): if *self*.balance < *amount*: raise ValueError("No hay fondos suficientes") *self*.withdraw(*amount*) *target*.deposit(*amount*)
*********** En los recursos de la clase existe un error ************************
Al ejecutar las pruebas, es útil utilizar el comando con la opción -b (acá debería ser -v )**** para obtener una salida más detallada y visualizar exactamente qué pruebas se están ejecutando y dónde están ubicadas en el código. Esto ayuda a depurar y tener un mejor control sobre el flujo de las pruebas.
Juan Camilo Noreña López
Para ir a la documentación o archivo donde se implementa la clase TestCase como lo hace el profesor, pueden hacerlo en VScode con Ctrl + Click en la clase TestCase o clase que deseen buscar su referencia
Luis Martinez
ProfesorBuenos tips!
Muchas veces olvido mencionarlo en el video. Gracias por el aporte.
JOSUE MARTIN CHI PERERA
Leonel Federico Valencia Estudillo
def test_transfer(self): target_account = BankAccount(balance=500) new_balance = self.account.transfer(500, target_account) assert new_balance == 500 assert target_account.balance == 1000 def test_transfer_not_enough_balance(self): target_account = BankAccount(balance=500) with self.assertRaises(ValueError): self.account.transfer(1500, target_account)
Luis Martinez
ProfesorBien, sigue motivado a hacer los retos, son buenas maneras de aprender.
Oswaldo Jair García Franco
Jarol Jiménez
class BankAccount: def __init__(self, balance=0): self.balance = balance def deposit(self, amount): if amount > 0: self.balance += amount return self.balance def withdraw(self, amount): if amount > 0: self.balance -= self.balance return self.balance def get_balance(self): return self.balance
Juan Sebastian Chavez Martinez
John Eduard Meneses González
Hernán García Urrutia
Esta es mi respuesta al reto.
En bank_account.py:
def transfer(self, amount, target_account): if amount > 0 and self.balance >= amount: self.withdraw(amount) target_account.deposit(amount) else: raise ValueError("Insufficient funds or invalid amount")
y su test sería:
def test_transfer(self): target_account = BankAccount(balance=100) assert self.account.transfer(300,target_account) == 400 def test_transfer_not_enough_funds(self): target_account = BankAccount(balance=100) self.assertRaises(ValueError, self.account.transfer,2000,target_account )
Andres David Caicedo Marquez
RETO:
- Crear nuevo método en la clase de bank account para hacer una transferencia entre cuentas.
- En el método debemos lanzar o levantar una assertion, en el momento que intente hacer una transferencia y no tenga el saldo necesario.
- Crear dos pruebas unitarias:
Rubén Téllez Gerardo
Daniel Felipe Ospina Guarnizo
mi solución:
Johan Moises Ariza Mahecha
Estas es la solución que propongo:
bank_account.py
def transfer(self, current_balance, amount_send, destination_account): if current_balance >= amount_send: destination_account.deposit(amount_send) self.withdraw(amount_send) else: return "No se puede realizar la trasnferencia saldo insuficiente" return self.get_balance() ```**tests\_bank\_account.py** ```js def test_transfer(self): current_balance = self.account.get_balance() destination_account = BankAccount(balance=2000) amount_send = 500 assert self.account.transfer(current_balance, amount_send, destination_account) == 500 def test_transfer_no_balance(self): current_balance = 0 destination_account = BankAccount(balance=2000) amount_send = 500 assert self.account.transfer(current_balance, amount_send, destination_account) == "No se puede realizar la trasnferencia saldo insuficiente"
José Fabián Beltrán Meza
Mi solución:
def transfer(self,amount: int, target): if amount > 0 and self.balance > amount: target.deposit(amount) self.balance -= amount return self.balance else: raise ValueError('You do not have enough money') # Para el tests def test_transfer(self): target = BankAccount(500) self.account.transfer(900, target) #Balance cuenta transmisora self.assertEqual(self.account.get_balance(), 100) #Balance cuenta receptora self.assertEqual(target.get_balance(), 1400) def test_insufficient_funds_transfer(self): target = BankAccount(balance=500) with self.assertRaises(ValueError) as context: self.account.transfer(2000, target) self.assertEqual(str(context.exception), "You do not have enough money")
César Ernesto Rivas Martínez
Juan Sabogal
#Archivo bank_account def send_money(self,amount): if self.balance >= amount: new_balance = self.balance - amount return new_balance if self.balance < amount: raise ValueError("Fondos insuficientes") ```   ```python #archivo test_bank_account def test_send_money(self): new_balance = self.account.send_money(1500) assert new_balance == 500
Nahuel Seoane
Paso mi intento de solución:
def transfer(self, amount, other): if amount <= self.balance: other.deposit(amount) self.withdraw(amount) else: raise ValueError("Not enough balance") return self.balance ``` y ahora los tests: ```js def test_transfer_success(self): new_account = BankAccount(balance=1000) new_balance = self.account.transfer(500, new_account) assert new_balance == 500 and new_account.balance == 1500 def test_transfer_not_enough_balance(self): new_account = BankAccount(balance=1000) with self.assertRaisesRegex(ValueError, 'Not enough balance'): self.account.transfer(1500, new_account)
Ronaldo Jiménez
Quise usar pytest para ver la diferencias y este es el resultado:
import pytest from src.bank_account import BankAccount @pytest.fixture def setup_account(): return BankAccount(balance=1000) # Balance inicial común para todas las pruebas def test_deposit(setup_account): new_balance = setup_account.deposit(250) assert new_balance == 1250 # Balance inicial (1000) + depósito (250) def test_withdraw(setup_account): setup_account.deposit(4000) # 1000 + 4000 = 5000 new_balance = setup_account.withdraw(2000) assert new_balance == 3000 # Balance esperado después de retirar def test_get_balance(setup_account): assert setup_account.get_balance() == 1000 # Verifica el balance inicial
Luis Martinez
ProfesorTe adelantaste un poco en el curso, vemos Pytest en las últimas clases.
Hola gente, les dejo mi solución:
Archivo de cuenta de banco:
class BankAccount: def __init__(self, balance=0): self.balance = balance def deposit(self, amount): if amount > 0: self.balance += amount return self.balance def withdraw(self, amount): if amount > 0: self.balance -= amount return self.balance def get_balance(self): return self.balance def transfer(self, amount, otherAccount): if amount > self.balance: raise ValueError("Insufficient funds") self.balance -= amount otherAccount.deposit(amount) return self.balance ```Archivo de pruebas: ```js import unittest from src.bank_account import BankAccount class BankAccountTests(unittest.TestCase): def setUp(self): self.account = BankAccount(balance = 1000) def test_deposit(self): new_balance = self.account.deposit(500) assert new_balance == 1500 def test_withdraw(self): new_balance = self.account.withdraw(200) assert new_balance == 800 def test_get_balance(self): assert self.account.get_balance() == 1000 def test_transfer(self): account2 = BankAccount(balance=1000) new_balance = self.account.transfer(400, account2) assert new_balance == 600 assert account2.get_balance() == 1400
import unittest from src.bank_account import BankAccount class BankAccountTests(unittest.TestCase): def test_deposit(self): # Inicializa cuenta coon saldo = 1000 account = BankAccount(balance=1000) new_balance = account.deposit(500) # Nuevo balance es igual a 1500 self.assertEqual(new_balance, 1500) def test_withdraw(self): account = BankAccount(balance=1000) new_balance = account.withdraw(200) self.assertEqual(new_balance, 800) def test_get_balance(self): account = BankAccount(balance=3000) account.deposit(3000) account.withdraw(1000) actual_balance = account.get_balance() self.assertEqual(actual_balance, 5000) ```import unittestfrom src.bank\_account import BankAccount class BankAccountTests(*unittest*.TestCase):   def test\_deposit(*self*): # Inicializa cuenta coon saldo = 1000 account = BankAccount(*balance*=1000) new\_balance = account.deposit(500) # Nuevo balance es igual a 1500 *self*.assertEqual(new\_balance, 1500)   def test\_withdraw(*self*): account = BankAccount(*balance*=1000) new\_balance = account.withdraw(200) *self*.assertEqual(new\_balance, 800)   def test\_get\_balance(*self*): account = BankAccount(*balance*=3000) account.deposit(3000) account.withdraw(1000) actual\_balance = account.get\_balance() *self*.assertEqual(actual\_balance, 5000)
Clase bank_account:
class BankAccount: def __init__(self, balance = 0): self.balance = balance def deposit(self, amount): self.balance += amount return self.balance def withdraw(self, amount): if amount > self.balance: raise ValueError("Insufficient funds") self.balance -= amount return self.balance def get_balance(self): return self.balance def transfer(self, target, amount): self.withdraw(amount) target.deposit(amount) return self.balance, target.balance
Clase test_bank_account:
import unittest from src.bank_account import BankAccount class BankAccountTest(unittest.TestCase): def setUp(self): self.account = BankAccount(1000) def test_deposit(self): res = self.account.deposit(500) assert res == 1500 def test_withdraw(self): res = self.account.withdraw(500) assert res == 500 def test_get_balance(self): res = self.account.get_balance() assert res == 1000 def test_transfer(self): target = BankAccount() res = self.account.transfer(target, 500) assert res == (500, 500) def test_transfer_insufficient_funds(self): target = BankAccount() with self.assertRaises(ValueError): self.account.transfer(target, 1500)
Respuesta:
test_deposit (test_bank_account.BankAccountTest.test_deposit) ... ok test_get_balance (test_bank_account.BankAccountTest.test_get_balance) ... ok test_transfer (test_bank_account.BankAccountTest.test_transfer) ... ok test_transfer_insufficient_funds (test_bank_account.BankAccountTest.test_transfer_insufficient_funds) ... ok test_withdraw (test_bank_account.BankAccountTest.test_withdraw) ... ok test_div (test_calculator.TestCalculator.test_div) ... ok test_sum (test_calculator.TestCalculator.test_sum) ... ok ---------------------------------------------------------------------- Ran 7 tests in 0.001s OK
Reto de la Clase!!
class BankAccount: def __init__(self, initial_balance=0): self.balance = initial_balance def deposit(self, amount): if amount > 0: self.balance += amount else: raise ValueError("Deposit amount must be positive") return self.balance def withdraw(self, amount): if amount > self.balance: raise ValueError("Insufficient funds") elif amount <= 0: raise ValueError("Withdrawal amount must be positive") else: self.balance -= amount return self.balance def get_balance(self): return self.balance def transfer(self, amount, target_account): if amount <= 0: raise ValueError("Transfer amount must be positive") if amount > self.balance: raise ValueError("Insufficient funds for transfer") self.balance -= amount target_account.deposit(amount) return self.balance
import unittest from src.bank_account import BankAccount class BankAccountTests(unittest.TestCase): def setUp(self) -> None: self.account = BankAccount(initial_balance=1000) def test_deposit(self): new_balance = self.account.deposit(500) assert new_balance == 1500 def test_withdraw(self): new_balance = self.account.withdraw(200) assert new_balance == 800 def test_withdraw_with_deposit(self): account = BankAccount() account.deposit(200) account.withdraw(50) assert account.balance == 150 def test_get_balance(self): assert self.account.get_balance() == 1000 def test_withdraw_insufficient_funds(self): account = BankAccount() account.deposit(50) with self.assertRaises(ValueError): account.withdraw(100) # ✅ Transferencia exitosa def test_transfer_successful(self): target = BankAccount(initial_balance=200) self.account.transfer(300, target) assert self.account.get_balance() == 700 assert target.get_balance() == 500 # ❌ Transferencia fallida por fondos insuficientes def test_transfer_insufficient_funds(self): target = BankAccount(initial_balance=100) with self.assertRaises(ValueError): self.account.transfer(2000, target)
Clase
class BankAccount: def __init__(self, balance=0): self.balance = balance def deposit(self, amount): if amount > 0: self.balance += amount return self.balance raise ValueError("Invalid deposit amount") def withdraw(self, amount): if 0 < amount <= self.balance: self.balance -= amount return self.balance raise ValueError("Invalid withdraw amount") def get_balance(self): return self.balance def transfer(self, account, amount): if 0 < amount <= self.balance: self.balance -= amount account.deposit(amount) return self.balance raise ValueError("Invalid transfer amount") ```Test ```python from unittest import TestCase from src.BankAccount import BankAccount class BankAccountTests(TestCase): def setUp(self): self.account = BankAccount(1000) def test_deposit(self): self.account.deposit(500) assert self.account.get_balance() == 1500 def test_withdraw(self): self.account.withdraw(500) assert self.account.get_balance() == 500 def test_withdraw_fail(self): with self.assertRaises(ValueError): self.account.withdraw(1500) def test_get_balance(self): assert self.account.get_balance() == 1000 def test_transfer(self): account2 = BankAccount(500) self.account.transfer(account2, 500) assert self.account.get_balance() == 500 assert account2.get_balance() == 1000 def test_transfer_fail(self): with self.assertRaises(ValueError): account2 = BankAccount(500) self.account.transfer(account2, 2000)
