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

Cover of the article “Boosting dev productivity: How to write complete unit tests faster with a contextualized AI tool”. A white person stands in front of a laptop with their hands under the keyboard. Codes are on the laptop screen.
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?

Antes de tudo, 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.

Por isso, 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. Pois 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.

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:

Imagem do artigo sobre testes unitários com a opção de MessageTest.java selecionada.

Quando eu executo os testes utilizando Pitest para validar 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.

Imagem do artigo sobre testes unitários com 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.
Imagem do artigo sobre testes unitários com 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:

Imagem do artigo sobre testes unitários com 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. Dessa forma, você tem a opção de adicionar essa classe inteira no seu projeto ou inserir apenas o código na classe já existente.

Imagem do artigo sobre testes unitários com 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, assim 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.

Imagem do artigo sobre testes unitários com 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.
Imagem do artigo sobre testes unitários com 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, então 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”:

Imagem do artigo sobre testes unitários com 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:

Imagem do artigo sobre testes unitários com 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

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

Imagem do artigo sobre testes unitários com 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.
Imagem do artigo sobre testes unitários com 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

Portanto, 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. 

Assim, 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

Related posts