Aumentando a produtividade de devs: Como escrever testes unitários completos mais rápido com uma ferramenta de AI contextualizada

Uma pessoa branca está em frente do laptop com as mãos sob o teclado. Códigos estão na tela do laptop.
Este artigo mostra como a StackSpot AI pode ser utilizada para gerar testes unitários mais completos para um projeto Java, com exemplos práticos.

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:

Tela da IDE Visual Studio Code, com o plugin da StackSpot AI instalado e exibindo a área de login da StackSpot AI dentro da IDE

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

Consuma inovação,
comece a transformação

Assine nosso boletim informativo para se manter atualizado sobre as práticas recomendadas mais recentes para aproveitar a tecnologia para gerar impacto nos negócios

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.

Relatório do Pitest exibindo a cobertura de linha e mutação das classes Clalc.java e Message.java. A classe Calc.java possui 0% de cobertura de linha e mutação. A classe Message.java possui 100% de cobertura de linha e 60% de cobertura de mutação.
Relatório do Pitest da classe Message.java indicando que na linha 6 do código falta adicionar o teste de análise de limites.

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:

Menu da StackSpot AI exibido sobre o código selecionado

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.

Informação gerada pela StackSpot AI, exibindo uma classe de teste com todos os métodos de teste gerados pela IA, abaixo da classe uma breve explicação do código gerado.

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.

Relatório do Pitest exibindo a cobertura de linha e mutação das classes Clalc.java e Message.java. A classe Calc.java possui 0% de cobertura de linha e mutação. A classe Message.java possui 100% de cobertura de linha e 100% de cobertura de mutação.
Relatório do Pitest da classe Message.java indicando 100% de cobertura de linha e todas as condições de mutação.

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”:

Menu da StackSpot AI exibido sobre o código selecionado

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:

Informação gerada pela StackSpot AI, exibindo parte de uma classe de teste com  os métodos de teste gerados pela IA.

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.

Relatório do Pitest exibindo a cobertura de linha e mutação das classes Clalc.java e Message.java. A classe Calc.java possui 100% de cobertura de linha e mutação. A classe Message.java possui 100% de cobertura de linha e mutação.
Relatório do Pitest da classe Calc.java indicando 100% de cobertura de linha e todas as condições de 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

Consuma inovação,
comece a transformação

Assine nosso boletim informativo para se manter atualizado sobre as práticas recomendadas mais recentes para aproveitar a tecnologia para gerar impacto nos negócios

Summary

Related posts

*Material em Inglês

Baixe grátis o eBook
e descubra caminhos para evoluir sua empresa