Gerar testes de unidade com o modo de exibição Copilot Chat do GitHub

  • 8 minutos

A exibição de Chat no Visual Studio Code é o principal local para gerar testes de unidade com o GitHub Copilot. No modo de exibição chat, você pode configurar uma estrutura de teste, gerar testes para um arquivo ou seleção e refinar os resultados até que os testes correspondam às convenções do projeto. Esta unidade se concentra no modo Agente, que grava os testes gerados diretamente em um arquivo de teste, pode executar os testes resultantes e itera sobre as falhas — tudo a partir de um único prompt no chat. Você também pode usar o modo Ask com antecedência para explorar suas opções de teste sem fazer alterações de arquivo.

Abra a exibição de Chat

Abra a exibição de Chat usando uma das seguintes opções:

  • Pressione Ctrl + Alt + I (Windows//Linux) ou Cmd + Alt + I (macOS).
  • Selecione o ícone GitHub Copilot na barra de título e selecione Toggle Chat.

O modo de exibição de Chat é aberto na Barra Lateral Secundária e fornece três opções de configuração que afetam cada prompt que você envia:

  • Destino do agente: onde o agente é executado. Selecione Local para executar o agente interativamente no editor com acesso total ao seu workspace, ferramentas e modelos.
  • Agente: a função que a IA assume para a sessão. Os agentes locais internos são Ask, Plan e Agent.
  • Nível de permissão: quanta autonomia o agente tem ao invocar ferramentas e comandos de terminal. As opções são Aprovações Padrão, Aprovações de Bypass e Piloto Automático.

Para a geração de testes unitários, o ponto de partida recomendado é Agente com Aprovações padrão. O modo de agente pode editar arquivos, executar comandos de terminal e executar testes novamente, para que ele possa usar um prompt como "gerar testes para esse método" e produzir um arquivo de teste de trabalho que você só precisa examinar. As Aprovações Padrão mantêm você no loop solicitando que você confirme cada invocação de ferramenta.

Opcionalmente, use o modo Ask para explorar as opções de teste primeiro

O modo de pergunta responde a perguntas no chat sem modificar arquivos ou invocar ferramentas. Isso faz com que seja uma boa opção quando você deseja planejar uma abordagem antes de deixar o Agente mudar qualquer coisa. Use o modo Perguntar quando quiser:

  • Compare possíveis casos de teste para um método complexo antes de definir uma estrutura.
  • Identificar casos extremos e condições de contorno que merecem ser abordados.
  • Obtenha uma recomendação para uma estrutura de teste ou um estilo de declaração.
  • Veja um exemplo de teste no chat sem escrevê-lo em disco.

Para usar o modo Ask para análise:

  1. Abra o modo de exibição chat e selecione Perguntar no seletor do agente.

  2. Anexe o arquivo ou a seleção relevantes como contexto (por exemplo, com #selection ou arrastando um arquivo).

  3. Faça uma pergunta de análise. Por exemplo: What edge cases should I cover when testing the CalculateDiscount method? List the scenarios and explain why each one matters.

  4. Examine a resposta e, em seguida, alterne o seletor de agente para o Agente para gerar os testes reais.

Configurar uma estrutura de teste com /setupTests

Se o projeto ainda não tiver uma estrutura de teste configurada, GitHub Copilot poderá recomendar uma e orientá-lo pelas etapas de configuração. O comando de barra /setupTests funciona em qualquer agente, mas o modo Agente também pode instalar pacotes e criar o projeto de teste para você.

  1. Abra a visualização de chat e selecione Agente no seletor de agente.

  2. Insira o comando /setupTests no campo de entrada do chat.

  3. Confirme as invocações de ferramentas e os comandos de terminal que o Agente sugere para instalar pacotes, criar a estrutura do projeto de teste e recomendar extensões de teste do Visual Studio Code.

/setupTests é mais útil quando você está iniciando um novo projeto de teste ou integrando um projeto que ainda não inclui testes.

Gerar testes com /tests

O comando de barra /tests gera testes de unidade para o código atualmente ativo no editor. No modo Agent, os testes gerados são gravados diretamente em um arquivo de teste apropriado. GitHub Copilot detecta a estrutura de teste e o estilo de codificação existentes e produz testes que correspondem.

Para gerar testes para um arquivo inteiro:

  1. Abra o arquivo de código do aplicativo que você deseja testar.

  2. Abra o modo de exibição chat e confirme se o Agente está selecionado.

  3. No campo de entrada de chat, insira /tests seguido de qualquer orientação adicional. Por exemplo: /tests Generate unit tests for the methods in this file. Include success, failure, and edge cases.

  4. Confirme as invocações de ferramenta que o Agente usa para ler o contexto, gravar os testes e (opcionalmente) executá-los.

  5. Examine as alterações aplicadas pelo Agente.

    O Agente acrescenta testes a um arquivo de teste existente quando um está disponível ou cria um novo arquivo de teste no local apropriado. A diferença é exibida no editor para que você possa verificar cada alteração.

  6. Selecione Manter ou Desfazer para aceitar ou descartar as alterações.

Para gerar testes para um método específico ou bloco de código:

  1. Abra o arquivo de código do aplicativo.

  2. Selecione o método ou o bloco que você deseja testar.

  3. No modo de exibição chat, insira /tests seguido de diretrizes que referenciam a seleção. Por exemplo: /tests Generate unit tests for the selected method. Validate both success and failure, and include edge cases.

  4. Examine e mantenha ou descarte as alterações resultantes.

Gerar testes com um prompt de linguagem natural

Você não precisa usar um slash command. O Agente gera testes a partir de prompts em linguagem natural quando você inclui contexto suficiente. Exemplos:

  • "Gere testes xUnit para os métodos neste arquivo e adicione-os ao projeto Calculator.Tests."
  • Escreva testes de unidade para o método CalculateDiscount, incluindo casos extremos para valores negativos e zero. Execute os testes depois de escrevê-los."
  • "Crie testes de integração para a camada de acesso a dados neste módulo."

Como o Agente pode executar comandos, você pode incluir etapas de verificação no mesmo prompt. Pedir ao Agente para executar os testes depois de escrevê-los permite que ele pegue e corrija falhas óbvias antes de entregar o trabalho de volta para você.

Adicionar contexto aos prompts

A qualidade dos testes gerados depende do contexto fornecido. Use uma ou mais das seguintes opções para anexar o contexto a um prompt de exibição de chat:

  • Botão Adicionar Contexto : Abra uma Seleção Rápida para adicionar arquivos, pastas, símbolos ou a seleção atual do editor.
  • Arrastar e soltar: arraste arquivos do modo de exibição do Explorer ou arraste uma guia do editor para o modo de exibição chat para anexar o conteúdo.
  • # menções: Digite # seguido por um arquivo, pasta ou nome de símbolo para adicioná-lo como contexto. Use #selection para anexar a seleção atual do editor ou #codebase para permitir que GitHub Copilot pesquise o workspace em busca de contexto relevante.
  • Arquivos externos: abra arquivos de markdown (por exemplo, diretrizes de colaborador ou convenções de teste) no editor e anexe-os por meio de Adicionar Contexto. O Agente usa o conteúdo para moldar os testes gerados.

Por exemplo, se um único método estiver visível no editor, você poderá perguntar: Write a unit test for the method in #editor. Se vários métodos estiverem visíveis ou o método de destino se estender além da área visível, selecione o código primeiro e pergunte: #selection write unit tests for the selected code.

Examinar e refinar as alterações do Agente

Mesmo que o Agente grave testes diretamente em seu projeto de teste, você permanecerá no controle:

  • Examine a diferença: cada arquivo que o Agente altera é aberto no editor com as edições propostas realçadas. Revise as diferenças antes de aceitá-las.
  • Manter ou Desfazer: use Manter para aceitar as alterações ou Desfazer para revertê-las. Você também pode reverter hunks individuais no editor.
  • Compilar e executar: depois de manter as alterações, crie o projeto de teste e execute os testes do Gerenciador de Testes ou do terminal para confirmar se tudo é compilado e aprovado.
  • Iterar: use prompts de acompanhamento na mesma sessão de chat para refinar testes específicos, adicionar mais casos ou renomear métodos.

Personalizar a geração de teste com instruções personalizadas

Se sua organização tiver requisitos de teste específicos, você poderá personalizar como GitHub Copilot gera testes para que a saída corresponda aos seus padrões. As instruções personalizadas permitem:

  • Especifique estruturas de teste preferenciais (por exemplo, xUnit em vez de NUnit).
  • Defina convenções de nomenclatura para classes de teste e métodos.
  • Defina preferências de estrutura de código, como o padrão Arrange-Act-Assert.
  • Solicite padrões de teste específicos, como testes parametrizados para valores de limite.

Armazene instruções personalizadas em um *.instructions.md arquivo em seu workspace. Use o applyTo campo de metadados para aplicar as instruções somente aos arquivos de teste. Por exemplo, um applyTo: tests/** valor define como escopo as instruções para arquivos no tests/ diretório. Compartilhar o arquivo no controle do código-fonte fornece a todos os desenvolvedores da equipe o mesmo contexto de teste.

Importante

Os casos de teste gerados podem não abranger todos os cenários. Revisão manual e revisão de código ainda são necessárias para garantir a qualidade dos testes.