Pruebas unitarias de TypeScript
Prácticas de pruebas unitarias en proyectos TypeScript para garantizar la calidad del código.
Las pruebas unitarias pueden verificar la corrección del código. El sistema de tipos de TypeScript se combina perfectamente con el marco de pruebas, lo que permite escribir código de prueba con seguridad de tipos.
Diagrama SVG: flujo de pruebas unitarias
¿Por qué se necesitan pruebas unitarias?
Las pruebas unitarias son un medio importante para garantizar la calidad del código; pueden verificar la corrección del código y prevenir la aparición de errores.
En proyectos TypeScript, el código de prueba también se beneficia del sistema de tipos: los errores de tipo se detectan en tiempo de compilación, el IDE proporciona sugerencias inteligentes y el código de prueba es más confiable.
Además, el código de prueba es también la mejor documentación; a través de las pruebas se puede comprender el comportamiento esperado de funciones/clases.
Garantía de calidad:Las pruebas unitarias pueden detectar rápidamente problemas de regresión, asegurando que los cambios de código no rompan la funcionalidad existente.
Configuración del marco de pruebas
Jest es el marco de pruebas más popular para proyectos TypeScript.
Instalación de Jest
# - ts-jest:Permitir que Jest ejecute TypeScript
# - @types/jest:Definiciones de tipos de Jest
npm install --save-dev jest ts-jest @types/jest
# Inicializar la configuración de Jest
npx ts-jest config:init
ts-jest:Este es un preprocesador que permite a Jest ejecutar directamente archivos TypeScript sin compilación manual.
Configuración de jest.config.js
Configurar el entorno de pruebas de Jest.
jest.config.js
// Usar la configuración preestablecida de ts-jest
preset: 'ts-jest',
// Entorno de prueba: node o browser
testEnvironment: 'node',
// Directorio de archivos de prueba
roots: ['<rootDir>/src'],
// Patrón de coincidencia de archivos de prueba
testMatch: ['**/__tests__/**/*.ts'],
// Extensiones de archivo admitidas
moduleFileExtensions: ['ts', 'js', 'json'],
// Archivos para recopilar cobertura
collectCoverageFrom: [
'src/**/*.ts',
'!src/**/*.d.ts' // Excluir archivos de declaración de tipos
]
}
Notas de configuración:Los archivos de prueba generalmente se colocan en el directorio __tests__ o terminan con .test.ts.
Prueba de funciones
Primero, escriba el código de negocio que necesita ser probado.
src/utils/calculator.ts
export class Calculator {
// Suma
add(a: number, b: number): number {
return a + b;
}
// Resta
subtract(a: number, b: number): number {
return a - b;
}
// Multiplicación
multiply(a: number, b: number): number {
return a * b;
}
// División
divide(a: number, b: number): number {
if (b === 0) {
throw new Error("Cannot divide by zero");
}
return a / b;
}
}
Luego, escriba el código de prueba correspondiente.
src/utils/calculator.test.ts
// Suite de pruebas: pruebas de la clase Calculator
describe("Calculator", () => {
let calculator: Calculator;
// Crear una nueva instancia de Calculator antes de cada prueba
beforeEach(() => {
calculator = new Calculator();
});
// Prueba de suma
describe("add", () => {
it("should add two numbers", () => {
expect(calculator.add(2, 3)).toBe(5);
});
it("should handle negative numbers", () => {
expect(calculator.add(-1, 1)).toBe(0);
});
});
// Prueba de división
describe("divide", () => {
it("should divide two numbers", () => {
expect(calculator.divide(10, 2)).toBe(5);
});
it("should throw error when dividing by zero", () => {
// Esperar que se lance un error
expect(() => calculator.divide(10, 0)).toThrow();
});
});
});
Resultado de ejecución:
Calculator
add
✓ should add two numbers
✓ should handle negative numbers
divide
✓ should divide two numbers
✓ should throw error when dividing by zero
describe/it:describe se usa para agrupar pruebas, e it (o test) se usa para definir casos de prueba individuales.
Prueba de servicios
Probar la lógica de negocio de la capa de servicios.
src/services/userService.ts
export interface User {
id: number;
name: string;
}
// Clase de servicio de usuario
export class UserService {
private users: User[] = [];
private nextId = 1;
// Crear usuario
createUser(name: string): User {
const user = { id: this.nextId++, name };
this.users.push(user);
return user;
}
// Obtener usuario
getUser(id: number): User | undefined {
return this.users.find(u => u.id === id);
}
// Obtener todos los usuarios
getAllUsers(): User[] {
return [...this.users];
}
}
src/services/userService.test.ts
describe("UserService", () => {
let service: UserService;
beforeEach(() => {
service = new UserService();
});
describe("createUser", () => {
it("should create a user with id", () => {
const user = service.createUser("Alice");
expect(user.id).toBe(1);
expect(user.name).toBe("Alice");
});
it("should increment id for each user", () => {
const user1 = service.createUser("Alice");
const user2 = service.createUser("Bob");
expect(user2.id).toBe(user1.id + 1);
});
});
describe("getUser", () => {
it("should return user by id", () => {
const created = service.createUser("Alice");
const found = service.getUser(created.id);
// Usar encadenamiento opcional y toBe
expect(found?.name).toBe("Alice");
});
it("should return undefined for non-existent id", () => {
const found = service.getUser(999);
expect(found).toBeUndefined();
});
});
});
Resultado de ejecución:
UserService
createUser
✓ should create a user with id
✓ should increment id for each user
getUser
✓ should return user by id
✓ should return undefined for non-existent id
Aislamiento de pruebas:Cada caso de prueba debe ser independiente; use beforeEach para asegurar que cada prueba tenga un estado limpio.
Mock
Use mocks para simular dependencias, como APIs externas, bases de datos, etc.
Ejemplo
const mockCallback = jest.fn(x => x * 2);
// Usar la función simulada
[1, 2, 3].forEach(mockCallback);
// Verificar que la función fue llamada 3 veces
expect(mockCallback).toHaveBeenCalledTimes(3);
// Verificar los parámetros con los que se llamó a la función
expect(mockCallback).toHaveBeenCalledWith(2);
// Módulo mock: simular el módulo completo
jest.mock("./api", () => ({
fetchUser: jest.fn(() => Promise.resolve({ id: 1, name: "Alice" }))
}));
Resultado de ejecución:
✓ mock 函数被调用 3 次
Usos de Mock:Cuando el código bajo prueba depende de sistemas externos, usar mocks puede aislar las dependencias y probar solo la lógica del código objetivo.
Notas
- Ubicación de los archivos de prueba:Colocar en el directorio __tests__ o usar el sufijo .test.ts
- Nomenclatura de pruebas:Usar nombres de prueba descriptivos que expliquen el comportamiento esperado
- Pruebas independientes:Cada prueba debe ejecutarse de forma independiente, sin depender de otras pruebas
- Cobertura:Prestar atención a la cobertura de pruebas de la lógica de negocio principal
Mejores prácticas:Las pruebas deben ser rápidas, confiables e independientes entre sí. Siga el principio AAA: Arrange (preparar), Act (ejecutar), Assert (afirmar).
Resumen
Las pruebas unitarias son un medio importante para garantizar la calidad del código TypeScript.
- Jest:El marco de pruebas TypeScript más popular
- describe:Se usa para agrupar pruebas relacionadas
- it/test:Define casos de prueba individuales
- expect:Afirma los resultados de las pruebas
- Mock:Simula dependencias externas
Otras extensionesRecomendaciones:Escriba pruebas para la lógica de negocio crítica, asegurando que los cambios de código no introduzcan errores.