É importante escrever testes unitários claros e eficientes que funcionam realmente durante o processo de desenvolvimento de software. Testes unitários separam os elementos de código individuais e confirmam que funcionam conforme planejado.

Testes unitários eficazes não apenas capturam erros, mas também ajudam você a ter confiança que seu código pode ser mantido e é confiável. Mas leva tempo e recursos para criar manualmente um conjunto extensivo de testes unitários.

Houve algumas recentes evoluções na inteligência artificial que prometem auxiliar a automatizar os processos de desenvolvimento de testes unitários. Em fevereiro, investigadores da Meta divulgaram um documento sobre Aperfeiçoamento Automático de Testes Unitários usando Modelos de Linguagem Grande. Este documento apresentou um método inovador para automatizar os testes unitários.

Seu trabalho se concentra em uma ferramenta chamada TestGen-LLM, que explora as possibilidades de usar modelos de linguagem livre (LLM) para analisar testes unitários já existentes e melhorá-los para aumentar a cobertura do código.

Embora o código do TestGen-LLM não tenha sido lançado, eu vou apresentar uma alternativa de código aberto inspirada em seu trabalho neste artigo. Vai aprender como ela gera suítes de teste, por que é melhor que a maioria dos LLM e onde conseguir suas mãos nesta tecnologia e começar a testá-la.

Tabela de Conteúdos

Meta’s TestGen-LLM

O Meta’s TestGen-LLM aborda a tarefa tempo-consumidora de escrita de testes unitários, aproveitando o poder de Modelos de Linguagem Larga (LLMs). Modelos LLMs de propósito geral, como Gemini ou ChatGPT, podem ter dificuldade com o domínio específico de código de teste unitário, sintaxe de teste e geração de testes que não adicionam valor. Mas o TestGen-LLM é especificamente feito para testes unitários.

Essa especialização permite que ele entenda as complexidades da estrutura de código e lógica de teste, levando a suite de testes mais focada e gerar testes que atualmente adicionam valor e aumentam a cobertura de código.

O TestGen-LLM é capaz de avaliar testes unitários e identificar áreas para melhoria. Ele consegue isso através de seu entendimento de padrões de teste comuns, com os quais foi treinado. Mas a geração de testes por si só é insuficiente para a cobertura de código apropriada.

Pesquisadores da Meta implementaram salvaguardas no TestGen-LLM para garantir a eficácia dos testes que ele escreve. Essas salvaguardas, chamadas de filters, atuam como um mecanismo de controle de qualidade. Elas eliminam sugestões que:

  • não compilariam

  • falhariam consistentemente, ou

  • não melhorariam realmente a cobertura de código (sugestões que já estão cobertas por outros testes).

Como funciona o TestGen-LLM?

O TestGen-LLM utiliza uma abordagem chamada “Engenharia de Software baseada em LLM Assurada” (Assured LLMSE). O TestGen-LLM simplesmente acrescenta casos de teste adicionais a uma classe de teste existente, mantendo todos os casos de teste existentes e garantindo assim que não haverá nenhuma regressão.

Fluxo de geração de testes(Do artigo de TestGen_LLM)

O TestGen-LLM gera um conjunto de testes, depois filtra os testes que não executam e descarta qualquer que não passe. Finalmente, descarta aqueles que não aumentam a cobertura de código.

Após usar o TestGen-LLM para automatizar um conjunto de testes, a Meta usou um revisor humano para aceitar ou rejeitar testes onde os testes gerados tinham uma taxa de aprovação de 73% em seus melhores casos relatados.

De acordo com o artigo, o TestGen-LLM gera um único teste em cada execução, que é então adicionado a um conjunto de testes existente que foi escrito anteriormente por um desenvolvedor. Mas ele não gera necessariamente testes para qualquer conjunto de testes dado.

A eficácia do TestGen-LLM foi demonstrada em test-a-thons internos da Meta. Aqui, a ferramenta foi usada para analisar conjuntos de testes existentes e sugerir melhorias. Os resultados foram promissores:

“75% dos casos de teste do TestGen-LLM foram construídos corretamente, 57% passaram com confiabilidade e 25% aumentaram a cobertura. Durante os test-a-thons de Instagram e Facebook da Meta, ela melhorou 11,5% de todas as classes para as quais foi aplicada, com 73% das sugestões de recomendações sendo aceitas para implantação em produção por engenheiros de software da Meta”.

Também, as recomendações do TestGen-LLM foram consideradas úteis e relevantes pelos desenvolvedores que participaram dos test-a-thons.

Implementação de Código Aberto (Cover-Agent)

