É 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 eles funcionam conforme planejado.

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

Houve algumas recentes mudanças na inteligência artificial que prometem ajudar a automatizar os processos de desenvolvimento de testes unitários. Em fevereiro, pesquisadores na Meta divulgaram um documento sobre Avanços na Automatização de Melhoria de Testes Unitários usando Modelos de Linguagem de Grande Escala. Este documento apresentou uma nova abordagem para a automatização de testes unitários.

Sua pesquisa se concentra em uma nova ferramenta chamada TestGen-LLM, que explora as possibilidades de usar LLMs para analisar testes unitários já existentes e melhorá-los para aumentar a cobertura de 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 sua pesquisa neste artigo. Vai aprender como a ferramenta gera conjuntos de testes, porque é melhor que a maioria dos LLMs e onde conseguir sua mão na tecnologia e começar a tentar.

Tabela de Conteúdos

Meta’s TestGen-LLM

O Meta’s TestGen-LLM aborda a tarefa demorada de escrever testes de unidade, aproveitando o poder de Modelos de Linguagem Larga (LLMs). Modelos LLMs de finalidade geral, como Gemini ou ChatGPT, podem ter dificuldades com o domínio específico de código de testes de unidade, testando sintaxe, e gerando testes que não adicionam valor. Mas o TestGen-LLM é especificamente feito para testes de unidade.

Essa especialização o permite entender as complexidades da estrutura de código e lógica de teste, levando a suites de teste mais focadas e gerando testes que realmente adicionam valor e aumentam a cobertura de código.

O TestGen-LLM é capaz de avaliar testes de unidade e identificar áreas para melhoria. 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 garantias dentro do TestGen-LLM para garantir a eficácia dos testes que ele escreve. essas garantias, chamadas de filtros, atuam como um mecanismo de controle de qualidade. 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 TestGen_LLM)

O TestGen-LLM gera um conjunto de testes, em seguida, elimina 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 em que 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 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% foram executados confiabilmente, e 25% aumentaram a cobertura. Durante os test-a-thons do Instagram e do Facebook da Meta, ele melhorou 11,5% de todas as classes às quais foi aplicado, com 73% de suas recomendações sendo aceitas para implantação de produção pelos engenheiros de software da Meta”.

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

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

A pesquisa do TestGen-LLM da Meta tem muito potencial para mudar o teste de unidade 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 esta tecnologia não está disponível para qualquer pessoa, já que o código do TestGen-LLM não foi liberado.

Desenvolvedores que se interessaram nesta tecnologia provavelmente estão frustrados pela falta de código disponível publicamente. Afinal, o estudo do TestGen-LLM da Meta fornece uma pequena ideia do futuro do que a automação de testes pode ser.

É muito atraente ser capaz de mergulhar nas funcionalidades internas da última tecnologia, entender seus processos de decisão e talvez até mesmo ajudar a moldar seu desenvolvimento. Mas enquanto a falta de código da Meta é um obstáculo, 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 teste automatizado baseada no TestGen-LLM. Inspirado pela pesquisa da Meta, o Cover-Agent está agora no centro das mudanças em tecnologias de teste de unidade de código aberto com inteligência artificial.

Por que é necessário LLMs específicos focados em testes?

Já que a maioria dos LLMs (como ChatGPT e Gemini) é capaz de gerar testes, então por que se preocupar com uma nova 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 pitfalls comuns que os desenvolvedores se deparam quando gerando testes com LLMs, tais como:

  • Falha de LLM

  • Gerando testes que não adicionam valor

  • Gerando testes que omitem partes do código, resultando em baixa cobertura de código

Para superar tais desafios (especificamente para testes de unidade de regressão) os pesquisadores 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 outras necessidades que possamos ter?

Estas são questões e problemas fundamentais que o teste gerado deve resolver antes de ser considerado uma melhoria na tecnologia existente. O Cover-Agent fornece testes que respondem a estas questões com um grau de eficiência notável.

Como o Cover-Agent Funciona?

O Cover-Agent faz parte de uma suite mais abrangente de ferramentas projetadas para automatizar a criação de testes unitários para projetos de software. Utilizando o modelo de IA gerativa TestGen-LLM, ele visa simplificar e acelerar o processo de teste, garantindo o desenvolvimento de software de alta qualidade.

O sistema é composto por vários componentes:

  • Executor de Testes: Executa comandos ou scripts para executar o conjunto de testes e gerar relatórios de cobertura de código.

  • Analista de Cobertura: 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.

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

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

Estes componentes trabalham juntos com o TestGen-LLM para gerar apenas testes que sejam garantidos para melhorar a base de código existente.

Como Usar o Cover-Agent

Requisitos

Antes de começar a usar o Cover-Agent, você precisa ter as seguintes exigências:

  • OPENAI_API_KEY definido nas variáveis de ambiente, que é necessário para chamar a API OpenAI.

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

Instalação

Se você estiver executando o Cover-Agent 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.

Executar em Modo独立e

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

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 Python). Você pode baixar a versão para seu sistema navegando até 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 do código fonte:

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 de unidade.

Executá-lo pelo terminal 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 contidos 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-codigo: 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% seja frequentemente 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 determinada forma. Por exemplo, aqui especificamos que o código deve ser 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 a simples aplicação calculator.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 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 pytest para relatórios de cobertura, como mencionado anteriormente.

pip install pytest-cov

Execute o分析 de cobertura com:

pytest --cov=calculator

O resultado mostra:

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

O resultado acima mostra que 5 de 10 instruções em calculator.py não foram executadas, resultando em apenas 50% de cobertura de código. Para um base de código maior, isso se tornará um problema sério e poderá causar recuo.

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.

Em seguida, 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 quaisquer casos 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 bases de código maiores.

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 adicional e para a adoção mais ampla, e o codiumAI convida você a fazer seu contributo a este ferramenta de código aberto.

Benefícios do Open Source Cover-Agent

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

  • Acessibilidade: Sua natureza open source permite experiências de teste baseadas em LLM e é acessível a desenvolvedores com背景variavel. Isto aumentará o número de usuários e levará ao desenvolvimento de uma melhor tecnologia e aplicações mais..

  • Cooperação: Desenvolvedores podem fazer contribuições, sugerir melhorias, propôr 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 do 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. Isso permite a exploração próxima e imediata das capacidades da tecnologia e com pouca ou nenhuma interrupção no seu workflow.

  • Customização para Necessidades Específicas: A natureza open-source do Cover-Agent permite que os desenvolvedores adapquem a ferramenta às suas exigências de projeto específicas. Isto pode envolver modificar o modelo LLM usado, ajustar o conjunto de dados de treinamento para melhor refletir seu codebase, 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 uma maneira que se alinhe com as 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 você pode contribuir para o Cover-Agent?

O código fonte do Cover-Agent está publicamente disponível através deste repositório no GitHub. Eles encorajam desenvolvedores de todas as backbones a testarem o seu produto e a 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 um potencial imenso para revolucionar a forma como os desenvolvedores abordam os testes de unidade. Ao aproveitar o poder de modelos de linguagem grande especificamente treinados em código, essas ferramentas podem linearizar a criação de testes, melhorar a cobertura de código e, eventualmente, aumentar a qualidade do software.

Enquanto a Meta realiza pesquisa com TestGen-LLM oferecendo insigtes valiosas, a falta de código disponível publicamente 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 com sua evolução.

O potencial das TestGen-LLM e do Cover-Agent é imenso, e o desenvolvimento futuro 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.