Por Qué Implementé Tests Automáticos en Mi Portafolio (Django + React)
Este artículo explica la implementación de tests automáticos en un portafolio personal desarrollado con Django y React. Se detalla cómo se utilizan herramientas como `django.test`, `rest_framework.test`, Jest y `@testing-library/react` para asegurar la calidad del código tanto en el backend como en el frontend. Se describe la arquitectura de testing, integrada en el pipeline de GitHub Actions, garantizando que ningún código llegue a producción sin pasar las pruebas. El lector aprenderá sobre las estrategias de testing para modelos, APIs y componentes, así como el mockeo de servicios externos.

Herramientas de Testing
Backend
| Librería | Rol |
|---|---|
django.test.TestCase |
Clase base para tests unitarios con BD en memoria |
rest_framework.test.APIClient |
Cliente HTTP para testear endpoints DRF |
unittest.mock.patch |
Mockeo de servicios externos (Vertex AI, email) |
django.test.override_settings |
Sobreescribir configuración por test |
Frontend
| Librería | Rol |
|---|---|
| Jest | Runner de tests, assertions, mocks |
@testing-library/react |
Renderizado y queries sobre el DOM (render, screen) |
@testing-library/jest-dom |
Matchers adicionales (toBeInTheDocument, toHaveAttribute) |
@testing-library/user-event |
Simulación de interacciones de usuario |
Arquitectura de Testing
Push a main
↓
GitHub Actions: deploy.yml
↓
┌─────────────────────────────┐
│ 1. Backend Tests (Django) │
│ python manage.py test │
│ 65 tests · ~28s │
├─────────────────────────────┤
│ 2. Frontend Tests (Jest) │
│ npx react-scripts test │
│ 24 tests · ~8s │
├─────────────────────────────┤
│ 3. Build Docker images │
│ 4. Push a Artifact Registry │
│ 5. Deploy a Cloud Run │
└─────────────────────────────┘
↑ Si algún test falla,
el deploy se DETIENE
La idea central es simple: ningún código llega a producción sin pasar todos los tests. El workflow es secuencial: si los tests del backend fallan, no se construyen las imágenes Docker. Si los tests del frontend fallan, tampoco. Solo si todo pasa se despliega.
Qué Cubren los Tests
Backend: 65 Tests en 5 Apps
Blog (blog/tests/)
- Modelos (
test_models.py): auto-generación de slugs, resolución de colisiones, renderizado decontent_htmldesde Markdown, cálculo dereading_time,cover_urlcuando no hay imagen. - QuerySets:
published(),public(),internal()— filtrado correcto de posts segúnis_publishedeis_internal. - API (
test_api.py): CRUD completo con permisos diferenciados (anónimos vs empleados), filtrado por tags, búsqueda por título, paginación, preview de Markdown, serialización completa de campos.
```python blog_backend/blog/tests/test_api.py def test_list_posts_returns_only_public(self): """Listado anónimo solo devuelve posts públicos.""" response = self.client.get('/api/blog/posts/') slugs = [p['slug'] for p in response.data['results']] self.assertIn('public-post', slugs) self.assertNotIn('internal-post', slugs) self.assertNotIn('draft-post', slugs)
#### Users (`users/tests/`)
- **Modelo**: `CustomUser` con email como `USERNAME_FIELD`, auto-promoción del email del autor a `is_employee`, `create_superuser` con validaciones.
- **Auth API**: Login JWT (éxito + credenciales inválidas), registro (validación de email duplicado y password corto), refresh de tokens, perfil autenticado vs anónimo.
```python
def test_auto_promote_hector_email(self):
"""El email del autor se auto-promueve a employee."""
user = User.objects.create_user(
email='hectorgarridohenriquez@gmail.com', password='pass',
)
self.assertTrue(user.is_employee)
Contact (contact/tests/)
- Modelo: creación de mensajes,
__str__con/sin subject, ordenamiento descendente por fecha. - API: envío público de mensajes, validación de campos faltantes y email inválido, permisos de listado (admin only), envío de notificación por email, comportamiento cuando
CONTACT_NOTIFICATION_EMAILno está configurado.
@override_settings(
EMAIL_BACKEND='django.core.mail.backends.locmem.EmailBackend',
CONTACT_NOTIFICATION_EMAIL='owner@hectorgarrido.cl',
)
def test_email_notification_sent(self):
"""Al crear un mensaje se envía una notificación por email."""
from django.core import mail
self.client.post('/api/contact/messages/', self.valid_payload)
self.assertEqual(len(mail.outbox), 1)
Search/RAG (search/tests/)
- PostEmbedding: serialización/deserialización de embeddings numpy con pickle, manejo de embeddings vacíos.
- Keyword Search: búsqueda por título, contenido, queries vacías, queries sin resultados.
- RAG: mock de Vertex AI para testear el endpoint sin dependencias externas, caché de queries (unicidad por hash).
@patch('search.views.SearchEngine.generate_answer')
def test_rag_with_query(self, mock_generate):
"""El endpoint llama al motor RAG y devuelve la respuesta."""
mock_generate.return_value = {
'answer': 'El autor trabaja con series de tiempo.',
'sources': [{'title': 'Post 1', 'slug': 'post-1'}],
'cached': False,
}
response = self.client.get('/api/search/rag/', {'q': '¿Qué hace el autor?'})
self.assertEqual(response.data['answer'], 'El autor trabaja con series de tiempo.')
Tasks (tasks/tests/)
- Modelos (
test_models.py): creación de tareas con estado, prioridad y tags ad-hoc, relación M2M conTaskTag. - API (
test_api.py): CRUD protegido (solo empleados autenticados), filtrado por estado y prioridad, creación de tags al vuelo.
Frontend: 24 Tests en 9 Archivos
| Archivo | Qué cubre |
|---|---|
seoConfig.test.js |
Constantes SEO, buildCanonical() con distintos paths |
theme.test.js |
Modo light/dark, colores, tipografía, fondos |
PostCard.test.js |
Título, excerpt, tags, links, fecha, imagen |
App.test.js |
Renderizado base, ruta Home |
api/client.test.js |
Axios client, interceptor JWT, refresh de token |
generateSeo.test.js |
Generación de meta tags y JSON-LD por tipo de página |
pages/Home.test.js |
Carga de posts, estado de carga, manejo de errores |
pages/InternalPosts.test.js |
Visibilidad de posts internos según rol de usuario |
pages/TaskManager.test.js |
CRUD de tareas, filtros, creación de tags |
Errores que Encontré al Escribir los Tests
Escribir tests no es solo verificar que el código funciona — es descubrir que algunas cosas no funcionan como crees.
1. URLs equivocadas
La documentación del proyecto decía /api/contact/contact/ pero el router de Django registra el viewset en messages, por lo que la URL real es /api/contact/messages/. Todos los tests de contacto devolvían 404 hasta que corregí las rutas.
Lección: los tests son la documentación más honesta de tu API.
2. Refresh de tokens
El endpoint de refresh estaba documentado como /api/auth/login/refresh/ pero la ruta real es /api/auth/token/refresh/. Otro 404 silencioso que los tests atraparon.
3. Ordenamiento con timestamps iguales
El test de ordenamiento de mensajes de contacto fallaba porque SQLite no garantiza el orden cuando dos registros tienen el mismo created_at (generado con auto_now_add). La solución fue forzar una diferencia de 5 minutos con update().
4. Elementos duplicados en el DOM
El test de PostCard buscaba getByText('Python') pero el componente renderiza "Python" en dos lugares (etiqueta de categoría + chip de tag). La solución fue usar getAllByText y verificar que al menos un elemento existe.
Patrones de Testing que Uso
Mocking de Servicios Externos
Vertex AI no está disponible en el entorno de CI. Uso unittest.mock.patch para mockear SearchEngine.generate_answer:
@patch('search.views.SearchEngine.generate_answer')
def test_rag_with_query(self, mock_generate):
mock_generate.return_value = {'answer': '...', 'sources': [], 'cached': False}
response = self.client.get('/api/search/rag/', {'q': 'test'})
mock_generate.assert_called_once_with('test')
Email Backend de Pruebas
Django proporciona locmem.EmailBackend que almacena emails en memoria:
@override_settings(EMAIL_BACKEND='django.core.mail.backends.locmem.EmailBackend')
def test_email_sent(self):
from django.core import mail
# ... enviar mensaje ...
self.assertEqual(len(mail.outbox), 1)
Providers para Componentes React
Material UI y React Router necesitan sus providers. Un helper centralizado evita repetición:
const renderWithProviders = (ui) =>
render(
<ThemeProvider theme={theme}>
<MemoryRouter>{ui}</MemoryRouter>
</ThemeProvider>
);
force_authenticate para Tests de Permisos
DRF permite autenticar sin enviar tokens reales:
```python blog_backend/blog/tests/test_api.py self.client.force_authenticate(user=self.employee) response = self.client.post('/api/blog/posts/', {...}) self.assertEqual(response.status_code, 201)
---
## Integración con CI/CD
Los tests se ejecutan como pasos obligatorios en el workflow de GitHub Actions:
```yaml
jobs:
deploy:
steps:
# Tests primero — si fallan, el workflow se detiene aquí
- name: Run backend tests
run: |
cd blog_backend
python manage.py test
- name: Run frontend tests
run: |
cd blog_frontend
npm test -- --watchAll=false --ci
# Solo si los tests pasan, se construyen y despliegan las imágenes
- name: Build Backend Image
run: gcloud builds submit ...
- name: Deploy Backend
uses: google-github-actions/deploy-cloudrun@v2
Los tests y el deploy viven en el mismo job, en secuencia. Si cualquier paso de tests falla, los pasos de build y deploy simplemente no se ejecutan.
Métricas del Resultado
| Métrica | Backend | Frontend | Total |
|---|---|---|---|
| Tests | 65 | 24 | 89 |
| Tiempo | ~28s | ~8s | ~36s |
| Apps cubiertas | 5/5 | 9 archivos | — |
| Modelos testeados | 5 | — | 5 |
| Endpoints testeados | 12+ | — | 12+ |
Lo que Sigue
- Cobertura: Agregar
coverage.py(backend) y--coverage(frontend) para medir y visualizar qué porcentaje del código está cubierto. - Tests de integración E2E: Cypress o Playwright para flujos completos (login → crear post → verificar en listado).
- Tests de performance: Lighthouse CI para métricas de rendimiento del frontend en cada deploy.
- Property-based testing: Hypothesis para generar inputs aleatorios y encontrar edge cases en modelos.
Conclusión
Agregar tests automáticos no fue solo una mejora técnica —fue un cambio de mentalidad. Pasé de "despliego y rezo" a "despliego con confianza". Los tests encontraron bugs reales (URLs incorrectas, elementos duplicados en el DOM, race conditions en timestamps) que habrían llegado a producción sin ellos.
Para un portafolio de Data Scientist, tener tests automáticos comunica algo importante a los reclutadores: que entiendes que el código no solo tiene que funcionar hoy, sino seguir funcionando mañana.
Código fuente: github.com/hecgarri/blog_project
Documentación técnica:docs/09-tests-automatizados.md
Anterior: Conectar un Formulario de Contacto con Gmail en Django + React
Siguiente: Analytics de Comportamiento: Entendiendo Cómo Navegan los Usuarios Mi Portafolio
Este artículo es parte de la serie "Construyendo un Blog con IA". El código fuente completo está en GitHub.