diff --git a/app/api/indicadores/route.test.ts b/app/api/indicadores/route.test.ts index 011e3eb..558f4e6 100644 --- a/app/api/indicadores/route.test.ts +++ b/app/api/indicadores/route.test.ts @@ -1,75 +1,163 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; -import type { IndicadoresSnapshot } from '@/types/indicador'; - -const snapshot: IndicadoresSnapshot = { - version: '1.7.0', - autor: 'mindicador.cl', - fecha: '2026-07-25T00:00:00.000Z', - uf: { - codigo: 'uf', - nombre: 'Unidad de fomento (UF)', - unidad_medida: 'Pesos', - fecha: '2026-07-25T00:00:00.000Z', - valor: 40845, - }, -} as IndicadoresSnapshot; - -function mockFetchOnce(response: { ok: boolean; status?: number; json: () => Promise }) { - vi.mocked(fetch).mockResolvedValueOnce(response as Response); +import { getCodigoSerieBancoCentral } from '@/lib/bcentral-client'; +import { INDICADOR_CODIGOS, type IndicadorCodigo } from '@/types/indicador'; + +// La API de Banco Central declara charset=ISO-8859-1: response.arrayBuffer() +// tiene que decodificar los bytes crudos como Latin-1 (ver bcentral-client.ts +// y su test). Estos mocks de fetch simulan exactamente ese formato de bytes. +function bufferLatin1(texto: string): ArrayBuffer { + const bytes = new Uint8Array(texto.length); + for (let i = 0; i < texto.length; i += 1) { + bytes[i] = texto.charCodeAt(i) & 0xff; + } + return bytes.buffer; +} + +function respuestaOk(valor: number): Response { + return { + arrayBuffer: async () => + bufferLatin1( + JSON.stringify({ + Codigo: 0, + Descripcion: 'Success', + Series: { + descripEsp: 'Serie', + descripIng: 'Series', + seriesId: 'X', + Obs: [{ indexDateString: '27-07-2026', value: String(valor), statusCode: 'OK' }], + }, + SeriesInfos: [], + }), + ), + } as Response; } -function mockFetchRejectOnce(error: Error) { - vi.mocked(fetch).mockRejectedValueOnce(error); +function respuestaError(): Response { + return { + arrayBuffer: async () => + bufferLatin1( + JSON.stringify({ + Codigo: -50, + Descripcion: 'fallo simulado', + Series: { descripEsp: null, descripIng: null, seriesId: null, Obs: null }, + SeriesInfos: [], + }), + ), + } as Response; } -// El route handler mantiene `lastSnapshot` como estado en memoria a nivel de -// modulo (no exportado). Se resetean los modulos y se importa el handler de -// forma dinamica en cada test para que ese cache no se filtre entre tests. +function timeseriesDe(url: unknown): string | null { + return url instanceof URL ? url.searchParams.get('timeseries') : null; +} + +// El route handler mantiene el cache por indicador como estado en memoria a +// nivel de modulo (no exportado). Se resetean los modulos y se importa el +// handler de forma dinamica en cada test para que ese cache no se filtre +// entre tests (salvo en los tests que llaman GET() dos veces a proposito). describe('GET /api/indicadores', () => { beforeEach(() => { vi.resetModules(); vi.stubGlobal('fetch', vi.fn()); + vi.stubEnv('BCENTRAL_USER', 'usuario-test'); + vi.stubEnv('BCENTRAL_PASS', 'clave-test'); }); afterEach(() => { vi.unstubAllGlobals(); + vi.unstubAllEnvs(); }); - it('responde 200 con el snapshot cuando la API externa funciona', async () => { - mockFetchOnce({ ok: true, json: async () => snapshot }); + it('responde 200 con los 10 indicadores cuando las 10 llamadas funcionan', async () => { + vi.mocked(fetch).mockImplementation(async () => respuestaOk(1)); const { GET } = await import('@/app/api/indicadores/route'); const response = await GET(); + const body = await response.json(); expect(response.status).toBe(200); - await expect(response.json()).resolves.toEqual(snapshot); + INDICADOR_CODIGOS.forEach((codigo) => { + expect(body[codigo]?.valor).toBe(1); + }); }); - it('cae al ultimo valor cacheado en memoria cuando la API externa falla', async () => { + it('dispara las 10 llamadas en paralelo, no secuenciales', async () => { + let enVuelo = 0; + let maximoEnVuelo = 0; + vi.mocked(fetch).mockImplementation(async () => { + enVuelo += 1; + maximoEnVuelo = Math.max(maximoEnVuelo, enVuelo); + await new Promise((resolve) => setTimeout(resolve, 5)); + enVuelo -= 1; + return respuestaOk(1); + }); const { GET } = await import('@/app/api/indicadores/route'); - // Primera llamada exitosa: deja el snapshot cacheado en memoria. - mockFetchOnce({ ok: true, json: async () => snapshot }); - const primeraRespuesta = await GET(); - expect(primeraRespuesta.status).toBe(200); + await GET(); + + expect(maximoEnVuelo).toBe(INDICADOR_CODIGOS.length); + }); + + it('un fallo en 1 de los 10 indicadores no degrada los otros 9', async () => { + const codigoFallido: IndicadorCodigo = 'tpm'; + const serieFallida = getCodigoSerieBancoCentral(codigoFallido); + vi.mocked(fetch).mockImplementation(async (url) => + timeseriesDe(url) === serieFallida ? respuestaError() : respuestaOk(1), + ); + const { GET } = await import('@/app/api/indicadores/route'); - // Segunda llamada: la API externa falla, pero como ya hay cache, sigue - // respondiendo 200 con el ultimo valor conocido en vez de propagar el error. - mockFetchRejectOnce(new Error('fetch failed')); - const segundaRespuesta = await GET(); + const response = await GET(); + const body = await response.json(); - expect(segundaRespuesta.status).toBe(200); - await expect(segundaRespuesta.json()).resolves.toEqual(snapshot); + expect(response.status).toBe(200); + expect(body[codigoFallido]).toBeUndefined(); + INDICADOR_CODIGOS.filter((codigo) => codigo !== codigoFallido).forEach((codigo) => { + expect(body[codigo]?.valor).toBe(1); + }); }); - it('responde 502 cuando la API externa falla y no hay nada cacheado', async () => { - mockFetchRejectOnce(new Error('fetch failed')); + it('cae al valor cacheado de un indicador cuando su llamada vuelve a fallar', async () => { + const codigoAFallar: IndicadorCodigo = 'uf'; + const serieAFallar = getCodigoSerieBancoCentral(codigoAFallar); + const { GET } = await import('@/app/api/indicadores/route'); + + vi.mocked(fetch).mockImplementation(async () => respuestaOk(1)); + await GET(); + + vi.mocked(fetch).mockImplementation(async (url) => + timeseriesDe(url) === serieAFallar ? respuestaError() : respuestaOk(2), + ); + const response = await GET(); + const body = await response.json(); + + expect(response.status).toBe(200); + expect(body[codigoAFallar].valor).toBe(1); + expect(body.dolar.valor).toBe(2); + }); + + it('responde 502 cuando las 10 llamadas fallan y no hay nada cacheado', async () => { + vi.mocked(fetch).mockImplementation(async () => respuestaError()); const { GET } = await import('@/app/api/indicadores/route'); const response = await GET(); expect(response.status).toBe(502); const body = (await response.json()) as { error: string }; - expect(body.error).toContain('fetch failed'); + expect(body.error).toBeTruthy(); + }); + + it('cuando las 10 fallan pero habia cache previo, sirve el ultimo snapshot cacheado', async () => { + const { GET } = await import('@/app/api/indicadores/route'); + + vi.mocked(fetch).mockImplementation(async () => respuestaOk(1)); + await GET(); + + vi.mocked(fetch).mockImplementation(async () => respuestaError()); + const response = await GET(); + const body = await response.json(); + + expect(response.status).toBe(200); + INDICADOR_CODIGOS.forEach((codigo) => { + expect(body[codigo]?.valor).toBe(1); + }); }); }); diff --git a/app/api/indicadores/route.ts b/app/api/indicadores/route.ts index 23685b1..4cd8166 100644 --- a/app/api/indicadores/route.ts +++ b/app/api/indicadores/route.ts @@ -1,23 +1,60 @@ import { NextResponse } from 'next/server'; -import { getSnapshot } from '@/lib/mindicador-client'; -import type { IndicadoresSnapshot } from '@/types/indicador'; +import { BancoCentralApiError, getUltimoValor } from '@/lib/bcentral-client'; +import { + INDICADOR_CODIGOS, + type Indicador, + type IndicadorCodigo, + type IndicadoresSnapshot, +} from '@/types/indicador'; -const REVALIDATE_SECONDS = 300; +// Cache por indicador (no un snapshot unico como con mindicador.cl): cada +// codigo guarda su ultimo valor exitoso de forma independiente. Con Banco +// Central el snapshot son 10 llamadas independientes en vez de 1 - si una +// falla, se sirve el ultimo valor cacheado de ESE indicador sin afectar al +// resto (ver docs/migracion-banco-central.md, decision de resiliencia). +const cachePorIndicador = new Map(); -let lastSnapshot: IndicadoresSnapshot | null = null; - -export async function GET() { +async function obtenerConFallback(codigo: IndicadorCodigo): Promise { try { - const snapshot = await getSnapshot({ revalidate: REVALIDATE_SECONDS }); - lastSnapshot = snapshot; - return NextResponse.json(snapshot, { status: 200 }); + const indicador = await getUltimoValor(codigo); + cachePorIndicador.set(codigo, indicador); + return indicador; } catch (error) { - if (lastSnapshot) { - return NextResponse.json(lastSnapshot, { status: 200 }); + if (error instanceof BancoCentralApiError) { + console.error( + `Banco Central fallo para ${codigo} (serie ${error.codigoSerie}, Codigo ${error.codigoRespuesta ?? 'N/A'}): ${error.message}`, + ); + } else { + console.error(`Error inesperado obteniendo ${codigo} de Banco Central:`, error); + } + return cachePorIndicador.get(codigo); + } +} + +export async function GET() { + const resultados = await Promise.all(INDICADOR_CODIGOS.map(obtenerConFallback)); + + const indicadores: Partial> = {}; + INDICADOR_CODIGOS.forEach((codigo, indice) => { + const valor = resultados[indice]; + if (valor) { + indicadores[codigo] = valor; } + }); - const message = - error instanceof Error ? error.message : 'Error desconocido al consultar mindicador.cl'; - return NextResponse.json({ error: message }, { status: 502 }); + if (Object.keys(indicadores).length === 0) { + return NextResponse.json( + { error: 'No se pudo obtener ningun indicador desde el Banco Central' }, + { status: 502 }, + ); } + + const snapshot: IndicadoresSnapshot = { + version: '2.0', + autor: 'Banco Central de Chile', + fecha: new Date().toISOString(), + ...indicadores, + }; + + return NextResponse.json(snapshot, { status: 200 }); } diff --git a/types/indicador.ts b/types/indicador.ts index 949372c..2f191e4 100644 --- a/types/indicador.ts +++ b/types/indicador.ts @@ -21,20 +21,24 @@ export interface Indicador { valor: number; } +// Los campos de indicador son opcionales: con Banco Central el snapshot se +// arma a partir de 10 llamadas independientes con fallback por indicador +// (ver app/api/indicadores/route.ts) - un indicador puede quedar ausente si +// su llamada fallo y tampoco habia nada cacheado todavia para el. export interface IndicadoresSnapshot { version: string; autor: string; fecha: string; - uf: Indicador; - ivp: Indicador; - dolar: Indicador; - euro: Indicador; - ipc: Indicador; - utm: Indicador; - imacec: Indicador; - tpm: Indicador; - libra_cobre: Indicador; - tasa_desempleo: Indicador; + uf?: Indicador; + ivp?: Indicador; + dolar?: Indicador; + euro?: Indicador; + ipc?: Indicador; + utm?: Indicador; + imacec?: Indicador; + tpm?: Indicador; + libra_cobre?: Indicador; + tasa_desempleo?: Indicador; } export interface SerieHistoricaPunto {