A pesquisa do TestGen-LLM da Meta tem muito potencial para mudar a testação unitária e a geração automática de testes. A ferramenta provavelmente ajudará a melhorar a cobertura de código e a acelerar a criação de testes, utilizando LLMs particularmente treinadas em código. Mas essa tecnologia não está disponível para qualquer pessoa, já que o código do TestGen-LLM não foi lançado.

Desenvolvedores que se interessaram por essa tecnologia provavelmente estão frustrados pela falta de código disponível publicamente. Afinal, o estudo do TestGen-LLM da Meta fornece uma visão do futuro de que a testação automatizada pode ser.

É muito atraente ser capaz de mergulhar nas funcionalidades internas da mais nova tecnologia, entender os processos de tomada de decisão e talvez até mesmo ajudar a moldar seu desenvolvimento. Mas enquanto a falta do código da Meta é um impedimento, existe uma implementação de código aberto chamada Cover-Agent que pode servir como uma alternativa útil.

CodiumAI's Cover-Agent é a primeira implementação de código aberto de uma ferramenta de testação automatizada baseada no TestGen-LLM. Inspirado pela pesquisa da Meta, o Cover-Agent está agora no centro dos desenvolvimentos na área de testes unitários de IA aberta como resultado.

Por que é necessário especificamente LLMs centrados em testes?

Já que a maioria dos LLMs (como ChatGPT e Gemini) é capaz de gerar testes, então por que ter um novo tipo de tecnologia?

Bem, o Cover-Agent e o TestGen-LLM foram criados para ser o próximo passo na evolução da eficiência em testes unitários. Seu objetivo é evitar ospiores buracos que os desenvolvedores se encontram quando gerando testes com LLMs, como:

  • Falha de Ilusão do LLM

  • Gerando testes que não adicionam valor

  • Gerando testes que omitem partes do código, resultando em baixo coveragem de código

Para superar tais desafios (especificamente para testes de unidade de regressão) os investigadores do TestGen-LLM propuseram os seguintes critérios que os testes gerados devem atender antes de serem aceitos:

  • O teste gerado compila e executa corretamente?

  • O teste aumenta a cobertura de código?

  • Adiciona valor?

  • Confere com quaisquer outros requisitos que possamos ter?

Estas são questões e problemas fundamentais que o teste gerado deve resolver antes de serem considerados uma melhoria na tecnologia existente. O Cover-Agent fornece testes que respondem a essas questões com um grau de eficiência impressionante.

Como o Cover-AgentFunciona?

O Cover-Agent faz parte de uma suite de ferramentas mais ampla projetada para automatizar a criação de testes de unidade para projetos de software. Utilizando o modelo de IA de geração TestGen-LLM, visa simplificar e acelerar o processo de teste, garantindo o desenvolvimento de software de alta qualidade.

O sistema é composto por vários componentes:

  • Test Runner: Executa o comando ou scripts para executar o conjunto de testes e gerar relatórios de cobertura de código.

  • Coverage Parser: Valida que a cobertura de código aumenta conforme são adicionados testes, garantindo que novos testes contribuem para a eficácia global dos testes.

  • Prompt Builder: Coleta dados necessários do código-fonte e constrói o prompt a ser passado para o Modelo de Linguagem de Largura (LLM).

  • AI Caller: Interage com o LLM para gerar testes com base no prompt fornecido.

Esses componentes trabalham juntos com o TestGen-LLM para gerar apenas testes que garantem melhorias na base de código existente.

Como usar o Cover-Agente

Requisitos

Você precisa ter os seguintes requisitos antes de começar a usar o Cover-Agente:

  • OPENAI_API_KEY definido em suas variáveis de ambiente, o qual é necessário para chamar a API OpenAI.

  • Ferramenta de Cobertura de Código: Uma relação de cobertura de código em XML de Cobertura é necessária para que a ferramenta funcione corretamente. Por exemplo, em Python, você pode usar pytest-cov. Adicione a opção --cov-report=xml quando executar o Pytest.

Instalação

Se você estiver executando o Cover-Agente diretamente do repositório, você também precisará:

  • Python instalado no seu sistema.

  • Poetry instalado para gerenciar as dependências de pacotes Python. Você pode encontrar as instruções de instalação de Poetry aqui.

Execução independente

Você pode instalar o Cover-Agent como um pacote Python Pip ou executá-lo como um executável independente.

Pacote Python Pip

Para instalar o pacote Python Pip diretamente via GitHub, execute o seguinte comando:

pip install git+https://github.com/Codium-ai/cover-agent.git

Binário

Você pode executar o binário sem qualquer ambiente Python instalado no seu sistema (por exemplo, dentro de um contêiner Docker que não contém o Python). Você pode baixar a versão para seu sistema visitando a página de lançamentos do projeto.

Configuração do Repositório

