Noções básicas de teste de unidade

Verifique se seu código está funcionando conforme o esperado, criando e executando testes de unidade. É chamado de teste de unidade porque você divide a funcionalidade do seu programa em comportamentos testáveis discretos que você pode testar como unidades individuais. Visual Studio Test Explorer fornece uma maneira flexível e eficiente para executar seus testes de unidade e exibir seus resultados no Visual Studio. O Visual Studio instala as estruturas de teste de unidade da Microsoft para código gerenciado e nativo. Use uma estrutura de teste de unidade para criar testes de unidade, executá-los e relatar os resultados desses testes. Execute novamente os testes de unidade quando fizer alterações para testar se o código ainda está funcionando corretamente. O Visual Studio Enterprise pode fazer isso automaticamente com o Live Unit Testing, que deteta testes afetados por suas alterações de código e os executa em segundo plano enquanto você digita.

O teste de unidade tem o maior efeito na qualidade do seu código quando ele é parte integrante do seu fluxo de trabalho de desenvolvimento de software. Assim que você escrever uma função ou outro bloco de código do aplicativo, crie testes de unidade que verifiquem o comportamento do código em resposta a casos padrão, limite e incorretos de dados de entrada e que verifiquem quaisquer suposições explícitas ou implícitas feitas pelo código. Com o desenvolvimento controlado por teste, você cria os testes de unidade antes de escrever o código, portanto, usa os testes de unidade como documentação de projeto e especificações funcionais.

O Test Explorer também pode executar estruturas de teste de unidade de terceiros e de código aberto que implementaram interfaces de complemento do Test Explorer. Você pode adicionar muitas dessas estruturas por meio do Visual Studio Extension Manager e da galeria do Visual Studio. Para obter mais informações, consulte Instalar estruturas de teste de unidade de terceiros.

Introdução

Para obter uma introdução ao teste de unidade que o leva diretamente à codificação, consulte um destes artigos:

• GitHub Copilot em teste com .NET

• Passo a passo: Criar e executar testes de unidade para código .NET

• Passo a passo: Desenvolvimento orientado a testes com o Test Explorer

• Escrever testes de unidade para C/C++ no Visual Studio

O exemplo da solução bancária

Neste artigo, usamos o desenvolvimento de um aplicativo fictício chamado MyBank como exemplo. Você não precisa do código real para seguir as explicações neste artigo. Os métodos de teste são escritos em C# e apresentados usando o Microsoft Unit Testing Framework for Managed Code. No entanto, os conceitos são facilmente transferidos para outras linguagens e frameworks.

Nossa primeira tentativa de design para o MyBank aplicativo inclui um componente de contas que representa uma conta individual e suas transações com o banco, e um componente de banco de dados que representa a funcionalidade para agregar e gerenciar as contas individuais.

Criamos uma Bank solução que contém dois projetos:

• Accounts

• BankDB

Nossa primeira tentativa de projetar o Accounts projeto contém uma classe para armazenar informações básicas sobre uma conta, uma interface que especifica a funcionalidade comum de qualquer tipo de conta, como depositar e retirar ativos da conta, e uma classe derivada da interface que representa uma conta corrente. Começamos os projetos de Contas criando os seguintes arquivos de origem:

• AccountInfo.cs define as informações básicas de uma conta.

• IAccount.cs define uma interface padrão IAccount para uma conta, incluindo métodos para depositar e retirar ativos de uma conta e para recuperar o saldo da conta.

• CheckingAccount.cs contém a CheckingAccount classe que implementa a IAccount interface para uma conta corrente.

Sabemos, por experiência, que uma coisa que um saque de uma conta corrente deve fazer é certificar-se de que o valor retirado é menor do que o saldo da conta. Portanto, substituímos o IAccount.Withdraw método por CheckingAccount um método que verifica essa condição. O método pode ter esta aparência:

public void Withdraw(double amount)
{
    if(m_balance >= amount)
    {
        m_balance -= amount;
    }
    else
    {
        throw new ArgumentException(nameof(amount), "Withdrawal exceeds balance!");
    }
}

Agora que temos algum código, é hora de testar.

Crie testes de unidade com o Copilot

