Testing de Aplicaciones Django con Unit Tests
Contenido del curso
Luis Obando
Melvin Canté
Luis Martinez
Profesor
Miguel Angel Castillo Enriquez
Adrian Ernesto German Becerra
Luis Martinez
ProfesorLuis Martinez
Profesor
Francesc Bassas Serramia
César Ernesto Rivas Martínez
Miguel Angel Reyes Moreno
Frandy De La Cruz
Mario Alexander Vargas Celis
Las ultimas clases tienen el sonido super bajo.
Me gusta! no sabía cómo funcionaba esto del Testing en Django. Gracias, muy bien explicado!
El testing es algo muy útil en el desarrollo del software.
Te ánimo que crees más pruebas, por ejemplo una con archivos es nivel avanzado.
Te puedo ayudar por acá si lo deseas.
Quiero pensar que esta clase está mal colocada y debería ir al inicio 🤔 el titulo dice testing pero solo nos muestran cómo iniciar un proyecto en Django que para estas alturas no creo que sea necesario.
Gracias por reportarlo, lo vamos a arreglar.
Adrian, ya quedó resuelto!
No se porque pero estos últimos videos se escuchan con un volumen muy bajo.
Sería necesario corregir esto con la mayor brevedad posible.
no me parece buena practica dejar URL fijas en un test, porque si el dia de ma;ana cambia el path, te va a dar error el test, es mejor dejarlo todo amarrado con los names de las rutas
class MyOrderViewTests(TestCase): def test_no_logged_user_should_redirect_to_login(self): url = reverse('my_order') response = self.client.get(url) redirect_url = reverse('login') + f'?next={url}' self.assertEqual(response.url, redirect_url)
Está todo genial, aunque siento que la ejecución de las pruebas es algo lento
Y para ser pruebas tan sencillas...
El **unit testing** en Django es una herramienta poderosa para probar de manera automatizada las funcionalidades de tu aplicación. Django ofrece una integración directa con el módulo unittest de Python a través de su framework de pruebas. Aquí te explico cómo empezar a utilizar unit testing en Django:
### 1. **Configurar un entorno de prueba**
Django crea automáticamente un entorno de prueba al ejecutar pruebas, incluyendo la creación de una base de datos temporal, lo que asegura que las pruebas no afecten los datos reales.
### 2. **Estructura básica de una prueba en Django**
Las pruebas se suelen colocar en un archivo llamado tests.py dentro de cada aplicación de Django. El archivo básico tiene el siguiente formato:
from django.test import TestCase from .models import MiModelo class MiModeloTestCase(TestCase):   def setUp(self):   \# Esta función se ejecuta antes de cada test. Aquí puedes preparar datos de prueba.   MiModelo.objects.create(campo1="dato1", campo2="dato2")   def test\_campo1\_valor(self):   \# Prueba para verificar si el valor del campo1 es correcto.   objeto = MiModelo.objects.get(campo1="dato1")   self.assertEqual(objeto.campo1, "dato1")
### 3. **Métodos de prueba comunes**
- setUp(): Se ejecuta antes de cada prueba individual y es útil para preparar datos que serán utilizados en cada test.
- tearDown(): Se ejecuta después de cada prueba, y puedes usarlo para limpiar los datos si es necesario (aunque Django lo hace automáticamente al final de cada prueba).
- Métodos de unittest como assertEqual, assertTrue, assertFalse, etc., son usados para realizar las verificaciones.
### 4. **Ejecutar pruebas**
Para ejecutar las pruebas de tu proyecto Django, usa el comando:
python manage.py test
Esto ejecutará todas las pruebas en los archivos tests.py de todas las aplicaciones del proyecto.
### 5. **Pruebas para modelos**
Puedes probar la lógica de negocio y las relaciones de tus modelos de esta manera:
from django.test import TestCase from .models import MiModelo class MiModeloTestCase(TestCase):   def setUp(self):   \# Crea un objeto para probar   self.objeto = MiModelo.objects.create(campo1="prueba", campo2="valor")   def test\_campo1\_valor(self):   \# Verifica que el campo1 tiene el valor correcto   self.assertEqual(self.objeto.campo1, "prueba")   def test\_string\_representation(self):   \# Prueba el método \_\_str\_\_ del modelo   self.assertEqual(str(self.objeto), "prueba")
### 6. **Pruebas para vistas**
Puedes usar el cliente de pruebas que Django ofrece para probar tus vistas:
from django.test import TestCase from django.urls import reverse class MiVistaTestCase(TestCase):   def test\_vista\_principal(self):   \# Utiliza el cliente de pruebas para simular una solicitud GET   response = self.client.get(reverse('nombre\_de\_la\_vista'))   \# Verifica que la respuesta es 200 OK   self.assertEqual(response.status\_code, 200)   \# Verifica si el contenido contiene algún texto específico   self.assertContains(response, "Texto esperado")
### 7. **Pruebas para formularios**
Puedes probar la lógica de validación y envío de formularios de la siguiente manera:
from django.test import TestCase from .forms import MiFormulario class MiFormularioTestCase(TestCase):   def test\_formulario\_valido(self):   form = MiFormulario(data={'campo1': 'valor válido'})   self.assertTrue(form.is\_valid())   def test\_formulario\_invalido(self):   form = MiFormulario(data={'campo1': ''})   self.assertFalse(form.is\_valid())
### 8. **Pruebas para URLs**
Asegúrate de que las rutas de tus vistas están configuradas correctamente:
from django.test import SimpleTestCase from django.urls import reverse, resolve from .views import mi\_vista class URLTestCase(SimpleTestCase):   def test\_url\_resuelve\_a\_vista(self):   \# Verifica que la URL resuelve a la vista correcta   url = reverse('nombre\_de\_la\_vista')   self.assertEqual(resolve(url).func, mi\_vista)
### 9. **Pruebas para API (si usas Django REST Framework)**
Si trabajas con una API, también puedes hacer pruebas para verificar el comportamiento de tus endpoints:
from rest\_framework.test import APITestCase from rest\_framework import status from django.urls import reverse from .models import MiModelo class MiAPITestCase(APITestCase):   def test\_api\_lista(self):   url = reverse('mi\_api\_lista')   response = self.client.get(url)   self.assertEqual(response.status\_code, status.HTTP\_200\_OK)
### 10. **Estrategia para pruebas unitarias**
- **Cubre la lógica de negocio**: Asegúrate de probar cualquier cálculo, reglas de negocio y flujos de datos en los modelos.
- **Prueba todas las vistas críticas**: Asegúrate de que las vistas devuelvan la respuesta adecuada.
- **Prueba formularios y validaciones**: La lógica de validación en formularios debe ser robusta y a prueba de errores.
- **Prueba integraciones y APIs**: Si usas APIs, verifica que los endpoints funcionen como se espera.
### 11. **Ejemplo completo de pruebas**
from django.test import TestCase from django.urls import reverse from .models import Producto class ProductoTestCase(TestCase):   def setUp(self):   self.producto = Producto.objects.create(nombre="Café", precio=5.00)   def test\_producto\_creado(self):   producto = Producto.objects.get(nombre="Café")   self.assertEqual(producto.precio, 5.00)   def test\_vista\_producto\_lista(self):   response = self.client.get(reverse('productos'))   self.assertEqual(response.status\_code, 200)   self.assertContains(response, "Café")   def test\_formulario\_producto\_valido(self):   form\_data = {'nombre': 'Té', 'precio': 4.00}   response = self.client.post(reverse('crear\_producto'), data=form\_data)   self.assertEqual(response.status\_code, 302)   self.assertTrue(Producto.objects.filter(nombre='Té').exists())
### Resumen
- **TestCase**: Es el contenedor básico para las pruebas en Django.
- **Comandos**: Usa python manage.py test para ejecutar las pruebas.
- **Verificaciones**: Métodos como assertEqual, assertTrue, y assertContains permiten verificar el comportamiento esperado.
Este flujo de trabajo te ayudará a garantizar que tu aplicación funcione como se espera a través de pruebas automatizadas.
