Saltar al contenido
hg.Héctor GarridoCiencia de datos · Estadística · Ingeniería de datos
← Volver al blog
Portafolio RAG

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.

Por Qué Implementé Tests Automáticos en Mi Portafolio (Django + React)

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 de content_html desde Markdown, cálculo de reading_time, cover_url cuando no hay imagen.
  • QuerySets: published(), public(), internal() — filtrado correcto de posts según is_published e is_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_EMAIL no 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 con TaskTag.
  • 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

  1. Cobertura: Agregar coverage.py (backend) y --coverage (frontend) para medir y visualizar qué porcentaje del código está cubierto.
  2. Tests de integración E2E: Cypress o Playwright para flujos completos (login → crear post → verificar en listado).
  3. Tests de performance: Lighthouse CI para métricas de rendimiento del frontend en cada deploy.
  4. 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.