Examinar as ferramentas de teste de unidade e o ambiente

8 minutos

GitHub Copilot Chat pode ser usado para sugerir testes unitários com base no código que especificar. Por exemplo, se especificar uma assinatura de método e um corpo, o GitHub Copilot Chat pode sugerir casos de teste que abrangem parâmetros de entrada e valores esperados de saída. Quando o seu projeto de teste contém alguns casos de teste, pode usar GitHub Copilot para gerar sugestões de conclusão de código para casos de teste adicionais. Usar completações de linha de código para gerar testes de unidade reduz o processo repetitivo e ajuda a garantir que seu código seja testado completamente.

GitHub Copilot Chat usa o contexto e a semântica do seu código para sugerir asserções que garantam que a função está a funcionar corretamente. Ele também ajuda você a escrever casos de teste para casos de borda e condições de limite que podem ser difíceis de identificar manualmente. Por exemplo, o GitHub Copilot Chat pode sugerir casos de teste para o tratamento de erros, valores nulos ou tipos de entrada inesperados.

Importante

Os casos de teste gerados podem não abranger todos os cenários possíveis. Testes manuais e revisões de código são necessários para garantir a qualidade do seu código.

GitHub Copilot suporte para testes unitários

GitHub Copilot pode ajudar nas seguintes tarefas de teste:

Configurar estruturas de teste: obtenha ajuda para configurar a estrutura de teste e as extensões VS Code corretas para seu projeto e linguagem.
Gerar código de teste: crie testes de unidade, testes de integração e testes de ponta a ponta que abranjam o código do aplicativo.
Lidar com casos extremos: gere conjuntos de testes abrangentes para cobrir casos extremos e condições de erro.
Corrigir testes com falha: receba sugestões para corrigir falhas de teste.
Mantenha a consistência: personalize GitHub Copilot para gerar testes que sigam as práticas de codificação do seu projeto.

Configurar sua estrutura de teste

Para acelerar o seu fluxo de trabalho de testes, GitHub Copilot pode ajudar a configurar o framework de testes e as extensões VS Code para o seu projeto. GitHub Copilot sugere frameworks de teste adequados com base no tipo de projeto.

Abra a visualização de Chat.
Introduz o /setupTests comando no campo de entrada do chat.
Siga as orientações da GitHub Copilot para configurar o seu projeto.

Escrever testes unitários com GitHub Copilot

GitHub Copilot pode ajudar-te a escrever testes para o código da tua aplicação ao gerar código de teste que cubra a tua base de código. Isso inclui testes de unidade, testes de ponta a ponta e testes para casos extremos.

Pode gerar testes unitários usando as seguintes ferramentas GitHub Copilot:

Vista de chat: Use a vista de chat para gerar testes unitários para um projeto, classe ou método usando o Perguntar, Planear ou Agente.
Chat Inline: Use o Chat Inline para gerar testes unitários para turmas ou métodos selecionados.
Ações inteligentes: Use a ação inteligente Generate Tests para gerar testes unitários para código selecionado sem escrever um prompt.
Completação de linhas de código: Use completações de linhas de código para sugerir testes unitários adicionais para um caso de teste existente.

Corrigir testes com falha

GitHub Copilot integra-se com o Explorador de Testes em Visual Studio Code e pode ajudar a corrigir testes falhados.

No Gerenciador de Testes, passe o mouse sobre um teste com falha.
Selecione o botão Corrigir Falha no Teste (ícone de brilho)
Reveja e aplique a solução sugerida de GitHub Copilot.

Como alternativa, pode:

Abra a visualização de Chat.
Introduza o /fixTestFailure comando de barra.
Siga as sugestões da GitHub Copilot para corrigir o teste

Sugestão

Ao usar GitHub Copilot em modo Agente, o agente monitoriza a saída do teste ao executar testes e tenta automaticamente corrigir e reexecutar testes falhados.

Manter a consistência

Se a sua organização tiver requisitos específicos de testes, pode personalizar a forma como GitHub Copilot gera testes para garantir que cumprem os seus padrões. Pode personalizar a forma como GitHub Copilot gera testes fornecendo instruções personalizadas. Por exemplo:

