# FASE 2 - Prueba de Fallback Automático

## 🎯 Objetivo
Verificar que el sistema hace fallback automático de `ExternalContentAdapter` a `LocalContentAdapter` cuando el backend no está disponible.

## 🔍 Cómo Funciona el Fallback

### ContentAdapterFactory
El `ContentAdapterFactory` decide automáticamente qué adapter usar:

```typescript
static getAdapter(): ContentAdapter {
  // Crear adapters si no existen
  if (!this.externalAdapter) {
    this.externalAdapter = new ExternalContentAdapter();
  }
  if (!this.localAdapter) {
    this.localAdapter = new LocalContentAdapter();
  }

  // Intentar usar external primero, fallback a local
  if (this.externalAdapter.isAvailable()) {
    return this.externalAdapter;
  }

  return this.localAdapter;
}
```

### ExternalContentAdapter
- Intenta cargar el Content Pack desde el backend
- Si falla, marca `loaded = true` pero `pack = null`
- `isAvailable()` retorna `false` si `pack === null`
- El factory automáticamente usa `LocalContentAdapter` como fallback

### LocalContentAdapter
- Siempre disponible (`isAvailable() === true`)
- Lee datos directamente de `src/data/*.ts`
- No requiere conexión al backend

## 🧪 Pruebas Realizadas

### 1. Backend Disponible
```bash
# Verificar que el backend responde
curl http://localhost:3000/health

# Verificar Content Pack
curl http://localhost:3000/api/content-pack/latest.json
```

**Resultado esperado:**
- ✅ Backend responde
- ✅ Content Pack disponible
- ✅ `ExternalContentAdapter` se usa automáticamente
- ✅ Badge "Externo" visible en la UI

### 2. Backend No Disponible
```bash
# Detener backend
kill $(lsof -ti:3000)

# Verificar que no responde
curl http://localhost:3000/health
```

**Resultado esperado:**
- ✅ Backend no responde
- ✅ `ExternalContentAdapter.isAvailable() === false`
- ✅ `LocalContentAdapter` se usa automáticamente
- ✅ App funciona normalmente con datos locales
- ✅ No hay errores en consola

### 3. Cache del Content Pack
El `ExternalContentAdapter` intenta usar cache antes de hacer fetch:

1. **IndexedDB** (primero)
2. **localStorage** (fallback)
3. **Fetch desde backend** (si no hay cache)

Si hay cache válido (< 24 horas), el adapter puede seguir funcionando aunque el backend esté caído.

## 📋 Checklist de Verificación

### En el Navegador

1. **Con Backend Activo:**
   - [ ] Abrir http://localhost:8096
   - [ ] Abrir consola del navegador
   - [ ] Verificar mensaje: `[ContentAdapter] Content Pack cargado desde servidor`
   - [ ] Verificar badge "Externo" visible
   - [ ] Navegar a diferentes páginas (Fármacos, Protocolos, Guías)
   - [ ] Verificar que los datos se cargan correctamente

2. **Sin Backend (Fallback):**
   - [ ] Detener backend: `kill $(lsof -ti:3000)`
   - [ ] Recargar página en navegador
   - [ ] Verificar mensaje en consola: `[ContentAdapter] No se pudo cargar Content Pack`
   - [ ] Verificar que NO aparece badge "Externo"
   - [ ] Navegar a diferentes páginas
   - [ ] Verificar que los datos locales se cargan correctamente
   - [ ] No debe haber errores en consola

3. **Reconexión Automática:**
   - [ ] Reiniciar backend: `cd backend && npm start`
   - [ ] Recargar página en navegador
   - [ ] Verificar que vuelve a usar `ExternalContentAdapter`
   - [ ] Badge "Externo" vuelve a aparecer

## 🔧 Comandos Útiles

```bash
# Verificar estado del backend
curl http://localhost:3000/health

# Ver Content Pack
curl http://localhost:3000/api/content-pack/latest.json | jq '.metadata'

# Detener backend
kill $(lsof -ti:3000)

# Reiniciar backend
cd backend && npm start

# Ver logs del backend
tail -f /tmp/backend.log
```

## ✅ Resultados Esperados

### Escenario 1: Backend Disponible
- ✅ `ExternalContentAdapter` activo
- ✅ Content Pack cargado desde servidor
- ✅ Badge "Externo" visible
- ✅ Datos del backend se muestran

### Escenario 2: Backend No Disponible
- ✅ `LocalContentAdapter` activo (fallback automático)
- ✅ Datos locales se muestran
- ✅ No hay errores
- ✅ App funciona normalmente

### Escenario 3: Cache Disponible
- ✅ `ExternalContentAdapter` puede usar cache
- ✅ Funciona aunque backend esté caído temporalmente
- ✅ Cache válido por 24 horas

## 📝 Notas

- El fallback es **completamente automático** y **transparente** para el usuario
- No se requiere ninguna acción manual
- La app **siempre funciona**, con o sin backend
- El cache permite funcionar offline por hasta 24 horas

## 🎯 Estado Actual

- ✅ Backend funcionando
- ✅ Content Pack generándose correctamente
- ✅ `ExternalContentAdapter` implementado
- ✅ `LocalContentAdapter` implementado
- ✅ `ContentAdapterFactory` con fallback automático
- ✅ Cache implementado (IndexedDB + localStorage)
- ⏳ **Pendiente:** Prueba manual en navegador

## 🚀 Siguiente Paso

Probar manualmente en el navegador siguiendo el checklist de verificación arriba.