Os testes unitários

O que são?

Os testes unitários são implementados para avaliar uma pequena parte do seu código e devem testar apenas uma funcionalidade específica. Contudo, uma única funcionalidade pode possuir diversos testes unitários. Esses testes utilizam dados fixos e não devem se comunicar com bancos de dados remotos ou servidores.

Abaixo, verifica-se um exemplo de teste unitário em Java utilizando o JUnit 5:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CalculadoraTest {

    @Test
    public void testSoma() {
        Calculadora calc = new Calculadora();
        int resultado = calc.soma(2, 3);
        assertEquals( "A soma de 2 e 3 deve ser 5", 5, resultado);
    }
}

class Calculadora {
    public int soma(int a, int b) {
        return a + b;
    }
}

Neste exemplo, observamos o teste unitário que verifica a soma de dois números:

• O teste (testSoma) verifica se a função soma retorna o resultado correto para 2 + 3.
• O método assertEquals verifica se os valores são correspondentes e possui três parâmetros:
  • O primeiro parâmetro é uma mensagem de erro, sendo este opcional.
  • O segundo parâmetro é o valor esperado, ou seja, o resultado correto que se espera.
  • O terceiro parâmetro é o resultado obtido do teste.

Por que implementar testes?

Implementar testes é fundamental para garantir que as funcionalidades do sistema funcionem corretamente, mesmo diante de entradas inválidas ou cenários inesperados.

Imagine o cenário:

Você está desenvolvendo uma funcionalidade para processar pagamentos em um sistema bancário. O sistema deve aceitar um valor de pagamento, o número da conta do pagador e o número da conta do recebedor, além de garantir que a transação só seja processada se houver saldo suficiente na conta do pagador.

Você desenvolve a função para realizar o pagamento. Inicialmente, tudo funciona bem. No entanto, durante uma atualização no sistema, um desenvolvedor adiciona uma nova funcionalidade para aplicar uma taxa de serviço, mas, sem perceber, ele introduz um erro que permite processar transações mesmo quando o saldo do pagador não é suficiente. Esse bug só é descoberto quando várias transações incorretas são processadas, causando problemas graves, como perda de dinheiro e confiança dos usuários no sistema.

Você implementa testes unitários para a função de processamento de pagamentos, cobrindo cenários como:

1. Pagamento com saldo suficiente — Verifica se a transação é processada corretamente.
2. Pagamento com saldo insuficiente — Verifica se a transação é negada.
3. Pagador e recebedor iguais — Verifica se a transação é recusada.
4. Valor de pagamento inválido (zero ou negativo) — Garante que valores inválidos não sejam processados.

Quando o desenvolvedor adiciona a nova funcionalidade de taxa de serviço, os testes são executados automaticamente, detectando o bug no saldo insuficiente antes que o código vá para produção. Assim, o erro é corrigido sem impactar os usuários.

Assim, os testes unitários oferecem segurança ao garantir que, mesmo após mudanças no código, as funcionalidades críticas continuem funcionando corretamente, minimizando o risco de falhas e erros em cenários inesperados.