Reusable Mock - Documentación

Descripción del Proyecto

Este proyecto demuestra cómo implementar mocks reutilizables en TypeScript usando Jest. El enfoque utilizado permite simular el comportamiento de servicios externos para realizar pruebas unitarias de manera efectiva.

Instalación

Para instalar las dependencias del proyecto:

npm install

Funcionamiento

El proyecto implementa una forma efectiva de mockear servicios en TypeScript con Jest:

1. Servicio real: userService.ts contiene la función getUser que simula una llamada a una API para obtener datos de usuario.

2. Implementación de mocks: El directorio __mocks__ contiene una versión simulada del servicio que reemplaza la implementación real durante las pruebas.

3. Configuración de mocks: jest.setup.ts configura Jest para utilizar automáticamente los mocks cuando se importa el servicio.

Ejecución de Pruebas

Para ejecutar las pruebas:

npm run test

Ventajas del Enfoque

• Aislamiento: Las pruebas no dependen de servicios externos
• Control: Puedes simular diferentes respuestas para probar todos los casos
• Reutilización: La configuración de mocks es centralizada

Tecnologías Utilizadas

• TypeScript
• Jest
• ts-jest
• Node.js

Licencia

ISC

---

Este proyecto sirve como ejemplo práctico de cómo implementar pruebas unitarias con mocks reutilizables en aplicaciones TypeScript.

Pruebas Unitarias con Jest y Mocks

Este proyecto utiliza Jest para realizar pruebas unitarias. A continuación, se explica cómo configurar y utilizar mocks en los tests.

Configuración de Jest

1. Instalación de Jest

Si no tienes Jest instalado, puedes agregarlo a tu proyecto con:

npm install --save-dev jest

2. Configuración de jest.config.ts

El archivo jest.config.ts define la configuración de Jest. Aquí hay un ejemplo básico:

import type { Config } from 'jest';

const config: Config = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
  moduleNameMapper: {
    '^src/(.*)$': '<rootDir>/src/$1',
  },
};

export default config;

3. Archivo jest.setup.ts

El archivo jest.setup.ts se utiliza para configurar mocks globales y otras configuraciones que se aplican a todos los tests. Aquí hay un ejemplo:

import { mockUsers } from './tests/__mocks__/user.mock';
import { mockProducts } from './tests/__mocks__/product.mock';

jest.mock('./src/api/ApiClient', () => ({
  ApiClient: jest.fn().mockImplementation(() => ({
    get: jest.fn().mockImplementation((endpoint: string) => {
      if (endpoint === '/users') {
        return mockUsers;
      } else if (endpoint === '/products') {
        return mockProducts;
      } else if (endpoint.startsWith('/products/')) {
        const productId = parseInt(endpoint.split('/')[2], 10);
        return mockProducts.find((p) => p.id === productId) || null;
      }
      return null;
    }),
  })),
}));

Uso de Mocks en los Tests

1. Mock Automático con jest.mock()

Cuando usas jest.mock(), Jest intercepta las importaciones de los módulos especificados y reemplaza las implementaciones reales con las que defines en el mock. Esto permite que los tests utilicen automáticamente el mock en lugar de la implementación real.

Ejemplo en UserService.test.ts:

import { UserService } from "../src/services/UserService";
import { mockUsers } from "./__mocks__/user.mock";

describe('UserService with mocked ApiClient', () => {
  let userService: UserService;

  beforeEach(() => {
    userService = new UserService(); // Usará el mock automáticamente
  });

  it('should get all users using the mocked ApiClient', async () => {
    const users = await userService.getUsers();
    expect(users).toEqual(mockUsers);
  });

  it('should get a user by ID using the mocked ApiClient', async () => {
    const user = await userService.getUserById(1);
    expect(user).toEqual({ id: 1, name: 'Isabel' });
  });
});

2. Mock Manual en Tests

Si necesitas un mock específico para un test, puedes configurarlo manualmente usando jest.fn().

Ejemplo:

import { ApiClient } from '../src/api/ApiClient';
import { UserService } from '../src/services/UserService';

describe('UserService with manual mock', () => {
  let userService: UserService;
  let mockApiClient: jest.Mocked<ApiClient>;

  beforeEach(() => {
    mockApiClient = {
      get: jest.fn().mockResolvedValue([{ id: 1, name: 'Isabel' }]),
    } as jest.Mocked<ApiClient>;

    userService = new UserService(mockApiClient);
  });

  it('get all users using the manual mock', async () => {
    const users = await userService.getUsers();
    expect(users).toEqual([{ id: 1, name: 'Isabel' }]);
  });
});

Estructura de Mocks

1. Archivos de Mocks

Los mocks se almacenan en la carpeta __mocks__. Por ejemplo:

tests/__mocks__/user.mock.ts:

export const mockUsers = [
  { id: 1, name: 'Isabel' },
  { id: 2, name: 'Carlos' },
  { id: 3, name: 'Elena' },
];

tests/__mocks__/product.mock.ts:

export const mockProducts = [
  { id: 1, name: 'Laptop', price: 999.99 },
  { id: 2, name: 'Smartphone', price: 499.99 },
  { id: 3, name: 'Tablet', price: 299.99 },
];

Ejecución de los Tests

Para ejecutar los tests, usa el siguiente comando:

npm run test

Conclusión

El uso de mocks en Jest permite aislar las pruebas unitarias de dependencias externas, lo que garantiza que los tests sean predecibles y confiables. Con la configuración adecuada, puedes automatizar el uso de mocks en todos los tests, simplificando el proceso de desarrollo y pruebas.