No desenvolvimento de software, o teste de unidade é uma prática crucial que ajuda a garantir a correção do seu código.

O Capítulo 9 de Código Limpo: Um Manual de Artesanato de Software Ágil, intitulado "Testes de Unidade", se aprofunda nos princípios e práticas para escrever testes de unidade limpos e eficazes.

Neste artigo, resumiremos as principais conclusões do capítulo e forneceremos exemplos de JavaScript para ilustrar esses conceitos.

? Por que os testes unitários são importantes

O teste de unidade envolve escrever testes para unidades ou componentes individuais do seu código para verificar se eles funcionam conforme o esperado. Os principais objetivos dos testes unitários são:

1- Detectar bugs antecipadamente: Detecte problemas durante o desenvolvimento antes que eles cheguem à produção.

2- Facilite a refatoração: Certifique-se de que as alterações em seu código não interrompam a funcionalidade existente.

3- Comportamento do código do documento: Serve como documentação de como seu código deve ser usado.

? Princípios de testes unitários eficazes

⚡ Teste uma coisa de cada vez

Cada teste de unidade deve focar em um único aspecto da funcionalidade. Isso torna os testes mais fáceis de entender e manter. Se um teste falhar, você saberá exatamente onde está o problema.

function add(a, b) {
    return a   b;
}

// Test case for the add function
function testAdd() {
    // Test adding positive numbers
    assertEqual(add(2, 3), 5, '2   3 should be 5');
    // Test adding negative numbers
    assertEqual(add(-1, -1), -2, '-1   -1 should be -2');
}

// A simple assertion function
function assertEqual(actual, expected, message) {
    if (actual !== expected) {
        throw new Error(message);
    }
}

⚡ Torne os testes legíveis

Seus testes devem ser fáceis de ler e entender. Use nomes descritivos para suas funções de teste e afirmações claras. Isso ajuda outras pessoas (e você mesmo) a entender rapidamente o que cada teste está verificando.

function isEven(number) {
    return number % 2 === 0;
}

// Descriptive test function
function testIsEven() {
    assertEqual(isEven(4), true, '4 should be even');
    assertEqual(isEven(5), false, '5 should be odd');
}

⚡ Use nomes claros e descritivos

Os nomes dos casos de teste devem descrever o que eles estão testando. Isso melhora a legibilidade e a capacidade de manutenção de seus testes.

function calculateTotalPrice(items) {
    return items.reduce((total, item) => total   item.price, 0);
}

// Descriptive test case names
function testCalculateTotalPrice() {
    assertEqual(calculateTotalPrice([{ price: 10 }, { price: 20 }]), 30, 'Total price should be 30 for items costing 10 and 20');
    assertEqual(calculateTotalPrice([{ price: 5 }]), 5, 'Total price should be 5 for a single item costing 5');
}

⚡ Mantenha os testes independentes

Cada teste deve ser independente dos outros. Testes que dependem de estado compartilhado podem levar a testes instáveis ​​e dificultar a depuração.

function multiply(a, b) {
    return a * b;
}

// Independent test cases
function testMultiply() {
    assertEqual(multiply(2, 3), 6, '2 * 3 should be 6');
    assertEqual(multiply(0, 10), 0, '0 * 10 should be 0');
}

⚡ Use simulações e stubs adequadamente

Mocks e stubs podem ajudar a isolar a unidade de código em teste, simulando dependências. No entanto, use-os criteriosamente para evitar complicar demais os testes.

// Example of using a mock for a database call
function getUser(id) {
    // Imagine this function makes a database call
    return database.getUserById(id);
}

function testGetUser() {
    const mockDatabase = {
        getUserById: (id) => ({ id, name: 'John Doe' }),
    };

    const result = getUser(1, mockDatabase);
    assertEqual(result.name, 'John Doe', 'User name should be John Doe');
}

⚡ Testes automatizados

Automatize a execução de seus testes de unidade para garantir que eles sejam executados regularmente. As ferramentas de integração contínua (CI) podem ajudar a executar seus testes automaticamente sempre que alterações forem feitas.

Se estiver usando uma estrutura de teste como Jest, você pode configurar um script em seu package.json:

"scripts": {
    "test": "jest"
}

A execução do teste npm executará todos os seus testes e fornecerá feedback sobre seu status.

Conclusão

Escrever testes de unidade limpos e eficazes é essencial para manter um código de alta qualidade.

Seguindo os princípios descritos no Capítulo 9 do Código Limpo, você pode garantir que seus testes sejam confiáveis, compreensíveis e valiosos.

Implementar essas práticas em seu código JavaScript não apenas melhorará a qualidade de seus testes, mas também contribuirá para uma base de código mais robusta e sustentável.

Boa codificação!