Noções básicas de teste de unidade

Verifique se o código está funcionando conforme o esperado criando e executando testes de unidade. Ele é chamado de teste de unidade porque você divide a funcionalidade do programa em comportamentos discretos testáveis que você pode testar como unidades individuais. O Gerenciador de Testes do Visual Studio fornece uma maneira flexível e eficiente de 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 ao fazer 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 detecta testes afetados pelas alterações de código e os executa em segundo plano conforme você digita.

O teste de unidade tem o maior efeito sobre a qualidade do seu código quando ele é parte integrante do fluxo de trabalho de desenvolvimento de software. Assim que você escreve 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, de limite e incorretos de dados de entrada e que verificam 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, para usar os testes de unidade como documentação de design e especificações funcionais.

O Gerenciador de Testes também pode executar estruturas de teste de unidade de software livre e de terceiros que implementaram interfaces de complemento do Gerenciador de Testes. Você pode adicionar muitas dessas estruturas por meio do Gerenciador de Extensões do Visual Studio e da galeria do Visual Studio. Para saber mais, confira Instalar estruturas de teste de unidade de terceiros.

Introdução

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

• Teste do GitHub Copilot para .NET

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

• Passo a passo: testar o desenvolvimento controlado com o Gerenciador de Testes

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

O exemplo de solução do Banco

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 estruturas.

Nossa primeira tentativa de um 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 criar o Accounts projeto contém uma classe para manter 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 recuperar o saldo da conta.

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

Sabemos por experiência própria que uma coisa que um saque de uma conta corrente deve fazer é garantir que o valor retirado seja menor que o saldo da conta. Portanto, substituímos o método IAccount.Withdraw em CheckingAccount com 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.

Criar testes de unidade com Copilot

A partir do Insiders build do Visual Studio 2026, você pode usar os testes do GitHub Copilot para .NET para gerar testes de unidade automaticamente. O teste do GitHub Copilot para .NET não só gera os testes, mas depura os testes e os executa no Gerenciador de Testes. Para obter mais informações, consulte Visão geral do teste do GitHub Copilot para .NET. Esse é o método recomendado para gerar testes.

Como alternativa, você pode usar o comando de barra "Copilot" /tests para gerar testes de unidade 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 de unidade

Usando o build do Visual Studio 2026 Insiders, você pode usar o teste do GitHub Copilot para .NET para gerar automaticamente testes de unidade.

A maioria dos procedimentos descritos neste artigo se aplicam a testes gerados manualmente. Se você quiser saber mais sobre testes de unidade, leia o restante deste artigo ou vá para a seção Executar testes no Gerenciador de Testes.

Criar 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 do MyBank, você adiciona dois projetos de teste de unidade nomeados AccountsTests e BankDbTests à Bank solução. Os nomes de projeto 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 o teste 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 MSTest.)

3. Na próxima página, 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, ao projeto Contas.

   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 do Projeto ou Adicionar Referência, o que estiver disponível.

   2. Na caixa de diálogo Gerenciador de Referência , 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 A classe contém os métodos de teste de unidade para a AccountInfo classe no Accounts projeto

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

Escreva seus testes

A estrutura de teste de unidade que você usa e o Visual Studio IntelliSense o orientarão ao escrever o código para seus testes de unidade para um projeto de código. Para ser executado no Gerenciador de Testes, a maioria das estruturas exige 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 de declaração ou atributos de método, para indicar se o método de teste passou ou falhou. Outros atributos identificam métodos de instalação opcionais que estão na inicialização de classe e antes de cada método de teste e métodos de teardown 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 métodos na Assert classe geralmente são usados para verificação.

Para testar o CheckingAccount.Withdraw método de 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 tem suporte 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 de unidade do seu código

• Gravando testes de unidade para C/C++

Definir tempos limite para testes de unidade

Se você estiver usando a estrutura MSTest, pode 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 como o máximo permitido:

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

Executar testes no Test Explorer

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

Conforme você executa, grava e executa novamente seus testes, o Gerenciador de Testes pode exibir os resultados em grupos de Testes Com Falha, Testes Aprovados, Testes Ignorados e Testes Não Executados. Você pode escolher grupos diferentes por opções na barra de ferramentas.

Você também pode filtrar os testes em qualquer 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 imediatamente aparentes na barra de status de aprovação ou falha que se encontra na parte superior da janela do explorador. Os detalhes de um resultado do método de teste são exibidos quando você seleciona o teste.

Executar e exibir testes

A barra de ferramentas do Gerenciador de Testes 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 de clique com o 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 os impeçam de serem 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 build

Para executar os testes de unidade após cada build local, abra o ícone de configurações na barra de ferramentas do Gerenciador de Testes e selecione Executar Testes após o Build.

Filtrar e agrupar a lista de testes

Quando você tiver um grande número de testes, poderá digitar na caixa de pesquisa do Gerenciador de Testes para filtrar a lista pela cadeia de caracteres especificada. Você pode restringir mais o evento de filtro escolhendo na lista de filtros.

Botão	Description
	Para agrupar seus 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 depurar testes de unidade?

A: Use o Explorador de Testes para iniciar uma sessão de depuração para seus testes. Percorrer seu código com o depurador do Visual Studio permite que você navegue suavemente entre os testes de unidade e o projeto em 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 a depuração de testes de unidade.

P: Se eu estiver usando o TDD, como faço para gerar código 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 chama a classe ou o 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 tomam vários conjuntos de dados como entrada para executar o teste?

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

O método atribuído é executado uma vez para cada linha na fonte de dados. O Gerenciador de Testes relatará uma falha de teste para o método se alguma 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/falha para cada linha de dados.

Saiba mais sobre testes de unidade controlados 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 pelos testes de unidade usando a ferramenta de cobertura do Visual Studio Code no Visual Studio. Há suporte para linguagens nativas e gerenciadas e todas as estruturas de teste de unidade que podem ser executadas pelo Unit Test Framework.

Você pode realizar a cobertura de código em testes selecionados ou em todos os testes em uma solução. A janela Resultados de Cobertura de Código exibe a porcentagem dos blocos de código do produto que foram exercidos 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 da 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 têm dependências externas?

R: Sim. Se você tiver o Visual Studio Enterprise, o Microsoft Fakes poderá 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 utilizam a instrumentação em tempo de execução para redirecionar chamadas de um método alvo para um método shim substituto em métodos não virtuais.

Em ambas as abordagens, você usa os delegados gerados de chamadas para o método de dependência para especificar o comportamento desejado 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?

A: Sim, siga estas etapas para encontrar e instalar outros frameworks. Depois de reiniciar o Visual Studio, reabra a solução para criar seus testes de unidade e selecione as estruturas instaladas aqui:

Os stubs de teste de unidade serão criados usando a estrutura selecionada.

P: Como posso exportar meus resultados de 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 do teste. Para obter mais informações, consulte o elemento LoggerRunSettings.