Fundamentos del Testing en Python
¿Qué son las Pruebas Unitarias y por qué es importante?
¿Qué es el Testing en Software?
Instalación y Configuración del Entorno de Pruebas
Conceptos Básicos de Unittest
Cómo Crear Pruebas Unitarias con UnitTest en Python
Cómo usar el método setup en tests de Python
Uso de tearDown para limpieza de Pruebas Unitarias en Python
Cómo validar excepciones y estructuras de datos con Unittest en Python
Control de pruebas unitarias con unittest.skip en Python
Organización y Gestión de Pruebas
Cómo organizar y ejecutar pruebas en Python con UnitTest
Mejores prácticas para organizar y nombrar pruebas en Python
Técnicas Avanzadas en Pruebas Unitarias
Mocking de APIs externas en Python con unittest
Uso de Side Effects en Mocking con Python
Uso de Patching para Modificar Comportamientos en Python
Exploración de Herramientas y Métodos Complementarios
Cómo parametrizar pruebas en Python con SubTest
Documentación de pruebas unitarias con Doctest en Python
Cómo generar datos de prueba dinámicos con Faker en Python
Mejora y Automatización de Pruebas
¿Cómo asegurar la cobertura de pruebas con Coverage en Python
Automatización de Pruebas Unitarias en Python con GitHub Actions
Pruebas Unitarias con PyTest en Python
Cómo crear pruebas unitarias con inteligencia artificial en Python
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Cómo validar excepciones y estructuras de datos con Unittest en Python
7/20Recursos
UnitTest nos proporciona una amplia gama de métodos de aserción que mejoran la forma en que validamos nuestras pruebas. En esta clase, hemos explorado algunos de ellos y cómo utilizarlos en diferentes escenarios.
¿Cómo se usa el assertEqual en Unit Test?
El método assertEqual compara dos valores para verificar si son iguales. Acepta dos parámetros para comparar y opcionalmente un mensaje personalizado que se mostrará en la terminal si la prueba falla. Este método se integra bien con los editores, permitiendo ejecutar y depurar pruebas de manera eficiente.
- Parámetros: valor esperado, valor obtenido, mensaje de error (opcional)
- Uso típico: Validar igualdad de números, cadenas, o cualquier otro objeto comparable.
¿Qué otros métodos de aserción existen en Unit Test?
Además de assertEqual, Unit Test incluye muchos otros métodos de aserción útiles:
assertTrue: Verifica que una expresión sea verdadera. No compara valores, solo evalúa si una condición es cierta.assertRaises: Valida que se lance una excepción específica dentro de un bloque de código, utilizando la palabra clavewithcomo contexto.assertInyassertNotIn: Comprueban si un elemento está o no está dentro de una secuencia, como una lista o un conjunto.
¿Cómo se manejan excepciones en Unit Test?
Con assertRaises, se puede verificar que una excepción se lance correctamente. Este método es especialmente útil para manejar errores esperados, como cuando un usuario no tiene suficientes fondos para completar una transferencia.
- Se utiliza con
withpara capturar la excepción dentro de un bloque de código. - Ejemplo: Capturar un
ValueErroral pasar un argumento no válido a una función.
¿Cómo comparar listas, diccionarios y sets en Unit Test?
Unit Test ofrece métodos para comparar estructuras de datos más complejas:
assertDictEqual: Compara dos diccionarios.assertSetEqual: Compara dos sets para validar que contengan los mismos elementos, independientemente del orden.- Estos métodos también cuentan con variantes negativas, como
assertNotEqual, para validar desigualdades.
Aportes 7
Preguntas 0
Ordenar por:
**¿Por qué validar excepciones en pruebas unitarias?**
* **Detección temprana de errores:** Identifica fallos en la lógica de tu código antes de que causen problemas en producción.
* **Código más robusto:** Hace que tu código sea más resistente a errores inesperados.
* **Documentación implícita:** Indica las condiciones de error y los tipos de errores posibles.
* **Facilita la depuración:** Aísla la causa de los errores de manera más efectiva.
* **Mejora la calidad del código:** Contribuye a un código más limpio y confiable.
El reto usando with:
```python
def division(a,b):
if b == 0:
raise ValueError("La divisón por cero no esta permitida")
else:
return a/b
#test:
def test_division_by_zero(self):
with self.assertRaises(ZeroDivisionError):
division(10, 0)
```def division(a,b): if b == 0: raise ValueError("La divisón por cero no esta permitida") else: return a/b
### Equivalencias de `pytest `con `unittest`
* `assertEqual(a, b)` → `assert a == b`
* `assertNotEqual(a, b)` → `assert a != b`
* `assertTrue(x)` → `assert x is True`
* `assertFalse(x)` → `assert x is False`
* `assertIsNone(x)` → `assert x is None`
* `assertIsNotNone(x)` → `assert x is not None`
* `assertIn(a, b)` → `assert a in b`
* `assertNotIn(a, b)` → `assert a not in b`
Ejemplo en código:
```js
import pytest
def test_addition():
result = 1 + 1
assert result == 2 # Verifica que el resultado sea 2
def test_list():
my_list = [1, 2, 3]
assert 2 in my_list # Verifica que 2 esté en la lista
assert 4 not in my_list # Verifica que 4 no esté en la lista
def test_string():
my_string = "Hello, world!"
assert "Hello" in my_string # Verifica que 'Hello' esté en la cadena
assert "hello" not in my_string # Verifica que 'hello' no esté en la cadena
def test_dict():
my_dict = {'player': 'Ronaldo'}
assert my_dict.get('player') == 'Ronaldo' # Verifica que el valor de la clave sea 'value'
def test_zero_division():
with pytest.raises(ZeroDivisionError):
1 / 0 # Verifica que la excepción ZeroDivisionError se lance
def test_float_comparison():
result = 0.1 + 0.2
assert result == pytest.approx(0.3, rel=1e-9) # Compara números flotantes con un margen de error
def test_string_error():
my_string = "Error: Something went wrong"
assert "Error" in my_string # Verifica si "Error" está en la cadena
with pytest.raises(ValueError, match="Something went wrong"):
raise ValueError("Something went wrong") # Verifica que el mensaje de la excepción coincida
```
````python
import unittest
import os
from src.bank_account import BankAccount
class BankAccountTests(unittest.TestCase):
def setUp(self) -> None:
self.account = BankAccount(balance=1000,
log_file="MainAccount.txt")
def tearDown(self) -> None:
if os.path.exists(f"{self.account.log_file}"):
os.remove(f"{self.account.log_file}")
def _count_lines(self, filename):
with open(filename, "r") as f:
return len(f.readlines())
def test_deposit(self):
new_balance = self.account.deposit(500)
self.assertEqual(new_balance, 1500, "The balance is not the expected")
def test_withdraw(self):
new_balance = self.account.withdraw(500)
self.assertEqual(new_balance, 500)
def test_get_balance(self):
self.assertEqual(self.account.get_balance(), 1000)
def test_transfer(self, account = BankAccount()):
self.account.transfer(500, account)
self.assertEqual(self.account.get_balance(), 500)
self.assertEqual(account.get_balance(), 500)
def test_transfer_not_enough_balance(self):
with self.assertRaises(ValueError):
self.account.transfer(1500, BankAccount())
def test_log_transaction(self):
new_balance = self.account.deposit(500)
self.assertTrue(os.path.exists(f"{self.account.log_file}"))
def test_count_transactions(self):
self.assertEqual(self._count_lines(self.account.log_file), 1)
self.account.deposit(500)
self.assertEqual(self._count_lines(self.account.log_file), 2)
```import unittestimport os
from src.bank\_account import BankAccount
class BankAccountTests(unittest.TestCase):
def setUp(self) -> None: self.account = BankAccount(balance=1000, log\_file="MainAccount.txt") def tearDown(self) -> None: if os.path.exists(f"{self.account.log\_file}"): os.remove(f"{self.account.log\_file}")
def \_count\_lines(self, filename): with open(filename, "r") as f: return len(f.readlines())
def test\_deposit(self): new\_balance = self.account.deposit(500) self.assertEqual(new\_balance, 1500, "The balance is not the expected")
def test\_withdraw(self): new\_balance = self.account.withdraw(500) self.assertEqual(new\_balance, 500)
def test\_get\_balance(self): self.assertEqual(self.account.get\_balance(), 1000) def test\_transfer(self, account = BankAccount()): self.account.transfer(500, account) self.assertEqual(self.account.get\_balance(), 500) self.assertEqual(account.get\_balance(), 500)
def test\_transfer\_not\_enough\_balance(self): with self.assertRaises(ValueError): self.account.transfer(1500, BankAccount())
def test\_log\_transaction(self): new\_balance = self.account.deposit(500) self.assertTrue(os.path.exists(f"{self.account.log\_file}"))
def test\_count\_transactions(self): self.assertEqual(self.\_count\_lines(self.account.log\_file), 1) self.account.deposit(500) self.assertEqual(self.\_count\_lines(self.account.log\_file), 2)
````
```js
#Así resolví el reto:
#Aquí va el código de producción:
class BankAccount:
def __init__(self, balance=0, log_file=None):
self.balance = balance
self.log_file = log_file
self._log_transaction('Cuenta creada')
def _log_transaction(self, message):
if self.log_file:
with open(self.log_file, "a") as f:
f.write(f"{message}\n")
def deposit(self, amount):
if amount > 0:
self.balance += amount
self._log_transaction(f"Deposited {amount}. New balance: {self.balance}")
return self.balance
def withdraw(self, amount):
if amount > 0:
self.balance -= amount
self._log_transaction(f"Withdrew {amount}. New balance: {self.balance}")
return self.balance
def get_balance(self):
self._log_transaction(f"Checked balance. Current balance: {self.balance}")
return self.balance
def transfer(self, amount):
account2 = BankAccount(balance=0, log_file=None)
self._log_transaction("Transfer initiated")
if self.get_balance() >= amount:
self.withdraw(amount)
account2.deposit(amount)
self._log_transaction("Transfer completed")
elif self.get_balance() < amount:
self._log_transaction("Insufficient funds")
raise ValueError("Insufficient funds")
#Aquí van las pruebas.
import unittest, os
from src.bank_account import BankAccount
class BankAccountTests(unittest.TestCase):
def setUp(self) -> None: #aqui creamos la instancia de cuenta account que se llamará en todos los métodos antes de ejecutarse con self
self.account = BankAccount(balance=1000, log_file="transaction_log.txt")
def tearDown(self) -> None:
if os.path.exists(self.account.log_file):
os.remove(self.account.log_file)
def _count_lines(self, filename):
with open(filename, "r") as f:
return len(f.readlines())
def test_deposit(self):
new_balance = self.account.deposit(500)
self.assertEqual(new_balance, 1500, "El Balance no es igual")
def test_withdraw(self):
new_balance = self.account.withdraw(500)
self.assertEqual(new_balance, 500, "El Balance no es igual")
def test_get_balance(self):
self.assertEqual(self.account.get_balance(), 1000, "El Balance no es igual")
def test_transaction_log(self):
self.account.deposit(500)
self.assertTrue(os.path.exists("transaction_log.txt"))
def test_count_transactions(self):
assert self._count_lines(self.account.log_file) == 1
self.account.deposit(500)
assert self._count_lines(self.account.log_file) == 2
def test_transfer_insufficient(self):
with self.assertRaises(ValueError):
self.account.transfer(1001)
def test_transfer(self):
self.account.transfer(1000)
self.assertEqual(self.account.get_balance(),0)
```*#Así resolví el reto:#Aquí va el código de producción:*class BankAccount: def \_\_init\_\_(self, balance=0, log\_file=None): self.balance = balance self.log\_file = log\_file self.\_log\_transaction('Cuenta creada')
def \_log\_transaction(self, message): if self.log\_file: with open(self.log\_file, "a") as f: f.write(f"{message}\n")
def deposit(self, amount): if amount > 0: self.balance += amount self.\_log\_transaction(f"Deposited {amount}. New balance: {self.balance}") return self.balance
def withdraw(self, amount): if amount > 0: self.balance -= amount self.\_log\_transaction(f"Withdrew {amount}. New balance: {self.balance}") return self.balance
def get\_balance(self): self.\_log\_transaction(f"Checked balance. Current balance: {self.balance}") return self.balance def transfer(self, amount): account2 = BankAccount(balance=0, log\_file=None) self.\_log\_transaction("Transfer initiated") if self.get\_balance() >= amount: self.withdraw(amount) account2.deposit(amount) self.\_log\_transaction("Transfer completed") elif self.get\_balance() < amount: self.\_log\_transaction("Insufficient funds") raise ValueError("Insufficient funds") *#Aquí van las pruebas.*
import unittest, osfrom src.bank\_account import BankAccountclass BankAccountTests(unittest.TestCase):
def setUp(self) -> None: *#aqui creamos la instancia de cuenta account que se llamará en todos los métodos antes de ejecutarse con self* self.account = BankAccount(balance=1000, log\_file="transaction\_log.txt")
def tearDown(self) -> None: if os.path.exists(self.account.log\_file): os.remove(self.account.log\_file)
def \_count\_lines(self, filename): with open(filename, "r") as f: return len(f.readlines())
def test\_deposit(self): new\_balance = self.account.deposit(500) self.assertEqual(new\_balance, 1500, "El Balance no es igual")
def test\_withdraw(self): new\_balance = self.account.withdraw(500) self.assertEqual(new\_balance, 500, "El Balance no es igual")
def test\_get\_balance(self): self.assertEqual(self.account.get\_balance(), 1000, "El Balance no es igual")
def test\_transaction\_log(self): self.account.deposit(500) self.assertTrue(os.path.exists("transaction\_log.txt"))
def test\_count\_transactions(self): assert self.\_count\_lines(self.account.log\_file) == 1 self.account.deposit(500) assert self.\_count\_lines(self.account.log\_file) == 2
def test\_transfer\_insufficient(self): with self.assertRaises(ValueError): self.account.transfer(1001)
def test\_transfer(self): self.account.transfer(1000) self.assertEqual(self.account.get\_balance(),0)
Creo que asi: def transfer(self, amount): account2 = BankAccount(balance=0, log\_file=None) self.\_log\_transaction("Transfer initiated") if self.get\_balance() >= amount: self.withdraw(amount) account2.deposit(amount) self.\_log\_transaction("Transfer completed") elif self.get\_balance() < amount: self.\_log\_transaction("Insufficient funds") raise ValueError("Insufficient funds") def test\_transfer(self): with self.assertRaises(ValueError): self.account.transfer(1001)
```js
def transfer(self, amount):
account2 = BankAccount(balance=0, log_file=None)
self._log_transaction("Transfer initiated")
if self.get_balance() >= amount:
self.withdraw(amount)
account2.deposit(amount)
self._log_transaction("Transfer completed")
elif self.get_balance() < amount:
self._log_transaction("Insufficient funds")
raise ValueError("Insufficient funds")
```y esta sería la prueba:
```js
def test_transfer(self):
with self.assertRaises(ValueError):
self.account.transfer(1001)
```
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?