A partir da versão Visual Studio 2026 Insiders, podes usar testes do GitHub Copilot para .NET para gerar automaticamente testes unitários. O teste do GitHub Copilot para .NET não só gera os testes, como também depura os testes e executa-os no Explorador de Testes. Para mais informações, consulte a Visão Geral dos testes do GitHub Copilot para .NET. Este é o método recomendado para gerar testes.

Alternativamente, podes usar o comando Copilot /tests slash para gerar testes unitários a partir do código. Por exemplo, você pode digitar /tests using NUnit Framework para gerar testes NUnit. Para obter mais informações, consulte Usar comandos de barra no Copilot Chat.

Gerar e executar testes unitários

Usando a versão Visual Studio 2026 Insiders, podes usar testes do GitHub Copilot para .NET para gerar automaticamente testes unitários.

A maioria dos procedimentos descritos neste artigo aplica-se a testes gerados manualmente. Se quiser obter informações mais aprofundadas sobre testes unitários, pode ler o resto deste artigo ou saltar para a secção Executar testes no Explorador de Testes.

Crie o projeto de teste de unidade e os testes de unidade manualmente

Um projeto de teste de unidade geralmente espelha a estrutura de um único projeto de código. No exemplo MyBank, você adiciona dois projetos de teste de unidade nomeados AccountsTests e BankDbTests à Bank solução. Os nomes dos projetos de teste são arbitrários, mas adotar uma convenção de nomenclatura padrão é uma boa ideia.

Para adicionar um projeto de teste de unidade a uma solução:

1. No Gerenciador de Soluções, clique com o botão direito do mouse na solução e escolha Adicionar>NovoProjeto.

2. Digite test na caixa de pesquisa de modelo de projeto para localizar um modelo de projeto de teste de unidade para a estrutura de teste que você deseja usar. (Nos exemplos deste artigo, usamos o MSTest.)

3. Na página seguinte, nomeie o projeto. Para testar o Accounts projeto do nosso exemplo, você pode nomear o projeto AccountsTests.

4. Em seu projeto de teste de unidade, adicione uma referência ao projeto de código em teste, em nosso exemplo para o projeto Accounts.

   Para criar a referência ao projeto de código:

   1. No projeto de teste de unidade no Gerenciador de Soluções, clique com o botão direito do mouse no nó Referências ou Dependências e escolha Adicionar Referência de Projeto ou Adicionar Referência, o que estiver disponível.

   2. Na caixa de diálogo Gerenciador de referências , abra o nó Solução e escolha Projetos. Selecione o nome do projeto de código e feche a caixa de diálogo.

Cada projeto de teste de unidade contém classes que espelham os nomes das classes no projeto de código. Em nosso exemplo, o AccountsTests projeto conteria as seguintes classes:

• AccountInfoTests class contém os métodos de teste de unidade para a AccountInfo classe no Accounts projeto

• CheckingAccountTests class contém os métodos de teste de unidade para CheckingAccount classe.

Escreva os seus testes

A estrutura de teste de unidade que você usa e o Visual Studio IntelliSense irão guiá-lo através da escrita do código para seus testes de unidade para um projeto de código. Para ser executada no Gerenciador de Testes, a maioria das estruturas requer que você adicione atributos específicos para identificar métodos de teste de unidade. As estruturas também fornecem uma maneira — geralmente por meio de instruções assert ou atributos de método — para indicar se o método de teste passou ou falhou. Outros atributos identificam métodos de configuração opcionais que estão na inicialização da classe e antes de cada método de teste e métodos de desmontagem que são executados após cada método de teste e antes que a classe seja destruída.

O padrão AAA (Arrange, Act, Assert) é uma maneira comum de escrever testes de unidade para um método em teste.

• A seção Arrange de um método de teste de unidade inicializa objetos e define o valor dos dados que são passados para o método em teste.

• A seção Act invoca o método em teste com os parâmetros organizados.

• A seção Assert verifica se a ação do método em teste se comporta conforme o esperado. Para .NET, os Assert métodos na classe são frequentemente usados para verificação.

