¿Cómo pruebas aplicaciones de Django?

Question

Accepted Answer

Django incluye un **framework de pruebas integrado** (que extiende `unittest` de Python) con herramientas diseñadas para aplicaciones web — un cliente de pruebas para simular solicitudes, un sistema de fixtures/base de datos que crea una base de datos de pruebas aislada, y ayudantes para probar modelos, vistas y formularios.

## Por qué es importante

Las pruebas son esenciales para construir aplicaciones Django confiables y mantenibles, y el framework de pruebas integrado de Django — diseñado específicamente para aplicaciones web — lo hace accesible y efectivo, por lo que entenderlo es importante tanto para la calidad del código como como estándar profesional.

El framework proporciona herramientas específicas para web que hacen que probar aplicaciones Django sea práctico: el **cliente de pruebas** simula solicitudes HTTP a las vistas (manejando GET/POST, autenticación, sesiones) para que puedas probar el flujo completo de solicitud/respuesta — códigos de estado, contenido renderizado, redirecciones, permisos — sin un servidor ejecutándose, lo cual es crucial ya que las vistas son donde vive gran parte del comportamiento de una aplicación.

La **base de datos de pruebas automática** (creada nueva y destruida después, con cada prueba envuelta en una transacción revertida) asegura que las pruebas estén aisladas y nunca toquen datos reales, haciéndolas seguras y repetibles.

Entender cómo probar las capas clave — **modelos** (métodos personalizados, validación), **vistas** (códigos de estado, datos, autenticación/permisos, manejo de formularios a través del cliente de pruebas), **formularios/serializadores** (lógica de validación para entrada válida e inválida), y **lógica de negocio** — cubre el alcance práctico de probar una aplicación Django, y conocer herramientas como `APITestCase` para APIs de DRF, `setUpTestData`/factories para datos de prueba eficientes, y mocking de servicios externos para pruebas rápidas y deterministas refleja una práctica de pruebas madura.

Las aplicaciones Django bien probadas detectan regresiones, permiten refactorización confiada, y documentan el comportamiento esperado, mientras que el diseño del framework consciente de web (especialmente el cliente de pruebas y la base de datos de pruebas) hace que las pruebas exhaustivas sean mucho más fáciles que crear las tuyas propias.

Porque las pruebas son fundamentales para el desarrollo profesional de software y Django proporciona un excelente soporte integrado adaptado a sus características, saber cómo escribir pruebas efectivas a través de las capas de modelo/vista/formulario es un conocimiento importante y frecuentemente relevante que distingue a los desarrolladores que construyen aplicaciones robustas y mantenibles de aquellos que lanzan código frágil y sin pruebas.

## Un caso de prueba básico

```python
from django.test import TestCase

class ArticleModelTest(TestCase):
    def setUp(self):
        # runs before each test; data created here is rolled back after
        self.article = Article.objects.create(title="Test", body="...")

def test_str(self):
        self.assertEqual(str(self.article), "Test")

def test_default_published(self):
        self.assertFalse(self.article.published)
```

`TestCase` envuelve cada prueba en una **transacción de base de datos que se revierte** después, por lo que las pruebas están aisladas y no se contaminan mutuamente — y usa una **base de datos de pruebas separada** (creada/destruida automáticamente), nunca tus datos reales.

## Pruebas de vistas con el cliente de pruebas

```python
class ArticleViewTest(TestCase):
    def test_list_view(self):
        Article.objects.create(title="Hello")
        response = self.client.get("/articles/")        # simulate a GET request
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Hello")           # the title appears in the HTML

def test_create_requires_login(self):
        response = self.client.post("/articles/create/", {"title": "X"})
        self.assertEqual(response.status_code, 302)      # redirected to login

def test_authenticated_create(self):
        self.client.login(username="ann", password="pw")  # log in for the test
        response = self.client.post("/articles/create/", {"title": "New", "body": "..."})
        self.assertEqual(Article.objects.count(), 1)
```

El **cliente de pruebas** simula solicitudes HTTP a tus vistas (GET/POST, con login, sesiones, etc.) sin un servidor ejecutándose — permitiéndote probar el flujo completo de solicitud/respuesta, códigos de estado, y contenido renderizado.

## Pruebas de APIs de DRF

```python
from rest_framework.test import APITestCase

class ArticleAPITest(APITestCase):
    def test_create_article(self):
        response = self.client.post("/api/articles/", {"title": "X", "body": "..."}, format="json")
        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.data["title"], "X")
```

## Herramientas y prácticas útiles

```text
✓ setUpTestData — create shared read-only data ONCE per class (faster than setUp)
✓ Factories (factory_boy) — generate test data cleanly instead of manual creation
✓ pytest-django — many teams prefer pytest's cleaner syntax over unittest
✓ Coverage.py — measure test coverage
✓ Mock external services (APIs, email) so tests are fast and deterministic
✓ Run: python manage.py test  (or pytest)
```

## Qué probar

```text
Models → custom methods, validation, properties
Views  → status codes, correct data, permissions/auth, form handling
Forms/Serializers → validation logic (valid + invalid cases)
Business logic → the core domain rules
```