Execute o seguinte comando para instalar todas as dependências e executar o projeto a partir das fontes:

poetry install

Executando o Código

Após baixar o executável ou instalar o pacote Pip, você agora pode executar o Cover-Agent para gerar e validar testes unitários.

Execute-o pela linha de comando usando o seguinte comando:

cover-agent \
--source-file-path "path_to_source_file" \
--test-file-path "path_to_test_file" \
--code-coverage-report-path "path_to_coverage_report.xml" \
--test-command "test_command_to_run" \
--test-command-dir "directory_to_run_test_command/" \
--coverage-type "type_of_coverage_report" \
--desired-coverage "desired_coverage_between_0_and_100" \
--max-iterations "max_number_of_llm_iterations" \
 --included-files "<optional_list_of_files_to_include>"

Você pode usar os projetos de exemplo neste repositório para executar este código como um teste.

Argumentos de Comando

  • source-file-path: Caminho do arquivo que contém as funções ou bloco de código que queremos testar.

  • test-file-path: Caminho do arquivo onde os testes serão escritos pelo agente. É melhor criar um esqueleto deste arquivo com pelo menos um teste e as declarações de importação necessárias.

  • caminho-do-relatório-de-cobertura-de-código: Caminho onde o relatório de cobertura de código é salvo.

  • comando-de-teste: Comando para executar os testes (por exemplo, pytest).

  • diretório-do-comando-de-teste: Diretório onde o comando de teste deve ser executado. Defina isso na raiz ou na localização do seu arquivo principal para evitar problemas com importações relativas.

  • tipo-de-cobertura: Tipo de cobertura a ser usado. Cobertura é um bom padrão.

  • cobertura-desejada: Meta de cobertura. Maior é melhor, embora 100% muitas vezes seja impraticável.

  • max-iterações: Número de vezes que o agente deve tentar novamente gerar código de teste. Mais iterações podem resultar em maior uso de tokens OpenAI.

  • additional-instructions: Instruções adicionais para garantir que o código seja escrito de uma certa forma. Por exemplo, aqui especificamos que o código deve estar formatado para funcionar dentro de uma classe de teste.

Ao executar o comando, o agente começa a escrever e iterar os testes.

Como Usar o Cover-Agent

É hora de testar o Cover-Agent. Vamos usar uma simples aplicação de calculadora.py para comparar a cobertura de código para testes manual e automatizados.

Testes Manuais

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

Este é o arquivo test_calculator.py colocado na pasta de testes.

# tests/test_calculator.py
from calculator import add, subtract, multiply, divide

class TestCalculator:

    def test_add(self):
        assert add(2, 3) == 5

Para ver a cobertura de teste, precisamos instalar pytest-cov, uma extensão de cobertura de relatórios para o pytest mencionada anteriormente.

pip install pytest-cov

Execute o分析 de cobertura com:

pytest --cov=calculator

A saída mostra:

Name            Stmts   Miss  Cover
-----------------------------------
calculator.py      10      5    50%
-----------------------------------
TOTAL              10      5    50%

A saída acima mostra que 5 das 10 instruções em calculator.py não são executadas, resultando em apenas 50% de cobertura de código. Para uma base de código maior, isso se tornará um problema sério e causará atrasos.

Agora vamos ver se o cover-agent pode fazer melhor.

Testes Automatizados com Cover-Agent

Para configurar o Cover-Agent do Codium, siga estes passos:

Primeiro, instale o Cover-Agente:

pip install git+https://github.com/Codium-ai/cover-agent.git

Certifique-se de que sua OPENAI_API_KEY está definida em suas variáveis de ambiente, pois é necessária para a API OpenAI.

A seguir, escreva os comandos para iniciar a geração de testes no terminal:

cover-agent \
--source-file-path "calculator.py" \
--test-file-path "tests/test_calculator.py" \
--code-coverage-report-path "coverage.xml" \
--test-command "pytest --cov=. --cov-report=xml --cov-report=term" \
--test-command-dir "./" \
--coverage-type "cobertura" \
--desired-coverage 80 \
--max-iterations 3 \
--openai-model "gpt-4o" \
--additional-instructions "Since I am using a test class, each line of code (including the first line) needs to be prepended with 4 whitespaces. This is extremely important to ensure that every line returned contains that 4 whitespace indent; otherwise, my code will not run."

Isso gera o seguinte código:

import pytest
from calculator import add, subtract, multiply, divide

