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 Fondo Título Flujo de pruebas unitarias de TypeScript Código fuente Código fuente src/utils/calculator.ts src/services/userService.ts Anotaciones de tipos completas Flecha Código de prueba Código de prueba *.test.ts describe() / it() Aserción expect() Flecha Resultado de la prueba Resultado de la prueba ✓ Aprobado / ✗ Fallido Informe de cobertura Seguimiento de la pila de errores Parte inferior: principios de prueba Principios de las pruebas unitarias Principio 1 Cada prueba verifica solo una cosa Principio 2 Estructura Arrange-Act-Assert Principio 3 Las pruebas deben ser independientes entre sí Marcador de flecha

¿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

# Instalar Jest y dependencias relacionadas
# - 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

module.exports = {
    // 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

// Clase calculadora
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

import { Calculator } from "./calculator";

// 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

// Tipo de usuario
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

import { UserService } from "./userService";

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

// Función mock: crear una función simulada
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

Recomendaciones:Escriba pruebas para la lógica de negocio crítica, asegurando que los cambios de código no introduzcan errores.

Otras extensiones