Testing de Aplicaciones Django con Unit Tests

Me gusta! no sabía cómo funcionaba esto del Testing en Django. Gracias, muy bien explicado!

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.

Las ultimas clases tienen el sonido super bajo.

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 ```js 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

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: ```python 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: ```bash 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: ```python 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: ```python 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: ```python 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: ```python 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: ```python 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\*\* ```python 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.