Gerar testes unitários com a vista do GitHub Copilot Chat

  • 8 minutos

A vista de Chat no Visual Studio Code é o principal local para gerar testes unitários com o GitHub Copilot. A partir da vista Chat, pode configurar um framework de teste, gerar testes para um ficheiro ou seleção e refinar os resultados até que os testes correspondam às convenções do seu projeto. Esta unidade foca-se no modo Agente, que escreve os testes gerados diretamente num ficheiro de teste, pode executar os testes resultantes e itera sobre falhas — tudo a partir de um único prompt de chat. Também pode usar o modo Pergunta antes para explorar as opções de teste sem fazer alterações nos ficheiros.

Abrir a vista do Chat

Abra a vista do 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 depois selecione Toggle Chat.

A vista do Chat abre-se na Barra Lateral Secundária e oferece três opções de configuração que afetam cada prompt que envia:

  • Destino do agente: Onde o agente é executado. Selecione Local para executar o agente de forma interativa no editor com acesso total ao seu espaço de trabalho, ferramentas e modelos.
  • Agente: O papel que a IA assume durante a sessão. Os agentes locais integrados são Perguntar, Planear e Agente.
  • Nível de permissões: Quanta autonomia o agente tem ao invocar ferramentas e comandos de terminal. As opções são Aprovações Padrão, Aprovações de Contorno e Piloto Automático.

Para gerar testes unitários, o ponto de partida recomendado é o Agent com Default Approvals. O modo agente pode editar ficheiros, executar comandos de terminal e reexecutar testes, por isso pode pegar num prompt como "gerar testes para este método" e produzir um ficheiro de teste funcional que só precisa de rever. O Default Approvals mantém-no informado ao pedir-lhe para confirmar cada invocação de ferramenta.

Opcionalmente, usa o modo Pergunta para explorar primeiro as opções de teste

O modo Perguntar responde às perguntas no chat sem modificar ficheiros ou invocar ferramentas. Isso faz com que seja uma boa opção quando queres planear uma abordagem antes de deixares o Agente mudar alguma coisa. Use o modo Ask quando quiser:

  • Compare casos de teste candidatos para um método complexo antes de se comprometer com uma estrutura.
  • Identifique casos-limite e condições de contorno que valem a pena abordar.
  • Peça uma recomendação para um sistema de teste ou estilo de asserção.
  • Veja um teste de exemplo no chat sem o escrever no disco.

Para usar o modo Ask para análise:

  1. Abre a visão do Chat e seleciona a opção Perguntar no seletor de agentes.

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

  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. Revê a resposta e depois muda o seletor de agentes para Agente para gerar os testes reais.

Configurar uma estrutura de testes com /setupTests

Se o seu projeto ainda não tiver um framework de teste configurado, o GitHub Copilot pode recomendar um e guiá-lo nos passos de configuração. O /setupTests comando de barra funciona em qualquer agente, mas o modo Agente também pode instalar pacotes e criar automaticamente o projeto de teste.

  1. Abra a vista do Chat e selecione Agente no selecionador de agentes.

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

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

/setupTests É mais útil quando se começa um novo projeto de teste ou se está a integrar um projeto que ainda não inclui testes.

Gerar testes com /tests

O /tests comando slash gera testes unitários para o código que está atualmente ativo no editor. No modo Agente, os testes gerados são escritos diretamente num ficheiro de teste apropriado. O GitHub Copilot deteta o framework de testes e o estilo de programação existentes e produz testes que correspondem.