class TestCalculator:

    def test_add(self):
        assert(add(2, 3), 5

    def test_subtract(self):
        """
        Test subtracting two numbers.
        """
        assert subtract(5, 3) == 2
        assert subtract(3, 5) == -2

    def test_multiply(self):
        """
        Test multiplying two numbers.
        """
        assert multiply(2, 3) == 6
        assert multiply(-2, 3) == -6
        assert multiply(2, -3) == -6
        assert multiply(-2, -3) == 6

    def test_divide(self):
        """
        Test dividing two numbers.
        """
        assert divide(6, 3) == 2
        assert divide(-6, 3) == -2
        assert divide(6, -3) == -2
        assert divide(-6, -3) == 2

    def test_divide_by_zero(self):
        """
        Test dividing by zero, should raise ValueError.
        """
        with pytest.raises(ValueError, match="Cannot divide by zero"):
            divide(5, 0)

Você pode ver que o agente também escreveu testes que verificam erros para qualquer caso de borda.

Agora é hora de testar a cobertura novamente:

pytest --cov=calculator

Saída:

Name            Stmts   Miss  Cover
-----------------------------------
calculator.py      10      0   100%
-----------------------------------
TOTAL              10      0   100%

Neste exemplo, nós atingimos 100% de cobertura de código. Para bases de código maiores, o procedimento é relativamente o mesmo. Você pode ler esta guia para um passo a passo em uma base de código maior.

Enquanto o Cover-Agente representa um avanço significativo, é importante notar que esta tecnologia ainda está em suas fases iniciais. A pesquisa e o desenvolvimento contínuos são cruciais para a refinação e a adoção mais ampla e o codiumAI convida você a fazer suas contribuições para esta ferramenta de código aberto.

Vantagens do Open Source Cover-Agente

A natureza open source do Cover-Agente oferece várias vantagens que deveriam ajudar a impulsionar a tecnologia para frente. Entre elas estão:

  • Acessibilidade: Sua natureza open source permite experimentação de testes baseados em LLM e está acessível a desenvolvedores com back grounds diversosIsto aumentará o número de usuários e levará ao desenvolvimento de uma melhor tecnologia e aplicações mais numerosas.

  • Cooperação: Os desenvolvedores são capazes de fazer contribuições, sugerir melhorias, propunha novas funcionalidades e relatar problemas. Cover-Agent vai crescer e desenvolver rapidamente em um projeto perfeito para desenvolvedores..

  • Transparência: Informações sobre as operações internas estão disponíveis e isso promove a confiança e, eventualmente, aumenta o potencial da tecnologia.

Além das vantagens de código aberto, Cover-Agent oferece aos desenvolvedores um conjunto próprio de benefícios:

  • Acesso Simples: Os desenvolvedores podem instalar e experimentar fácilmente testes baseados em LLM. Isto permite uma exploração próxima e imediata das capacidades da tecnologia e com pouca ou nenhuma interrupção no seu fluxo de trabalho.

  • Customização para Necessidades Específicas: A natureza open-source do Cover-Agent permite que os desenvolvedores adapquem a ferramenta aos requisitos específicos de seus projetos. Isso pode envolver modificar o modelo LLM usado, ajustar os dados de treinamento para melhor refletir sua base de código ou integrar o Cover-Agent com frameworks de teste existentes. Este nível de customização dá poder aos desenvolvedores para aproveitar o poder dos testes baseados em LLM de forma que se aligne com suas necessidades de projeto.

  • Integração Fácil: Ele é facilmente integrado com o VSCode (um popular editor de código), o que torna a integração com fluxos de trabalho existentes muito fácil. Você também pode integrá-lo fácilmente com testes humanamente escritos existentes.

Como Podem Contribuir com o Cover-Agent?

O código fonte do Cover-Agent está disponível publicamente através deste repositório no GitHub. Eles incentivam desenvolvedores de todas as背景 para testarem o seu produto e fazerem contribuições para melhorar e expandir esta nova tecnologia.

Conclusão

Ferramentas de melhoria de teste baseadas em LLM (Large Language Model) têm imenso potencial para revolucionar a forma como os desenvolvedores abordam os testes unitários. Ao aproveitar o poder de modelos de linguagem grandes especificamente treinados sobre código, essas ferramentas podem linearizar a criação de testes, melhorar a cobertura de código e, eventualmente, melhorar a qualidade do software.

Enquanto a pesquisa da Meta com o TestGen-LLM oferece insigtes valiosas, a falta de código publicamente disponível dificulta a adoção mais ampla e o desenvolvimento contínuo. Felizmente, o Cover-Agent forneceu uma solução prontamente acessível e personalizável. Ele dá poder aos desenvolvedores para experimentar com testes baseados em LLM e contribuir para sua evolução.

O potencial do TestGen-LLM e do Cover-Agent é imenso, e o desenvolvimento adicional através de contribuições de desenvolvedores levará a uma ferramenta revolucionária que transformará a geração automatizada de testes para sempre.

Conecte-se comigo em LinkedIn e Twitter se encontrou isto útil.