Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
166 changes: 127 additions & 39 deletions app/api/indicadores/route.test.ts
Original file line number Diff line number Diff line change
@@ -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<unknown> }) {
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);
});
});
});
65 changes: 51 additions & 14 deletions app/api/indicadores/route.ts
Original file line number Diff line number Diff line change
@@ -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<IndicadorCodigo, Indicador>();

let lastSnapshot: IndicadoresSnapshot | null = null;

export async function GET() {
async function obtenerConFallback(codigo: IndicadorCodigo): Promise<Indicador | undefined> {
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<Record<IndicadorCodigo, Indicador>> = {};
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 });
}
24 changes: 14 additions & 10 deletions types/indicador.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down
Loading