Para gerar testes para um ficheiro inteiro:

  1. Abre o ficheiro de código da aplicação que queres testar.

  2. Abra a vista do Chat e confirme que o Agente está selecionado.

  3. No campo de entrada do chat, introduza /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 ferramentas que o Agente usa para ler o contexto, escrever os testes e (opcionalmente) executá-los.

  5. Revê as alterações que o Agente aplicou.

    O Agente adiciona testes a um ficheiro de teste existente quando um está disponível, ou cria um novo ficheiro de teste no local apropriado. A diferença aparece no editor para que possas verificar cada alteração.

  6. Selecione Guardar 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 ficheiro do código da aplicação.

  2. Selecione o método ou bloco que quer testar.

  3. Na vista do Chat, introduza /tests seguido de uma orientação que faz referência à seleção. Por exemplo: /tests Generate unit tests for the selected method. Validate both success and failure, and include edge cases.

  4. Revê e guarda ou descarta as alterações resultantes.

Gerar testes com um prompt em linguagem natural

Não precisas de usar um comando de corte. O Agente gera testes a partir de prompts em linguagem natural quando se inclui contexto suficiente. Exemplos:

  • "Gera testes xUnit para os métodos deste ficheiro e adiciona-os ao projeto Calculator.Tests."
  • "Escreva testes unitários para o CalculateDiscount método, incluindo casos limites para valores negativos e zero. Executa os testes depois de os teres escrito.
  • "Criar testes de integração para a camada de acesso a dados neste módulo."

Como o Agente pode executar comandos, pode incluir passos de verificação no mesmo prompt. Pedir ao Agente para fazer os testes depois de os escrever permite que ele detete e corrija falhas óbvias antes de te devolver o trabalho.

Adiciona contexto aos teus prompts

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

  • Adicionar Contexto : Abra uma Seleção Rápida para adicionar ficheiros, pastas, símbolos ou a seleção atual do editor.
  • Arrastar e largar: Arraste ficheiros da vista do Explorador, ou arraste um separador do editor, para a vista de Conversa para anexar os conteúdos.
  • # menções: Escreve # seguido de um nome de ficheiro, pasta ou símbolo para o adicionar como contexto. Use #selection para anexar a seleção atual do editor, ou #codebase para GitHub Copilot procurar contexto relevante no espaço de trabalho.
  • Ficheiros externos: Abra ficheiros markdown (por exemplo, diretrizes para colaboradores ou convenções de teste) no editor e anexe-os através de Adicionar Contexto. O Agente utiliza o conteúdo para moldar os testes gerados.

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

Revise e aperfeiçoe as alterações do Agente

Mesmo que o Agente escreva testes diretamente no seu projeto de teste, você mantém o controlo:

  • Revê o diferencial: Cada ficheiro alterado pelo Agente abre-se no editor com as edições propostas realçadas. Analise o diff antes de o aceitar.
  • Guardar ou Desfazer: Use Guardar para aceitar as alterações, ou Desfazer para as reverter. Também é possível reverter blocos individuais de alterações no editor.
  • Construir e executar: Depois de manteres as alterações, constrói o projeto de teste e executa os testes a partir do Explorador de Testes ou do terminal para confirmar que tudo compila e passa.
  • Iterar: Utilize pedidos de seguimento na mesma sessão de conversa para refinar testes específicos, adicionar mais casos ou renomear métodos.

Personalize a geração de testes com instruções personalizadas

Se a sua organização tiver requisitos específicos de testes, pode personalizar como o GitHub Copilot gera testes para que os resultados correspondam aos seus padrões. Instruções personalizadas permitem-lhe:

  • Especifique frameworks de teste preferidos (por exemplo, xUnit em vez de NUnit).
  • Defina convenções de nomenclatura para classes e métodos de teste.
  • 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 fronteira.

Guarde instruções personalizadas num *.instructions.md ficheiro no seu espaço de trabalho. Use o applyTo campo de metadados para aplicar as instruções apenas a ficheiros de teste. Por exemplo, um applyTo: tests/** valor escopa as instruções para ficheiros no tests/ diretório. Partilhar o ficheiro no controlo de versões dá a todos os programadores da equipa o mesmo contexto de teste.

Importante

Os casos de teste gerados podem não cobrir todos os cenários. A revisão manual e a revisão de código continuam a ser necessárias para garantir a qualidade dos seus testes.