Para testar o CheckingAccount.Withdraw método do nosso exemplo, podemos escrever dois testes: um que verifica o comportamento padrão do método e outro que verifica se uma retirada de mais do que o saldo falhará (O código a seguir mostra um teste de unidade MSTest, que é suportado no .NET.). CheckingAccountTests Na classe, adicionamos os seguintes métodos:

[TestMethod]
public void Withdraw_ValidAmount_ChangesBalance()
{
    // arrange
    double currentBalance = 10.0;
    double withdrawal = 1.0;
    double expected = 9.0;
    var account = new CheckingAccount("JohnDoe", currentBalance);

    // act
    account.Withdraw(withdrawal);

    // assert
    Assert.AreEqual(expected, account.Balance);
}

[TestMethod]
public void Withdraw_AmountMoreThanBalance_Throws()
{
    // arrange
    var account = new CheckingAccount("John Doe", 10.0);

    // act and assert
    Assert.ThrowsException<System.ArgumentException>(() => account.Withdraw(20.0));
}

Para obter mais informações sobre as estruturas de teste de unidade da Microsoft, consulte um dos seguintes artigos:

• Teste o seu código com testes unitários

• Escrevendo testes de unidade para C/C++

Definir tempos limite para testes de unidade

Se você estiver usando a estrutura MSTest, poderá usar o TimeoutAttribute para definir um tempo limite em um método de teste individual:

[TestMethod]
[Timeout(2000)]  // Milliseconds
public void My_Test()
{ ...
}

Para definir o tempo limite para o máximo permitido:

[TestMethod]
[Timeout(TestTimeout.Infinite)]  // Milliseconds
public void My_Test ()
{ ...
}

Executar testes no Explorador de Testes

Quando você cria o projeto de teste, os testes aparecem no Gerenciador de Testes. Se o Test Explorer não estiver visível, escolha Test no menu Visual Studio, escolha Windows e, em seguida, escolha Test Explorer (ou pressione Ctrl + E, T).

À medida que você executa, escreve e executa novamente os testes, o Gerenciador de Testes pode exibir os resultados em grupos de Testes Reprovados, Testes Aprovados, Testes Ignorados e Testes Não Executados. Você pode escolher diferentes grupos por opções na barra de ferramentas.

Você também pode filtrar os testes em qualquer modo de exibição combinando texto na caixa de pesquisa no nível global ou selecionando um dos filtros predefinidos. Você pode executar qualquer seleção dos testes a qualquer momento. Os resultados de uma execução de teste são visíveis de imediato na barra de aprovação/reprovação localizada no topo da janela do explorador. Os detalhes do resultado de um método de teste são exibidos quando você seleciona o teste.

Executar e visualizar testes

A barra de ferramentas Test Explorer ajuda você a descobrir, organizar e executar os testes nos quais você está interessado.

Você pode escolher Executar tudo para executar todos os testes (ou pressionar Ctrl + R, V) ou escolher Executar para escolher um subconjunto de testes a serem executados (Ctrl + R, T). Selecione um teste para exibir os detalhes desse teste no painel de detalhes do teste. Escolha Abrir teste no menu do botão direito do mouse (Teclado: F12) para exibir o código-fonte do teste selecionado.

Se os testes individuais não tiverem dependências que impeçam que eles sejam executados em qualquer ordem, ative a execução de teste paralelo no menu de configurações da barra de ferramentas. Isso pode reduzir visivelmente o tempo necessário para executar todos os testes.

Executar testes após cada compilação

Para executar seus testes de unidade após cada compilação local, abra o ícone de configurações na barra de ferramentas Test Explorer e selecione Run Tests After Build.

Filtrar e agrupar a lista de testes

Quando tiver um grande número de testes, pode digitar na caixa de pesquisa do Test Explorer para filtrar a lista pela cadeia de caracteres especificada. Pode restringir ainda mais o seu evento de filtragem, escolhendo a partir da lista de filtros.

Button	Description
	Para agrupar os testes por categoria, escolha o botão Agrupar por .

Para obter mais informações, consulte Executar testes de unidade com o Gerenciador de Testes.

Perguntas e Respostas

P: Como depuro testes de unidade?

A: Utilize Test Explorer para iniciar uma sessão de depuração para os seus testes. Percorrer o seu código com o depurador do Visual Studio permite navegação fluída entre os testes unitários e o projeto sob teste. Para iniciar a depuração:

