Há diversas tarefas que são muito importantes para a qualidade final do código produzido, mas são tediosas e muitas vezes até negligenciadas. Uma dessas ações é escrever testes unitários.

Geralmente, os testes unitários são feitos por pessoas desenvolvedoras com supervisão de profissionais de Quality Assurance (QAs). Porém, às vezes no ciclo de desenvolvimento de software, devs podem acabar fazendo somente o básico dos testes para acelerar o delivery. Com a StackSpot, devs conseguem gerar testes unitários mais completos e com uma redução da carga cognitiva considerável.

O objetivo deste artigo é apresentar as principais características e vantagens da StackSpot  AI para gerar testes unitários, bem como mostrar um exemplo prático de como utilizá-la em um projeto Java.

O que são testes unitários?

Os testes unitários são uma forma de verificar se o código de um programa está funcionando corretamente, isolando as unidades lógicas e testando seus comportamentos. Eles são essenciais para garantir a qualidade e a confiabilidade do software, além de facilitar a manutenção e a refatoração do código.

Saiba mais sobre teste unitário e tipos de teste.

No entanto, escrever testes unitários pode ser uma tarefa tediosa e demorada, e na maior parte do tempo é  negligenciada ou adiada. Por isso, é necessário encontrar  ferramentas que possam automatizar e simplificar esse processo, gerando testes unitários a partir do código-fonte ou de especificações.

Uma dessas ferramentas é a StackSpot AI. 

O que é a StackSpot AI?

A StackSpot AI é uma solução de inteligência artificial generativa que ajuda a otimizar a utilização contextualizada de modelos de linguagem grandes (LLM) para gerar código de alta qualidade e assertividade. É um assistente de código que usa seu contexto, fontes de conhecimento e decisões tecnológicas sobre padrões para produzir código de alta qualidade e assertividade.

A StackSpot AI se diferencia de outras soluções de IA por ser altamente personalizável e adaptável às necessidades de cada empresa. Além disso, permite a criação de comandos rápidos para automatizar tarefas repetitivas.

No nosso caso, a StackSpot AI permite gerar testes unitários para diferentes linguagens de programação, como Java, Python, C#, Ruby e JavaScript. Usa técnicas de aprendizado de máquina e análise estática para inferir as propriedades e os requisitos do código, além de gerar casos de teste que cobrem todos os cenários possíveis.

Para usar a StackSpot AI, basta acessar o site, realizar o login na ferramenta de AI e baixar a extensão para IDE, no Visual Studio Code ou IntelliJ.

Abaixo, segue o exemplo do plugin instalado no Visual Studio Code:

Após a instalação, é só logar com os mesmos dados de login na ferramenta de AI.

Gerando os testes unitários na StackSpot AI

Agora vamos mostrar de uma forma prática como a StackSpot AI pode te ajudar a gerar os testes unitários.

Confira dois exemplos, o primeiro complementando testes já existentes melhorando a cobertura, e outro vamos criar uma classe de teste do zero. 

Testes unitários na StackSpot AI – Exemplo nº 1

Tenho um projeto que possui testes para apenas a classe Message.java:

Quando eu executo os testes utilizando Pitest para validar a o teste classe Message.java, confira:

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

Classe:Message.java

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);
   }


}

Classe: Messagetest.java

Após a execução dos testes utilizando o Pitest, ao verificar o relatório, podemos notar que a classe Message.java tem 100% de cobertura, porém, a qualidade dos testes está em 60%. Isso indica que podemos adicionar mais cenários para cobrir todas as possibilidades. Saiba mais sobre testes de mutação.

Agora vamos utilizar a StackSpot AI para gerar os testes e garantir 100% de cobertura de mutação.

Dentro da classe Message.java, selecione o código, clique com o botão direito e no menu exibido e selecione “StackSpot AI > Add tests for this code”. Confira a imagem abaixo:

A StackSpot AI processa a informação e gera uma classe com todos os testes e uma breve explicação sobre o código. Você tem a opção de adicionar essa classe inteira no seu projeto ou inserir apenas o código na classe já existente.

Nesse exemplo, os testes existentes foram substituídos,  escolhemos os gerados pela  StackSpot AI. A classe MessageTest.java ficou assim:

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");
   }


}

Classe: MessageTest.java

Após a execução dos testes gerados pela StackSpot  AI e verificando o relatório do Pitest, podemos notar que todos os cenários de teste da classe Message.java foram cobertos.

Testes unitários na StackSpot AI – Exemplo nº 2

O mesmo procedimento será aplicado para a classe Calc.java, vamos criar a classe de teste inteira pela StackSpot  AI.

Primeiro selecionamos o código da classe, clicando com o botão direito do mouse e selecionando no menu “StackSpot AI > Add tests for this code”:

Após alguns segundos a StackSpot AI gera a classe de teste com todos os cenários e a explicação do código. Confira:

A StackSpot AI gerou e a classe CalcTest.java que ficou 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));
   }
}

Classe: Calctest.java

Os testes foram executados novamente e o relatório mostra que todos os cenários atenderam a cobertura de código e mutação.

Acompanhe o passo a passo para criar testes unitários no vídeo da StackSpot Demos.

Conclusão

A StackSpot AI é uma ferramenta poderosa e inovadora que pode ajudar pessoas desenvolvedoras a economizar tempo e recursos, além de aumentar a confiança e a segurança no seu código. 

Com a StackSpot AI, os testes unitários são gerados de uma forma mais rápida e com qualidade, diminuindo a carga cognitiva do time.

Quer saber mais como usar a StackSpot no desenvolvimento de software e ganhar eficiência? Então siga as postagens na nossa categoria “Tutoriais” aqui no blog!

Ficou com alguma dúvida ou tem sugestões? Então deixe seu comentário.

Referências

• Diferença entre fases de teste, tipos de teste e formas de execução – Blog Zup Innovation
• Getting Started | Docs AI – StackSpot AI Documentation
• StackSpot AI – Site oficial
• Teste de mutação: conceito, funcionamento e desafios para implementação – Blog Zup Innovation