Pular para o conteúdo principal

Testes Unitários

Os testes unitários garantem que o código de um programa funcione corretamente ao testar partes individuais. Eles são cruciais para manter a qualidade do software e facilitar a manutenção do código. No entanto, escrever testes unitários pode ser demorado, por isso automatizar o processo é essencial.

Gerar Teste Unitário: Exemplo 1

Este exemplo demonstra um projeto com testes para a classe Message.java. Ao executar os testes usando Pitest para validar a classe Message.java, os resultados são os seguintes:

public class Message {
   public String message(int a) {
       String result;
       if (a >= 0 && a <= 10) {
           result = "YES";
       } else {
           result = "NO";
       }
       return result;
   }
}

public class MessageTest {

   @Test
   public void messageOk1() {
       Message message = new Message();
       String result = message.message(5);
       assertEquals("YES", result);
   }

   @Test
   public void messageOk2() {
       Message message = new Message();
       String result = message.message(-5);
       assertEquals("NO", result);
   }
}

Após executar o Pitest, o relatório mostra que a classe Message.java possui 100% de cobertura de linhas, mas apenas 60% de cobertura de mutação. Isso indica que cenários adicionais devem ser adicionados para cobrir todas as possibilidades.

Relatório do Pitest mostrando a cobertura de linhas e mutações das classes Calc.java e Message.java. A classe Calc.java possui 0% de cobertura de linhas e mutações. A classe Message.java possui 100% de cobertura de linhas e 60% de cobertura de mutações.

Relatório do Pitest da classe Message.java indicando que o teste de análise de limite está faltando na linha 6 do código.

Passos para usar a StackSpot AI para gerar testes e garantir 100% na cobertura de mutação

  1. Dentro da classe Message.java, selecione o código, clique com o botão direito para abrir o menu e selecione "StackSpot AI > Adicionar testes para este código."

  2. A StackSpot AI processa as informações e gera uma classe contendo todos os testes e uma breve explicação do código. Você pode adicionar essa classe ao seu projeto ou inserir o código em uma classe existente.

As informações geradas pela StackSpot AI exibem uma classe de teste com todos os métodos de teste gerados pela AI. Depois da classe, há uma breve explicação do código gerado.

  1. Neste exemplo, os testes existentes foram substituídos pelos gerados pela StackSpot AI. O layout da classe MessageTest.java aparece da seguinte forma:
public class MessageTest {

   @Test
   public void testMessageWithNumberInRange() {
       Message message = new Message();
       assertEquals("YES", message.message(5), "The message should be YES for numbers in range 0-10");
   }

   @Test
   public void testMessageWithNumberOutOfRangePositive() {
       Message message = new Message();
       assertEquals("NO", message.message(11), "The message should be NO for numbers greater than 10");
   }

   @Test
   public void testMessageWithNumberOutOfRangeNegative() {
       Message message = new Message();
       assertEquals("NO", message.message(-1), "The message should be NO for negative numbers");
   }

   @Test
   public void testMessageWithBoundaryNumberZero() {
       Message message = new Message();
       assertEquals("YES", message.message(0), "The message should be YES for the boundary number 0");
   }

   @Test
   public void testMessageWithBoundaryNumberTen() {
       Message message = new Message();
       assertEquals("YES", message.message(10), "The message should be YES for the boundary number 10");
   }
}

Após executar os testes gerados pela StackSpot AI e verificar o relatório do Pitest, você pode verificar que todos os cenários de teste para a classe Message.java foram cobertos.

O relatório do pitest mostra a cobertura de linha e mutação das classes Calc.java e Message.java. A classe Calc.java tem 0% de cobertura de linha e mutação, enquanto a classe Message.java tem 100% de cobertura de linha e 100% de cobertura de mutação.

Relatório do Pitest da Message.java

Exemplo 2

  1. Abra um projeto, neste exemplo, a classe Calc.java.

  2. Clique com o botão direito para selecionar o código da classe e escolha "StackSpot AI > Adicionar testes para este código" no menu.

Menu da StackSpot AI exibido sobre o código selecionado

  1. Após alguns segundos, a StackSpot AI gera a classe de teste com todos os cenários e explicações do código.

Informações geradas pela StackSpot AI, mostrando parte de uma classe de teste com métodos de teste gerados pela AI.

  1. A StackSpot AI gera a classe Calc.java, que ficará assim:
class CalcTest {

   @Test
   void testSomaWithValidNumbers() {
       assertEquals(5, Calc.soma(2, 3));
   }

   @Test
   void testSomaWithNulls() {
       assertNull(Calc.soma(null, 3));
       assertNull(Calc.soma(2, null));
       assertNull(Calc.soma(null, null));
   }

   @Test
   void testSubtraiWithValidNumbers() {
       assertEquals(1, Calc.subtrai(4, 3));
   }

   @Test
   void testSubtraiWithNulls() {
       assertNull(Calc.subtrai(null, 3));
       assertNull(Calc.subtrai(4, null));
       assertNull(Calc.subtrai(null, null));
   }

   @Test
   void testMultiplicaWithValidNumbers() {
       assertEquals(12, Calc.multiplica(4, 3));
   }

   @Test
   void testMultiplicaWithNulls() {
       assertNull(Calc.multiplica(null, 3));
       assertNull(Calc.multiplica(4, null));
       assertNull(Calc.multiplica(null, null));
   }

   @Test
   void testDivideWithValidNumbers() {
       assertEquals(2, Calc.divide(6, 3));
   }

   @Test
   void testDivideByZero() {
       assertNull(Calc.divide(6, 0));
   }

   @Test
   void testDivideWithNulls() {
       assertNull(Calc.divide(null, 3));
       assertNull(Calc.divide(6, null));
       assertNull(Calc.divide(null, null));
   }
}
  1. Reexecute os testes. O relatório indica que todos os cenários alcançaram cobertura de código e mutação.

Este é um relatório do pitest mostrando a cobertura de linha e mutação das classes Calc.java e Message.java. A classe Calc.java tem 100% de cobertura de linha e mutação, e a classe Message.java tem 100% de cobertura de linha e mutação.

Seguindo esses passos, você pode usar efetivamente a StackSpot AI para gerar testes unitários abrangentes, garantindo que seu código atinja alta cobertura e qualidade.

Vídeo & Blog