Especificar estruturas de teste preferenciais
Definir convenções de nomenclatura para testes
Definir preferências de estrutura de código
Solicitar padrões ou metodologias de teste específicos

Suporte ao Visual Studio Code para testes unitários

Para criar e executar testes unitários em C# no Visual Studio Code, precisa dos seguintes recursos:

O SDK .NET 8.0 ou posterior.
A extensão C# Dev Kit para Visual Studio Code.
Um pacote de estrutura de teste adicionado ao seu projeto.

Suporte do C# Dev Kit para testes de unidade

A extensão C# Dev Kit para Visual Studio Code oferece um conjunto rico de funcionalidades para o ajudar a criar e gerir testes unitários para os seus projetos em C#. Inclui as seguintes características:

Test Explorer - Uma exibição em árvore para mostrar todos os casos de teste em seu espaço de trabalho.
Executar/Depurar casos de teste - Um recurso para executar e depurar casos de teste.
Exibir resultados do teste - Um recurso para exibir os resultados do teste.
Comandos de teste - Comandos para executar todos os testes, executar testes com falha e muito mais.
Configurações de teste - Configurações específicas para testes.
Pacote de estrutura de teste

O C# Dev Kit suporta as seguintes estruturas de teste:

xUnidade
NUnit
MSTest

O C# Dev Kit permite criar um projeto de teste, adicionar um pacote de estrutura de teste e gerenciar testes de unidade.

Habilitando uma estrutura de teste

A Paleta de Comandos no Visual Studio Code oferece a forma mais fácil de ativar um framework de testes para o seu projeto. Você pode abrir a Paleta de Comandos das seguintes maneiras:

Pressione as teclas Ctrl + Shift + P (Windows/Linux) ou Cmd + Shift + P (macOS).
Abre o menu Visualizar e depois seleciona Paleta de Comandos.
Abra a vista Solution Explorer, clique com o botão direito na pasta da solução e depois selecione Novo Projeto. Esta opção abre a Paleta de Comandos com o .NET:Novo Projeto... comando já selecionado.

As seções a seguir descrevem como habilitar uma estrutura de teste para seu projeto C# usando a paleta de comandos.

xUnidade

Abre a Paleta de Comandos e seleciona .NET:Novo Projeto... depois selecione xUnit Test Project e forneça o nome e a localização do novo projeto. Este comando cria um novo projeto e diretório que usa xUnit como biblioteca de testes e configura o executor de testes adicionando os seguintes <PackageReference /> elementos ao ficheiro do projeto.

Microsoft.NET.Test.Sdk
xUnit
xunit.runner.visualstudio
coverlet.collector

A partir do Terminal, pode executar o seguinte comando:


   dotnet add [location of your test csproj file] reference [location of the csproj file for project to be tested]

NUnit

Abre a Paleta de Comandos e seleciona .NET:Novo Projeto... depois selecione NUnit3 Test Project e forneça o nome e a localização do novo projeto. Este comando cria um novo projeto e diretório que utiliza o NUnit como biblioteca de teste e configura o executor de testes adicionando os seguintes <PackageReference /> elementos ao ficheiro do projeto.

Microsoft.NET.Test.Sdk
NUnit
NUnit3TestAdapter

No Terminal, execute o seguinte comando:

    dotnet add [location of your test csproj file] reference [location of the csproj file for project to be tested]

MSTest

Abre a Paleta de Comandos e seleciona .NET:Novo Projeto... selecione MSTest Test Project e forneça o nome e a localização do novo projeto. Este comando cria um novo projeto e diretório que utiliza o MSTest como biblioteca de teste e configura o executor de testes adicionando os seguintes <PackageReference /> elementos ao ficheiro do projeto.

Microsoft.NET.Test.Sdk
MSTest.TestAdapter
MSTest.TestFramework
coverlet.collector

No Terminal, execute o seguinte comando:

    dotnet add [location of your test csproj file] reference [location of the csproj file for project to be tested]

Desenvolver testes unitários em Visual Studio Code usando o GitHub Copilot Chat