1. No editor do Visual Studio, defina um ponto de interrupção em um ou mais métodos de teste que você deseja depurar.

   Observação

   Como os métodos de teste podem ser executados em qualquer ordem, defina pontos de interrupção em todos os métodos de teste que você deseja depurar.

2. No Gerenciador de Testes, selecione os métodos de teste e escolha Depurar Testes Selecionados no menu de atalho.

Saiba mais detalhes sobre testes unitários de depuração.

P: Se eu estiver usando TDD, como faço para gerar código a partir dos meus testes?

Um: Use Ações Rápidas para gerar classes e métodos no código do projeto. Escreva uma instrução em um método de teste que chame a classe ou método que você deseja gerar e, em seguida, abra a lâmpada que aparece sob o erro. Se a chamada for para um construtor da nova classe, escolha Gerar tipo no menu e siga o assistente para inserir a classe em seu projeto de código. Se a chamada for para um método, escolha Gerar método no menu IntelliSense.

P: Posso criar testes de unidade que usam vários conjuntos de dados como entrada para executar o teste?

R: Sim. Os métodos de teste orientados por dados permitem testar um intervalo de valores com um único método de teste de unidade. Utilize um atributo DataRow, DynamicData ou DataSource para o método de teste que especifica a fonte de dados que contém os valores variáveis que se deseja testar.

O método atribuído é executado uma vez para cada linha na fonte de dados. Test Explorer relata uma falha de teste para o método se qualquer uma das iterações falhar. O painel de detalhes dos resultados do teste para o método mostra o método de status de aprovação/reprovação para cada linha de dados.

Saiba mais sobre testes de unidade orientados por dados.

P: Posso ver quanto do meu código é testado pelos meus testes de unidade?

R: Sim. Você pode determinar a quantidade de seu código que está realmente sendo testado por seus testes de unidade usando a ferramenta de cobertura de código do Visual Studio no Visual Studio. Há suporte para linguagens nativas e gerenciadas e todas as estruturas de teste de unidade que podem ser executadas pela Estrutura de Teste de Unidade.

Você pode executar cobertura de código em testes selecionados ou em todos os testes numa solução. A janela Resultados da Cobertura de Código exibe a porcentagem dos blocos de código do produto que foram executados por linha, função, classe, namespace e módulo.

Para executar a cobertura de código para métodos de teste em uma solução, escolha Test>Analyze Code Coverage for All Tests.

Os resultados de cobertura aparecem na janela Resultados da Cobertura de Código.

Saiba mais sobre a cobertura de código.

P: Posso testar métodos no meu código que tenham dependências externas?

R: Sim. Se você tiver o Visual Studio Enterprise, o Microsoft Fakes pode ser usado com métodos de teste que você escreve usando estruturas de teste de unidade para código gerenciado.

O Microsoft Fakes usa duas abordagens para criar classes substitutas para dependências externas:

1. Os stubs geram classes substitutas derivadas da interface pai da classe de dependência de destino. Os métodos Stub podem ser substituídos por métodos virtuais públicos da classe de destino.

2. Os shims usam instrumentação de tempo de execução para desviar chamadas de um método de destino para um método substituto de shim em métodos não virtuais.

Em ambas as abordagens, utiliza-se os delegados gerados das chamadas para o método de dependência para especificar o comportamento pretendido no método de teste.

Saiba mais sobre como isolar métodos de teste de unidade com o Microsoft Fakes.

P: Posso usar outras estruturas de teste de unidade para criar testes de unidade?

Um: Sim, siga estas etapas para encontrar e instalar outros frameworks. Depois de reiniciar o Visual Studio, reabra sua solução para criar seus testes de unidade e, em seguida, selecione suas estruturas instaladas aqui:

Os stubs dos testes unitários serão criados usando o framework selecionado.

P: Como posso exportar os resultados do meu teste de unidade?

Um: Você pode usar um arquivo .runsettings com a linha de comando ou o IDE do Visual Studio para configurar testes de unidade e definir o arquivo de resultados de teste. Para obter mais informações, consulte o elemento LoggerRunSettings.