DEV Community

alexrai
alexrai

Posted on

Mockeamos la API de un proveedor para salvar el CI, y el mock nos mintió

Era martes. La ejecución de GitHub Actions llevaba unos 40 minutos cuando la suite de integración murió con el mismo error por tercera vez esa mañana:

FetchError: request to https://sandbox.<proveedor>.com/v1/rates failed
  status: 429 Too Many Requests
  retry-after: 3600
Enter fullscreen mode Exit fullscreen mode

Nuestro proveedor de tarifas de envío limita su sandbox a 1.000 llamadas al día por clave. Éramos cuatro desarrolladores, una clave compartida y una suite que hacía unas 180 llamadas por ejecución. Con seis pushes y un par de reintentos, la cuota se acababa antes de comer.

Esa semana perdimos casi dos días de sprint con un pipeline en rojo que nadie podía arreglar, porque en realidad no había nada roto. Al mes siguiente descubrimos que el proveedor también cobra el exceso de llamadas al sandbox. Unos 340 dólares por el privilegio de fallar nuestros propios tests.

Así que montamos un mock server. Arregló el pipeline. Y cinco semanas después dejó pasar un bug real hasta producción. Las dos mitades de la historia merecen contarse.

Lo que necesitábamos de verdad

No quería una librería de mocks repartida por los archivos de test. Ya lo habíamos hecho en un proyecto anterior con nock y cada test acabó con su propia versión, ligeramente distinta, de lo que devolvía el proveedor. Cambiar un endpoint significaba tocar 30 archivos.

Quería algo aburrido: un servidor HTTP local con las mismas rutas que el proveedor, que devuelva JSON grabado y que se active con una sola variable de entorno. El código de la aplicación no debería enterarse.

Si alguien de tu equipo no tiene claro el concepto, yo pasé por el canal interno la guía de Keploy sobre mock servers. Explica la diferencia entre hacer stubs dentro de un test y levantar un servidor aparte, que era justo la discusión que teníamos cada semana.

Son unas 30 líneas

Sin framework. El módulo http de Node es suficiente.

// mock-server.js
const http = require('node:http');
const fs = require('node:fs');
const path = require('node:path');

const fixtures = {
  'POST /v1/rates': 'rates-ok.json',
  'GET /v1/shipments/shp_123': 'shipment.json',
};

const server = http.createServer((req, res) => {
  const url = new URL(req.url, 'http://localhost');
  const key = `${req.method} ${url.pathname}`;
  const file = fixtures[key];

  if (!file) {
    res.writeHead(404, { 'content-type': 'application/json' });
    return res.end(JSON.stringify({ error: `no fixture for ${key}` }));
  }

  const body = fs.readFileSync(path.join(__dirname, 'fixtures', file));
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(body);
});

server.listen(process.env.MOCK_PORT || 4010, () => {
  console.log(`mock listening on ${server.address().port}`);
});
Enter fullscreen mode Exit fullscreen mode

Los fixtures eran respuestas reales que capturé del sandbox con curl. En CI, el workflow arranca el mock en segundo plano y apunta la aplicación hacia él:

node mock-server.js &
VENDOR_BASE_URL=http://localhost:4010 npm test
Enter fullscreen mode Exit fullscreen mode

El 404 con el nombre de la ruta resultó ser la línea más útil del archivo. Cuando alguien añade una llamada nueva y se olvida del fixture, el fallo le dice exactamente qué falta en lugar de quedarse colgado hasta el timeout.

Esa suite pasó de unos 40 minutos (casi todo reintentos y esperas) a menos de uno. Las llamadas al sandbox desde CI bajaron a cero y el cargo extra desapareció de la factura.

Durante cinco semanas pensé que habíamos terminado.

Dónde me equivoqué

El proveedor cambió su endpoint de tarifas. El campo amount, un decimal en euros, pasó a ser amount_cents, un entero. Lo anunciaron en un correo de novedades que llegó a un buzón compartido que nadie lee.

Nuestros fixtures seguían teniendo amount. Nuestros tests seguían pasando. Claro que pasaban: estaban probando contra una foto de la API de hacía mes y medio.

En producción, rate.amount llegó como undefined. El checkout mostró el envío como "NaN €" durante unas tres horas de un día laborable, hasta que nos llegó un ticket de soporte.

Eso fue culpa mía. Traté los fixtures como algo terminado cuando en realidad son una caché, y las cachés caducan. Un mock te dice que tu código maneja bien una respuesta concreta. No te dice nada sobre si esa respuesta sigue existiendo.

La comprobación nocturna

La solución no fue tirar el mock. Fue añadir un job pequeño que, una vez cada noche, compara la forma del fixture con lo que devuelve el sandbox en ese momento. Gasta un puñado de llamadas, no 180 por push.

// check-drift.js (Node 18+, usa fetch global)
const fixture = require('./fixtures/rates-ok.json');

function keys(obj, prefix = '') {
  return Object.entries(obj).flatMap(([k, v]) =>
    v && typeof v === 'object' && !Array.isArray(v)
      ? keys(v, `${prefix}${k}.`)
      : [`${prefix}${k}`]
  );
}

(async () => {
  const res = await fetch(`${process.env.SANDBOX_URL}/v1/rates`, {
    method: 'POST',
    headers: {
      authorization: `Bearer ${process.env.SANDBOX_KEY}`,
      'content-type': 'application/json',
    },
    body: JSON.stringify({ from: '28001', to: '08001', weight_g: 500 }),
  });

  const liveKeys = keys(await res.json());
  const missing = keys(fixture).filter((k) => !liveKeys.includes(k));

  if (missing.length) {
    console.error('el fixture tiene campos que la API ya no devuelve:', missing);
    process.exit(1);
  }
  console.log('el fixture coincide con la API real');
})();
Enter fullscreen mode Exit fullscreen mode

Es tosco. Solo mira nombres de campos, no tipos, y trata los arrays como hojas. Pero habría detectado el cambio de amount a la mañana siguiente, y ese era el listón. Corre a las 2 de la madrugada y avisa por Slack si falla.

Lo que le diría a un compañero que empieza hoy

Graba los fixtures desde respuestas reales. No los escribas a mano a partir de la documentación. La documentación miente más que los sandboxes.

Mantén el mock tonto. En cuanto empieza a tener lógica ("si el peso supera 10 kg devuelve este otro fixture") estás manteniendo una segunda versión, peor, de la API del proveedor. Si de verdad necesitas respuestas que dependan del estado o de la petición, eso ya es simulación de APIs y conviene tratarlo como un proyecto aparte, no como un if más dentro del mock.

Yo no mockearía todo. La base de datos, por ejemplo, la sigo levantando de verdad en un contenedor, porque ahí los mocks esconden justo los fallos que más duelen.

Y ponle nombre y apellido al correo de novedades del proveedor. Ese correo fue la causa real del incidente, y ninguna herramienta arregla un buzón que nadie abre.

El mock nos dio velocidad. La comprobación nocturna nos devolvió la confianza que habíamos entregado sin darnos cuenta para conseguirla.

Top comments (0)