Fundamentos del Testing en Python
Pruebas Unitarias, de Integración y Funcionales en Python
Pruebas Automatizadas y Unitarias con Python: Ahorra Tiempo y Evita Errores
Estructura de Proyectos de Testing con Unit Test en Python
Conceptos Básicos de Unittest
Pruebas Unitarias con Python: Métodos Setup y Teardown
Pruebas Unitarias con Método Setup en Python
Pruebas de Registro de Transacciones en Cuentas Bancarias
Métodos de Assert en UnitTest para Pruebas Efectivas
Decoradores de Unit Test para Saltar Pruebas y Detectar Fallos
Organización y Gestión de Pruebas
Organización y Ejecución de Pruebas con Python Unit Test
Formato de Nombres para Pruebas Unitarias en Python
Técnicas Avanzadas en Pruebas Unitarias
Pruebas de APIs en Python con Mocking y UnitTest
Simulación de Side Effects con Mock en Pruebas Unitarias
Simulación de Horarios para Pruebas Unitarias en Python
Exploración de Herramientas y Métodos Complementarios
Parametrización de pruebas con SubTest en UnitTest
Pruebas de Código con Doctest en Python
Generación de Datos de Prueba con la Librería Faker
Mejora y Automatización de Pruebas
Cobertura de Código en Python con Coverage: Instalación y Uso
Integración Continua con GitHub Actions para Pruebas Automatizadas
Pruebas Parametrizadas con PyTest: Instalación y Ejecución
Uso de IA para Generar Pruebas Unitarias en Proyectos Software
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Estructura de Proyectos de Testing con Unit Test en Python
3/20Recursos
La creación de funciones y pruebas para el código que se va a producción es clave para validar resultados correctamente. En Python, el uso de Unit Testing simplifica este proceso, permitiendo automatizar pruebas y hacerlas más legibles y eficientes, además de integrarse fácilmente con sistemas de Continuous Integration.
¿Cómo mejorar la legibilidad de las pruebas con Unit Testing?
Python incluye Unit Testing de forma nativa, proporcionando clases reutilizables para ejecutar pruebas de manera automática o manual. Esta herramienta no solo permite mejorar la legibilidad, sino también identificar y solucionar errores rápidamente, sin necesidad de depender de print para verificar si las pruebas se están ejecutando.
¿Cómo estructurar un proyecto de testing en Python?
- Separación de código y pruebas: Coloca el código fuente en una carpeta
srcy las pruebas en una carpetatest. - Entorno virtual: Crea un entorno virtual para aislar dependencias del proyecto. Esto se hace con
python -m venv, lo que genera una carpeta con binarios y librerías solo para el proyecto. - Uso de gitignore: Añade un archivo
.gitignorepara evitar que el entorno virtual y otros archivos no deseados se suban al repositorio.
¿Cómo escribir y ejecutar pruebas con Unit Test?
Para escribir pruebas, sigue estas buenas prácticas:
- Crea un archivo de pruebas, como
test_calculator.py, y empieza importando Unit Test. - Define clases que hereden de
unittest.TestCase. - Escribe métodos de prueba que validen funciones específicas usando
assertEqualpara verificar resultados.
Ejemplo básico de prueba:
import unittest
from src.calculator import add, subtract
class TestCalculator(unittest.TestCase):
def test_add(self):
self.assertEqual(add(2, 3), 5)
def test_subtract(self):
self.assertEqual(subtract(10, 5), 5)
Ejecuta las pruebas con python -m unittest discover para que Unit Testing encuentre y ejecute las pruebas automáticamente.
¿Qué hacer cuando una prueba falla?
Si una prueba falla, Unittest lo indica con una “F”, mostrando el error detallado, lo que facilita la depuración. Puedes forzar un fallo, por ejemplo, esperando que la suma de 2 + 3 sea 6 en lugar de 5, para ver cómo se comporta.
Aportes 24
Preguntas 0
Ordenar por:
Para activar el entorno virtual en Visual Studio Code, lo más eficiente es usar la herramienta de detección automática de entornos virtuales.
* Primero, crea el entorno virtual ejecutando python -m venv nombre\_del\_entorno
* Luego, en Visual Studio Code, usa la combinación de teclas Shift + Cmd + P en macOS (o Shift + Ctrl + P en otros sistemas operativos) para abrir el Command Palette.
* En el Command Palette, escribe y selecciona "Python: Select Interpreter".
* Escoge el intérprete que dice algo como Python \[versión] (venv), que será el correspondiente a tu entorno virtual. Verás que está marcado como "recomendado".
Después de esto, cada vez que entres en la carpeta del proyecto, Visual Studio Code detectará y activará automáticamente el entorno virtual.
Estoy siguiendo el curso junto con la documentación de `unittest`: <https://docs.python.org/3/library/unittest.html>
Hola, les comparto el código de la clase, incluyendo las pruebas unitarias par multiplicacion, divicion y division por cero.
```python
import unittest
from src.calculator import addition, subtraction, multiplication, division
"""
Esta clase nos va a dar una serie de funcionalidades que nos van a permitir ver el progreso de
las pruebas, qué prueba se ejecutó, qué prueba falló, por qué falló
"""
class CalculatorTest(unittest.TestCase):
def test_addition(self):
assert addition(2, 3) == 5
def test_subtraction(self):
assert subtraction(10, 5) == 5
def test_multiplication(self):
assert multiplication(2, 4) == 8
def test_division(self):
assert division(30, 2) == 15
def test_division_by_zero(self):
with self.assertRaises(ZeroDivisionError):
division(30, 0)
```
Por si alguien llega al tener el mismo problema que yo en windows.
Les explico luego del comando para crear el entorno que es
python3 -m venv nombre\_del\_entorno
para activarlo es
.\nombre\_del\_entorno\Scripts\Activate
Acá puede darles el error UnauthorizedAccess esto sucede si la terminal por defecto que usan en VSC es PowerShell. En este caso solo escriban el comando
cmd
Y los cambia a una terminal con el entorno ya activa y si no solo escriban de nuevo el comando ya activado
debería ser algo así
(venv) C:\ruta\de\tu\proyecto>
Que tal?, les comparto el código que avance:
El siguiente es del archivo calculator.py:
```js
def sum(a, b):
return a + b
def subtract(a, b):
return a - b
def multiplication(a, b):
return a * b
def division(a, b):
if b == 0:
return "NA"
return a / b
```Y este del tests.py:
```js
import unittest
from src.calculator import sum, subtract, division, multiplication
#functionalities for viewing the tests' progress
class CalculatorTests(unittest.TestCase):
def test_sum(self):
assert sum(7, 3) == 10
def test_subtract(self):
assert subtract(11, 5) == 6
def test_multiplication(self):
assert multiplication(50, 0) == 0
def test_division(self):
assert division(22, 11) == 2
def test_division_zero(self):
assert division(22, 0) == "NA"
```
Hola, ¿Dónde puedo encontrar el link de como instalar python? (En el video indica que está en la sección de recursos, pero sólo veo código: .gitignore, src y tests
Mi solución al reto:
* Módulo de 'calculator.py':
* Módulo de 'test\_calculator.py':
```python
from src.calculator import sum, subtract, multiply, divide
class CalculatorTests(TestCase):
def test_sum(self):
assert sum(1, 2) == 3
def test_subtract(self):
assert subtract(2, 1) == 1
def test_multiply(self):
assert multiply(2, 3) == 6
def test_divide(self):
assert divide(6, 2) == 3
def test_divide_by_zero(self):
with self.assertRaises(ZeroDivisionError):
divide(6, 0)
``````python
from unittest import TestCase
from src.calculator import sum, subtract, multiply, divide
class CalculatorTests(TestCase):
def test_sum(self):
assert sum(1, 2) == 3
def test_subtract(self):
assert subtract(2, 1) == 1
def test_multiply(self):
assert multiply(2, 3) == 6
def test_divide(self):
assert divide(6, 2) == 3
def test_divide_by_zero(self):
with self.assertRaises(ZeroDivisionError):
divide(6, 0)
```
Para activar el entorno virtual en windows usa **venv\Scripts\activate**, venv es el nombre de la carpeta que se puso al entorno virtual.
La diferencia radica en la configuración de Visual Studio Code (VSCode) y la terminal de tu sistema. VSCode puede ejecutarse en un entorno de terminal integrado que permite comandos de shell, incluyendo la creación de entornos virtuales. Si el profesor lo hizo desde VSCode, es probable que haya configurado adecuadamente esta terminal. Si tú no pudiste, es posible que necesites abrir el terminal de VSCode o verificar que esté configurado para usar el terminal correcto. Asegúrate de tener Python instalado y de que el entorno esté activado correctamente.
Aqui va mi codigo :)
```python
def sum(a, b):
return a + b
def subtract(a, b):
return a - b
def multiplication(a, b):
return a * b
def division(a, b):
if b == 0:
return "No se puede dividir por 0"
return a / b
```Pruebas:
```js
import unittest
from src.calculator import sum, subtract, multiplication, division
class CalculatorTest(unittest.TestCase):
def test_sum(self):
assert sum(2, 3) == 5
def test_substract(self):
assert subtract(10, 5) == 5
def test_multiplication(self):
assert multiplication(5, 2) == 10
def test_division(self):
assert division(6, 3) == 2
assert division(15, 0) == "No se puede dividir por 0"
```
calculator.py
```js
def sum(a, b):
return a + b
def subtract(a, b):
return a - b
def multiplyBy(a,b):
return a*b
def dividedBy(a:float,b:float)->float:
try:
return a/b
except ZeroDivisionError as e:
print(e)
except TypeError as e:
print(e)
============================
test_calculator.py
import unittest
'''
Run test: python -m unittest discover -s tests
'''
from src.calculator import sum, subtract, multiplyBy, dividedBy
class CalculatorTests(unittest.TestCase):
def test_sum(self):
assert sum(2, 3) == 5
def test_subtract(self):
assert subtract(10, 5) == 5
def test_multiplay(self):
assert multiplyBy(7,5) == 35
def test_divideBy_zero(self):
assert dividedBy(10,0) == None
def test_divisionBy_ints(self):
assert dividedBy(10, 4) == 2.5
def test_divisionBy_floats(self):
assert dividedBy(10.0, 5.0) == 2.0
```def sum(a, b): return a + b
def subtract(a, b): return a - b
def multiplyBy(a,b): return a\*b
def dividedBy(a:float,b:float)->float: try: return a/b except ZeroDivisionError as e: print(e) except TypeError as e: print(e)
```js
import unittest
from src.calculator import sum, subtract, multyply, divide
class CalculatorTests(unittest.TestCase):
def test_sum(self):
# assert sum(2, 3) == 5
self.assertEqual(sum(2, 3), 5)
def test_subtract(self):
# assert subtract(10, 5) == 5
self.assertEqual(subtract(10, 5), 5)
def test_multyply(self):
self.assertEqual(multyply(2, 3), 6)
def test_divide(self):
self.assertEqual(divide(10, 2), 5)
def test_divide_by_zero(self):
with self.assertRaises(ZeroDivisionError):
divide(10, 0)
```import unittest
from src.calculator import sum, subtract, multyply, divide
class CalculatorTests(unittest.TestCase):
def test\_sum(self): # assert sum(2, 3) == 5 self.assertEqual(sum(2, 3), 5)
def test\_subtract(self): # assert subtract(10, 5) == 5 self.assertEqual(subtract(10, 5), 5)
def test\_multyply(self): self.assertEqual(multyply(2, 3), 6)
def test\_divide(self): self.assertEqual(divide(10, 2), 5)
def test\_divide\_by\_zero(self): with self.assertRaises(ZeroDivisionError): divide(10, 0)
```python
# calculator.py
def sum(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b # Multiplicación
def divide(a, b):
if b == 0:
raise ValueError("No se puede dividir por cero") # Excepción para división por 0
return a / b # Devolvemos la división si no hay error
```# calculator.py
def sum(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a \* b # Multiplicación
def divide(a, b):
if b == 0:
raise ValueError("No se puede dividir por cero") # Excepción para división por 0
return a / b # Devolvemos la división si no hay error
Mi aporte a la clase agregando las pruebas unitarias de division y multiplicacion y zero division error
```js
import unittest
from src.calculator import sum, substract, multi, division
class CalculatorTests(unittest.TestCase):
def test_sum(self):
assert sum(2, 3) == 5
def test_substract(self):
assert substract(10 , 5) == 5
def test_multi(self):
assert multi(10 , 5) == 50
def test_division(self):
assert division(5 , 5) == 1
assert ZeroDivisionError
```
Un detalle bastante importante caballeros, los .py para hacer pruebas con unitest deben comenzar con "test" para que se los reconozca el comando de python -m unittest discover -s /dir
Para configurar un entorno de \*\*pruebas unitarias\*\* (unit testing) en Django, debes asegurarte de que las herramientas necesarias estén instaladas y configuradas adecuadamente. A continuación te indico los pasos detallados para instalar y configurar un entorno de \*\*pruebas unitarias\*\* en \*\*Django\*\*.
\### 1. \*\*Instalar Dependencias Necesarias\*\*
Django viene con un framework de pruebas unitarias basado en `unittest` incorporado, por lo que no necesitas instalar ninguna herramienta extra para hacer pruebas unitarias básicas. Sin embargo, a continuación hay herramientas adicionales recomendadas:
\#### a. \*\*pytest-django\*\* (opcional)
Si prefieres usar \*\*pytest\*\* en lugar del framework de pruebas de Django, puedes instalar \*\*pytest-django\*\*, que ofrece una forma más flexible y poderosa de escribir y ejecutar pruebas.
```bash
pip install pytest pytest-django
```
\#### b. \*\*Factory Boy\*\* (opcional)
\*\*Factory Boy\*\* te permite crear objetos de prueba fácilmente. Es útil cuando necesitas muchos datos de prueba en tus tests.
```bash
pip install factory-boy
```
\#### c. \*\*Coverage\*\* (opcional)
Para medir la cobertura de tus pruebas y asegurarte de que gran parte de tu código esté siendo probado.
```bash
pip install coverage
```
\### 2. \*\*Configurar `pytest` (si se usa)\*\*
Si decides usar `pytest`, debes crear un archivo `pytest.ini` en la raíz de tu proyecto para configurarlo correctamente:
```ini
\# pytest.ini
\[pytest]
DJANGO\_SETTINGS\_MODULE = myproject.settings # Reemplaza con el nombre de tu proyecto
python\_files = tests.py test\_\*.py \*\_tests.py
```
\### 3. \*\*Configurar la Base de Datos de Pruebas\*\*
Django crea automáticamente una base de datos de pruebas temporal para ejecutar las pruebas. En el archivo `settings.py`, asegúrate de que la base de datos para las pruebas esté configurada de esta manera:
```python
\# settings.py
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3', # SQLite es más rápida para las pruebas
'NAME': ':memory:', # Base de datos en memoria para pruebas unitarias
}
}
```
Esto asegura que las pruebas unitarias se ejecuten en una base de datos SQLite en memoria, lo que es mucho más rápido.
\### 4. \*\*Escribir Pruebas Unitarias en Django\*\*
Las pruebas unitarias en Django se escriben extendiendo la clase `django.test.TestCase`. Aquí tienes un ejemplo básico:
```python
\# tests.py
from django.test import TestCase
from .models import MyModel
class MyModelTestCase(TestCase):
def setUp(self):
\# Crear datos de prueba que estarán disponibles en cada prueba
MyModel.objects.create(name="Test Object", value=100)
def test\_object\_value(self):
obj = MyModel.objects.get(name="Test Object")
self.assertEqual(obj.value, 100) # Asegura que el valor sea correcto
```
El método `setUp()` se ejecuta antes de cada prueba, lo que te permite preparar datos o configuraciones previas.
\### 5. \*\*Ejecutar Pruebas Unitarias\*\*
Si estás usando el framework de pruebas incorporado en Django, puedes ejecutar las pruebas unitarias usando el siguiente comando:
```bash
python manage.py test
```
Si prefieres usar `pytest`:
```bash
pytest
```
\### 6. \*\*Ver la Cobertura del Código (opcional)\*\*
Para ver qué partes de tu código están cubiertas por las pruebas, puedes utilizar \*\*Coverage\*\*. Para ejecutar tus pruebas con cobertura, utiliza los siguientes comandos:
```bash
coverage run --source='.' manage.py test
coverage report -m
```
Esto te dará un informe detallado de la cobertura de tus pruebas.
\### 7. \*\*Pruebas Unitarias en Django con `APIClient` (opcional)\*\*
Si estás utilizando Django REST Framework, puedes usar el cliente de prueba `APIClient` para probar tus vistas de API. Aquí un ejemplo:
```python
from rest\_framework.test import APITestCase
class MyAPITestCase(APITestCase):
def setUp(self):
\# Crear datos de prueba para la API
self.client = APIClient()
def test\_get\_request(self):
response = self.client.get('/api/my-endpoint/')
self.assertEqual(response.status\_code, 200) # Asegura que el código de estado sea 200
```
\### 8. \*\*Organización de las Pruebas\*\*
Es recomendable organizar las pruebas unitarias en un archivo `tests.py` o dentro de una carpeta `tests` en cada aplicación de Django. Por ejemplo:
```
myapp/
models.py
views.py
tests/
test\_models.py
test\_views.py
test\_serializers.py
```
\### 9. \*\*Uso de Factories para Datos de Prueba (opcional)\*\*
Con \*\*Factory Boy\*\*, puedes simplificar la creación de objetos de prueba en lugar de hacerlo manualmente:
```python
import factory
from .models import MyModel
class MyModelFactory(factory.django.DjangoModelFactory):
class Meta:
model = MyModel
name = "Test Object"
value = 100
```
Puedes usar esta fábrica en tus pruebas:
```python
class MyModelTestCase(TestCase):
def setUp(self):
self.obj = MyModelFactory()
def test\_object\_value(self):
self.assertEqual(self.obj.value, 100)
```
\### 10. \*\*Integración Continua (opcional)\*\*
Para mejorar la calidad de tu código, puedes integrar tus pruebas con herramientas de CI/CD como \*\*GitHub Actions\*\*, \*\*Travis CI\*\* o \*\*CircleCI\*\*, para que las pruebas se ejecuten automáticamente cada vez que haces cambios en el código.
\---
Con estos pasos, tendrás un entorno completo para realizar \*\*pruebas unitarias\*\* en Django, asegurando la calidad y estabilidad de tu código.
**calculator.py**
```js
def sum(a, b):
return a + b
def subtract(a, b):
return a - b
def multiplication(a, b):
return a * b
def division(a, b):
if b == 0:
raise ZeroDivisionError("No se permite la división por cero")
return a / b
```
**test\_calculator.py**
```js
import unittest
from src.calculator import sum, subtract, multiplication, division
class CalculatorTests(unittest.TestCase):
def test_sum(self):
assert sum(2, 3) == 5
def test_subtract(self):
assert subtract(10, 5) == 5
def test_multiplication(self):
assert multiplication(10, 5) == 50
def test_division(self):
assert division(10, 5) == 2
def test_div_by_zero(self):
with self.assertRaises(ZeroDivisionError):
division(3, 0)
```
Ventajas clave de utilizar un entorno virtual para desarrollar en Python:
* **Aislamiento de proyectos:** Cada proyecto tiene su propio conjunto de herramientas (paquetes). Esto evita conflictos entre diferentes versiones de un mismo paquete, que podrían causar errores en tu código.
* **Gestión de dependencias:** Puedes instalar y actualizar paquetes específicos para cada proyecto sin afectar a otros.
* **Reproducibilidad:** Puedes crear un archivo requirements.txt que liste todos los paquetes necesarios para un proyecto. Así, cualquier persona puede recrear exactamente el mismo entorno en otra computadora.
* **Organización:** Mantener tus proyectos separados facilita la gestión y evita confusiones.
* **Colaboración:** Si trabajas en equipo, cada miembro puede tener su propio entorno virtual, lo que facilita la colaboración y evita problemas de compatibilidad.
EL reto:
```js
import unittest
from src.calculator import add, substract, multiply, division
class CalculatorTest(unittest.TestCase):
def test_add(self):
assert add(2, 3) == 5
def test_substract(self):
assert substract(10, 5) == 5
def test_multiply(self):
assert multiply(5, 2) == 10
def test_division(self):
assert division(10, 2) == 5
def test_division_by_zero(self):
with self.assertRaises(ZeroDivisionError):
division(10, 0)
```import unittestfrom src.calculator import add, substract, multiply, division
class CalculatorTest(unittest.TestCase):
def test\_add(self): assert add(2, 3) == 5
def test\_substract(self): assert substract(10, 5) == 5
def test\_multiply(self): assert multiply(5, 2) == 10
def test\_division(self): assert division(10, 2) == 5
def test\_division\_by\_zero(self): with self.assertRaises(ZeroDivisionError): division(10, 0)
Código de la calculadora:
```python
def suma(a, b):
return a + b
def substract(a, b):
return a - b
def mult(a, b):
return a * b
def divi(a, b):
if b == 0:
raise ZeroDivisionError("Division by zero is not allowed")
return a / b
```
Para activar el entorno virtual en windows pueden usar el siguiente comando:
.\\\<nombre\_entorno>\Scripts\activate
Para Windows se puede usar el comando virtualenv venv
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?