Best practice for unit testing_Al Coding Assistant_Intelligent coding assistant - Qoder CN Series: Central de Documentação do Alibaba Cloud

Saiba como escrever testes unitários eficazes usando Qoder CN.

Importante

O novo site de documentação do Qoder CN já está disponível. O conteúdo neste site pode não refletir os recursos e as alterações mais recentes do product. Acesse docs.qoder.cn para consultar a documentação mais atualizada.

O que são testes unitários?

Testes unitários são uma metodologia de teste de software na qual os desenvolvedores escrevem código para verificar a corretude das menores unidades testáveis de uma aplicação, como funções, métodos ou classes. Os desenvolvedores escrevem testes unitários durante ou após a implementação de um recurso, garantindo que cada unidade funcione conforme o esperado pelo design.

Valor dos testes unitários

O valor dos testes unitários se manifesta principalmente na melhoria da qualidade e da confiabilidade do software, assegurando que o código continue funcionando corretamente após modificações ou refatorações. As vantagens dos testes unitários incluem:

Qualidade de código aprimorada: Detecta erros e vulnerabilidades no código, melhorando sua qualidade e confiabilidade.
Maior eficiência no desenvolvimento: Identifica problemas rapidamente durante o desenvolvimento, reduzindo ciclos e custos.
Refatoração e manutenção mais simples: Garante que o código não introduza novos erros e vulnerabilidades durante a refatoração e a manutenção.
Colaboração em equipe aprimorada: Funciona como uma ferramenta de comunicação e colaboração entre os membros da equipe, melhorando a eficiência e a qualidade do trabalho conjunto.

Além disso, os testes unitários permitem detectar falhas de software o quanto antes, evitando perdas causadas pela dificuldade de identificar e corrigir bugs em estágios mais avançados. A viabilidade de regressão dos testes unitários oferece proteção para o software e para refatorações futuras. Os testes unitários também fornecem instruções e exemplos de código que demonstram como utilizar unidades de software.

Princípios a seguir

Testes unitários adequados são imperceptíveis como o ar e devem garantir a qualidade dos testes de software. Do ponto de vista macro, testes unitários adequados precisam ser automáticos (A), independentes (I) e repetíveis (R).

A: Automático: Os testes unitários devem ser executados automaticamente para confirme rapidamente que o código recém-adicionado não quebra funcionalidades existentes quando há alterações. Normalmente, os testes unitários são integrados à integração contínua, acionando-os automaticamente a cada mudança no código.
I: Independente: Cada teste unitário deve ser independente e não depender da ordem de execução ou dos resultados de outros testes. Para garantir a independência de um teste unitário, a menor unidade testável da aplicação deve ser testada isoladamente.
R: Repetível: Bons testes unitários devem produzir os mesmos resultados nas mesmas condições a cada execução. O teste não pode depender de fatores externos, como redes, bancos de dados ou sistemas de arquivos — essas dependências externas devem ser devidamente simuladas (mocked).

Além disso, bons testes unitários devem ter asserções claras, execução rápida, testes de limite abrangentes e alta cobertura. Testes unitários que seguem esses princípios são qualificados e constituem uma parte fundamental da garantia de qualidade do código.

Escrevendo um teste unitário

Esta seção descreve como escrever um teste unitário em Java.

Detalhando os casos de teste

Consider branches

Ao escrever um teste unitário, considere todos os branches do seu código. Os branches incluem as instruções IF, IF ELSE e SWITCH. Cada branch deve ser testado separadamente. Por exemplo:

public String classifyNumber(int number) {
    if (number < 0) {
        return "negative";
    } else if (number == 0) {
        return "zero";
    } else {
        return "positive";
    }
}

No código anterior, os seguintes branches devem ser testados:

number < 0.
number == 0.
number > 0.

Escreva um caso de teste para cada branch.

Find boundary conditions

Além dos branches, considere também as condições de limite. Por exemplo, para as funções de classificação anteriores, os valores de limite são -1, 0 e 1. Os testes de condições de limite identificam problemas potenciais e garantem que o código funcione corretamente em condições extremas.

Estabelecendo padrões de teste unificados

Naming conventions

Uma classe de teste unitário recebe o nome no seguinte formato: Class name + Test. Por exemplo, para testar uma classe Calculator, a classe de teste unitário é nomeada CalculatorTest. O nome de um método de teste unitário deve descrever o conteúdo específico a ser testado. Por exemplo:

public class CalculatorTest {
    @Test
    public void testAddition() {
        // The content to be tested.
    }
    @Test
    public void testSubtraction() {
        // The content to be tested.
    }
}

Storage path

Em geral, uma classe de teste unitário é armazenada no mesmo nome de pacote que a classe a ser testada, mas em um diretório diferente. Por exemplo, na estrutura padrão de um projeto Maven, o código-fonte fica no diretório src/main/java, e o código de testes unitários, no diretório src/test/java.

