Cómo simular llamadas a la API con Jest: Un tutorial completo

Al escribir pruebas para código que realiza llamadas a la API, es importante simular esas llamadas para garantizar que tus pruebas sean fiables, rápidas y no dependan de un servicio externo. Jest, un popular framework de pruebas de JavaScript, proporciona varias formas de simular fácilmente las llamadas a la API en tus pruebas. Profundicemos en los diferentes enfoques que puedes utilizar.

Usando jest.mock()

Una forma de simular llamadas a la API en Jest es usando la función jest.mock() para simular todo el módulo que realiza la solicitud a la API. Aquí tienes un ejemplo:

// api.js
import axios from 'axios';

export const getUsers = () => {
  return axios.get('/users');
};

// api.test.js
import axios from 'axios';
import { getUsers } from './api';

jest.mock('axios');

test('getUsers devuelve datos de la API', async () => {
  const users = [{ id: 1, name: 'John' }];
  axios.get.mockResolvedValueOnce({ data: users });
  
  const result = await getUsers();
  
  expect(axios.get).toHaveBeenCalledWith('/users');
  expect(result.data).toEqual(users);
});

En este ejemplo, usamos jest.mock('axios') para simular automáticamente todo el módulo axios. Luego usamos axios.get.mockResolvedValueOnce() para simular la respuesta para la siguiente llamada a axios.get. Nuestra prueba puede entonces verificar que la API fue llamada correctamente y devuelve los datos simulados1.

Usando Simulaciones Manuales

Otro enfoque es simular manualmente el módulo que realiza la llamada a la API creando una carpeta __mocks__ y colocando un archivo de implementación simulada dentro:

// __mocks__/axios.js
export default {
  get: jest.fn(() => Promise.resolve({ data: {} })),
  post: jest.fn(() => Promise.resolve({ data: {} })),
  // ...
};

Ahora en tu prueba, puedes simular diferentes respuestas para cada prueba:

// api.test.js
import axios from 'axios';
import { getUsers } from './api';

jest.mock('axios');

test('getUsers devuelve datos de la API', async () => {
  const users = [{ id: 1, name: 'John' }];
  axios.get.mockResolvedValueOnce({ data: users });
  
  const result = await getUsers();
  
  expect(axios.get).toHaveBeenCalledWith('/users');
  expect(result.data).toEqual(users);
});

Con esta simulación manual, tienes control total para simular los diferentes métodos de Axios como get, post, etc. con tus propias implementaciones2.

Usando Axios-mock-adapter

Puedes usar la biblioteca para simular las solicitudes de Axios de forma más avanzada. Primero, instálala:

npm install axios-mock-adapter --save-dev

Luego en tus pruebas:

// api.test.js
import axios from 'axios';
import MockAdapter from 'axios-mock-adapter';
import { getUsers } from './api';

describe('getUsers', () => {
  let mock;
  
  beforeAll(() => {
    mock = new MockAdapter(axios);
  });
  
  afterEach(() => {  
    mock.reset();
  });
  
  test('devuelve datos de usuarios', async () => {
    const users = [{ id: 1, name: 'John' }];
    mock.onGet('/users').reply(200, users);
    
    const result = await getUsers();
    
    expect(result.data).toEqual(users);  
  });
});

Con el axios-mock-adapter, puedes simular solicitudes basadas en URLs, parámetros, encabezados y más. También puedes simular errores y tiempos de espera.

Inyectando una Instancia de Axios Simulada

Si tu código usa axios directamente, otra opción es inyectar una instancia de axios simulada en tu código durante las pruebas:

// api.js
import axios from 'axios';

export const getUsers = () => {
  return axios.get('/users');
};

// api.test.js
import axios from 'axios';
import { getUsers } from './api';

jest.mock('axios', () => ({
  get: jest.fn(),
}));

test('getUsers devuelve datos de la API', async () => {
  const users = [{ id: 1, name: 'John' }];
  axios.get.mockResolvedValueOnce({ data: users });
  
  const result = await getUsers();
  
  expect(axios.get).toHaveBeenCalledWith('/users');
  expect(result.data).toEqual(users);
});

Aquí simulamos axios en sí, no todo el módulo, y proporcionamos nuestra propia función get simulada.

Consejos para Simular Llamadas a la API

Aquí tienes algunos consejos a tener en cuenta al simular llamadas a la API en Jest:

• Restablece tus simulaciones entre pruebas para asegurar pruebas independientes usando beforeEach y afterEach
• No simules demasiado - solo simula las funciones y módulos que tu código realmente usa
• Prueba también los casos de fallo simulando errores y respuestas inesperadas
• Considera la posibilidad de crear fixtures de simulación reutilizables para respuestas de API comunes

Simula APIs con Apidog

Si deseas probar una experiencia de desarrollo de API diferente, ¡puedes considerar usar Apidog!

Apidog es una plataforma de API de bajo código que proporciona a los desarrolladores una interfaz de usuario sencilla e intuitiva para desarrollar APIs. Con Apidog, puedes construir, probar, simular y documentar APIs. ¡Echemos un vistazo más de cerca a Apidog!

Simulación Inteligente de Apidog

Deja que Apidog genere automáticamente datos de simulación realistas sin configuración manual si no tienes reglas de simulación definitivas.

Simulación Avanzada de Apidog

Modifica las respuestas de la API con scripts personalizados para simular interacciones reales entre el cliente y el lado del servidor.

Simulación en la Nube de Apidog

Colabora con tu equipo con la función de simulación en la nube a través de una dirección fija, accesible en el servidor de simulación en la nube.

Conclusión

La simulación es una habilidad fundamental para escribir buenas pruebas, especialmente cuando se trata de dependencias externas como las llamadas a la API. Jest proporciona muchas formas de simular llamadas a la API en tus pruebas, desde simular módulos enteros con jest.mock(), hasta simular módulos manualmente, hasta usar bibliotecas como axios-mock-adapter para casos más avanzados. La clave es elegir el enfoque correcto para tus necesidades, manteniendo tus pruebas independientes y centradas en el código que se está probando, no en los detalles de implementación de las APIs. Con estas técnicas de simulación en tu cinturón de herramientas, puedes escribir pruebas resilientes para código que depende de APIs.