A combinação de Visual Studio Code e GitHub Copilot Chat proporciona um ambiente poderoso para criar e executar testes unitários para os seus projetos em C#.

O processo de teste unitário pode ser dividido em três etapas:

Usa o Visual Studio Code para criar um projeto de teste para os teus testes unitários.
Usa GitHub Copilot Chat para desenvolver casos de teste unitário para o teu projeto C#.
Usa o Visual Studio Code e o C# Dev Kit para correr e gerir os teus testes unitários.

Criar um projeto de teste

Você precisa criar um projeto de teste que será usado para realizar seus testes de unidade. Pode usar o Visual Studio Code para completar as seguintes tarefas:

Use a paleta de comandos para criar um projeto de teste que usa uma estrutura de teste especificada.
Use o Terminal integrado para adicionar uma referência ao projeto que você está testando.

Esse processo cria um novo projeto e configura o executor de teste para a estrutura selecionada.

Gerar casos de teste unitário usando GitHub Copilot Chat

GitHub Copilot Chat pode ser usado para te ajudar a escrever casos de teste unitário para o teu framework de testes. O GitHub Copilot Chat reconhece o teu framework de teste e estilo de programação e gera excertos de código correspondentes. Pode usar GitHub Copilot Chat para completar as seguintes tarefas:

Escreva casos de teste de unidade para sua estrutura de teste com base no código aberto no editor ou no trecho de código destacado no editor. GitHub Copilot identifica o seu framework de teste e estilo de programação e gera excertos de código correspondentes.
Identifique e escreva casos de teste para casos extremos e condições de limite que podem ser difíceis de identificar manualmente. Por exemplo, GitHub Copilot pode sugerir casos de teste para o tratamento de erros, valores nulos ou tipos de entrada inesperados.
Sugira asserções que garantam que a função está funcionando corretamente, com base no contexto e na semântica do código. Por exemplo, gere asserções para garantir que os parâmetros de entrada da função sejam válidos.

Considere os seguintes cenários ao pedir ao GitHub Copilot Chat para gerar casos de teste unitário:

Se um único método estiver visível na íntegra no editor, pode pedir ao GitHub Copilot Chat para gerar um teste unitário para o método digitando Write a unit test for the method in the #editor.
Se houver vários métodos visíveis ou se o método pretendido se estender para além do que está visível no editor, selecione o código para o qual quer gerar um teste unitário e depois pergunte ao GitHub Copilot: #selection write a unit test for the selected code.

Executar e gerir testes unitários no Visual Studio Code

O Visual Studio Code e o C# Dev Kit oferecem um conjunto rico de funcionalidades para o ajudar a executar e gerir testes unitários para os seus projetos em C#. Você pode executar/depurar casos de teste, exibir resultados de teste e gerenciar casos de teste usando o Gerenciador de Testes.

Executar/Depurar casos de teste: o C# Dev Kit gera atalhos (o botão verde de reprodução) à esquerda das definições de classe e método. Para executar os casos de teste alvo, selecione o botão verde de executar. Você também pode clicar com o botão direito sobre ele para ver mais opções.
Test Explorer: O Test Explorer é uma exibição em árvore para mostrar todos os casos de teste em seu espaço de trabalho. Podes selecionar o botão de copo na barra de Atividades do lado esquerdo do Visual Studio Code para o abrir. Você também pode executar/depurar os seus casos de teste e visualizar os resultados do teste a partir desse ponto.
Exibir resultados do teste: Depois de executar/depurar os casos de teste, o estado dos itens de teste relacionados é atualizado nas decorações do editor e no Gerenciador de Testes. Você pode selecionar os links no rastreamento de pilha para navegar até o local de origem.
Comandos de teste do Visual Studio Code: Existem comandos de teste (por exemplo, Executar Todos os Testes) que podem ser encontrados procurando por Test: na Paleta de Comandos.
Definições de testes do Visual Studio Code: Existem definições específicas do Visual Studio Code para testes que podem ser encontradas procurando por Testing no editor de Definições.

Resumo

Comentários

Esta página foi útil?