src/main/java/com/example/Calculator.java
src/test/java/com/example/CalculatorTest.java

Escolhendo o framework de teste adequado

JUnit e Mockito são frameworks de teste unitário comuns em Java. Esta seção descreve como usar esses dois frameworks para escrever um teste unitário básico:

Junit

JUnit é o framework de teste unitário mais famoso em Java. É conciso, fácil de usar e oferece anotações e asserções abrangentes.

Adicione JUnit como dependência. Neste exemplo, usa-se uma dependência Maven.

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.13.2</version>
  <scope>test</scope>
</dependency>

Escreva um teste unitário:

import org.junit.Test;
import static org.junit.Assert.*;

public class CalculatorTest {
    @Test
    public void testAddition() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3));
    }
}

Mockito

Mockito é um poderoso framework de mocking que permite criar objetos simulados e simplificar os testes unitários, especialmente quando as dependências de teste não são fáceis de instanciar.

Adicione Mockito como dependência:

<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-core</artifactId>
  <version>3.11.2</version>
  <scope>test</scope>
</dependency>

Escreva um teste unitário:

import static org.mockito.Mockito.*;
import org.junit.Test;

public class UserServiceTest {
    @Test
    public void testGetUser() {
        UserService userService = new UserService();
        UserRepository mockRepo = mock(UserRepository.class);

        when(mockRepo.findUserById(1)).thenReturn(new User(1, "John Doe"));
        userService.setUserRepository(mockRepo);

        User user = userService.getUserById(1);
        assertNotNull(user);
        assertEquals("John Doe", user.getName());
    }
}

Como gerar testes unitários rapidamente com Qoder CN

A maioria dos desenvolvedores adota o desenvolvimento test-later com base em seus hábitos de programação, ou seja, escrevem o código primeiro e os testes unitários depois. Nesse contexto, usar Qoder CN para gerar testes unitários é especialmente conveniente. A seguir, são apresentadas algumas formas de gerar testes unitários usando Qoder CN.

Gerar um teste unitário selecionando código

No editor da IDE, selecione um trecho de código e use /unittest para gerar um teste unitário correspondente ao código selecionado.

Nota

Ao usar o comando /unit test, adicione contexto na caixa de chat para gerar casos de teste que atendam melhor às necessidades do desenvolvedor. Por exemplo, se precisar de suporte ao JUnit5 ou usar Mockito para mocking, utilize /unit test JUnit5 Mockito. As duas palavras-chave após o comando são parâmetros do comando anterior. Esse método também se aplica a outros comandos.

Gerar um teste unitário usando botões de atalho

Clique em o ícone do Qoder CN acima de cada assinatura de método e selecione UnitTest no menu suspenso.

Você também pode selecionar um bloco de código para gerar um teste unitário. Clique com o botão direito no bloco de código selecionado e escolha Qoder CN > Unit Test.

Aplicar o teste unitário

Após a geração do código de teste unitário, três ícones ficam disponíveis no canto superior direito do bloco de código no painel AI Chat:

Insert Code: insira o código de teste unitário gerado no arquivo atualmente aberto.
Copy: copia o código de teste unitário gerado no bloco de código e permite selecionar o arquivo para colar o código.
Create File: crie um arquivo de classe de teste unitário com base nos princípios de testes unitários em Java, no diretório de testes onde os métodos de teste são armazenados. Se já existir um arquivo de classe de teste com o mesmo nome, você precisará decidir se deseja substituir o arquivo existente.

Fazer perguntas sobre o teste unitário gerado

Se não estiver satisfeito com o código de teste unitário gerado, ou se precisar usar um framework específico ou gerar mais métodos de teste, insira suas perguntas na caixa de chat ou clique nas tags de perguntas pré-definidas, como Retry, Use Mockito, Use Spring Test e Explain code, e continue fazendo perguntas até ficar satisfeito com o código gerado.

Nota

Na maioria dos casos, Qoder CN gerará casos de teste comuns, mas não cobrirá todos os cenários possíveis. Se considerar que os casos de teste gerados são insuficientes, recomenda-se: 1. Primeiro, aceite os casos de teste gerados e adicione-os ao seu arquivo de testes. 2. Em seguida, alterne para o arquivo de testes e use o recurso de completar código. Qoder CN ajudará você a continuar escrevendo novos casos de teste.

Resumo

Os testes unitários são uma prática de programação essencial para garantir a qualidade do código. A abordagem test-first no desenvolvimento orientado a testes (TDD) promove significativamente um design de código melhor por meio de iterações. Qoder CN contribui reduzindo a carga de configuração de frameworks de teste unitário e de escrita de casos de teste, além de manter os casos de teste atualizados ao sugerir cenários adicionais e adaptar os testes às mudanças no código.