Introdução ao C# e ao MSTest

Este tutorial guia você por uma experiência interativa de construção de uma solução de exemplo passo a passo para aprender conceitos de teste de unidade. Se você preferir acompanhar o tutorial usando uma solução interna, veja ou baixe o exemplo de código antes de começar. Para obter instruções de download, consulte Exemplos e Tutoriais.

Este artigo é sobre como testar um projeto do .NET Core. Se você estiver testando um projeto do ASP.NET Core, consulte Testes de Integração no ASP.NET Core.

Pré-requisitos

• O .NET SDK mais recente
• Editor do Visual Studio Code
• O DevKit C#

Criar o projeto de origem

Abra uma janela do shell. Crie um diretório chamado unit-testing-using-mstest para manter a solução. Dentro desse novo diretório, execute dotnet new sln para criar um novo arquivo de solução para a biblioteca de classes e o projeto de teste. Crie um diretório PrimeService . O esquema a seguir mostra a estrutura do diretório e dos arquivos até agora.

/unit-testing-using-mstest
    unit-testing-using-mstest.sln
    /PrimeService

Torne PrimeService o diretório atual e execute dotnet new classlib para criar o projeto de origem.

Altere o diretório de volta para o diretório unit-testing-using-mstest. Execute dotnet sln add para adicionar o projeto de biblioteca de classes à solução:

dotnet sln add PrimeService/PrimeService.csproj

Renomeie Class1.cs no diretório PrimeService para PrimeService.cs. Substitua o código no arquivo pelo seguinte código para criar uma implementação com falha da PrimeService classe:

using System;

namespace Prime.Services
{
    public class PrimeService
    {
        public bool IsPrime(int candidate)
        {
            throw new NotImplementedException("Please create a test first.");
        }
    }
}

Criar o projeto de teste

Crie o diretório PrimeService.Tests . O seguinte esquema mostra a estrutura do diretório:

/unit-testing-using-mstest
    unit-testing-using-mstest.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests

Torne o PrimeService.Tests diretório atual e crie um novo projeto usando dotnet new mstest. O novo comando dotnet cria um projeto de teste que usa MSTest como a biblioteca de teste. O modelo configura o executor de teste no arquivo PrimeServiceTests.csproj :

<ItemGroup>
  <PackageReference Include="MSTest" Version="4.1.0" />
</ItemGroup>

Note

As versões do pacote mostradas são exemplos. As versões geradas por dotnet new mstest dependem do SDK do .NET. Modelos e exemplos baixados podem não usar as versões mais recentes dos pacotes NuGet.

Para verificar se há atualizações depois de criar e executar seus testes, execute dotnet package list --outdated no diretório do projeto de teste. Use dotnet package add <PACKAGE_NAME> para atualizar uma referência de pacote para a versão estável compatível mais recente. Examine as notas de versão sobre alterações incompatíveis antes de atualizar e execute dotnet test novamente depois.

Se você usar o SDK do .NET 9 ou anterior, use dotnet list package --outdated e dotnet add package <PACKAGE_NAME> em vez disso.

O projeto de teste requer outros pacotes para criar e executar testes de unidade. dotnet new na etapa anterior adicionou os pacotes e ferramentas MSTest necessários para o relatório de cobertura de código.

Adicione a PrimeService biblioteca de classes como outra dependência ao projeto. Use o comando dotnet reference add:

dotnet reference add ../PrimeService/PrimeService.csproj

Você pode ver todo o arquivo no repositório de exemplos no GitHub.

O esboço a seguir mostra o esquema final da solução.

/unit-testing-using-mstest
    unit-testing-using-mstest.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeServiceTests.csproj

Altere para o diretório unit-testing-using-mstest e execute dotnet sln add:

dotnet sln add ./PrimeService.Tests/PrimeService.Tests.csproj

Criar o primeiro teste

Escreva um teste com falha, faça-o passar e repita o processo. Remova UnitTest1.cs do diretório PrimeService.Tests e crie um novo arquivo C# chamado PrimeService_IsPrimeShould.cs com o seguinte conteúdo:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Prime.Services;

namespace Prime.UnitTests.Services
{
    [TestClass]
    public class PrimeService_IsPrimeShould
    {
        private readonly PrimeService _primeService;

        public PrimeService_IsPrimeShould()
        {
            _primeService = new PrimeService();
        }

        [TestMethod]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            bool result = _primeService.IsPrime(1);

            Assert.IsFalse(result, "1 shouldn't be prime");
        }
    }
}

O atributo TestClass indica uma classe que contém testes de unidade. O atributo TestMethod indica que um método é um método de teste.

O MSTest cria uma nova instância da classe de teste para cada teste, de modo que o construtor cria uma instância separada de PrimeService para cada teste. O construtor contém apenas a configuração necessária para cada teste nessa classe. Se os testes precisarem de uma configuração diferente, crie objetos nos métodos de teste ou chame métodos auxiliares nesses métodos. Para obter diretrizes, consulte Usar métodos auxiliares em vez de Setup e Teardown.

Salve esse arquivo e execute dotnet test para criar os testes e a biblioteca de classes e, em seguida, executar os testes. O executor de testes MSTest contém o ponto de entrada do programa para rodar seus testes. dotnet test inicia o executor de teste usando o projeto de teste de unidade que você criou.

O teste falha porque você ainda não criou a implementação. Faça esse teste passar escrevendo o código mais simples na classe PrimeService que funciona:

public bool IsPrime(int candidate)
{
    if (candidate == 1)
    {
        return false;
    }
    throw new NotImplementedException("Please create a test first.");
}

No diretório unit-testing-using-mstest , execute dotnet test novamente. O comando dotnet test executa um build para o projeto PrimeService e, em seguida, para o projeto PrimeService.Tests. Depois de compilar os dois projetos, ele executará esse teste único. Ele passa.

Adicionar mais recursos

Agora que você fez uma aprovação de teste, é hora de escrever mais. Há alguns outros casos simples para números primos: 0, -1. Você pode adicionar novos testes com o atributo TestMethod, mas isso rapidamente se torna entediante. Há outros atributos MSTest que permitem que você escreva um conjunto de testes semelhantes. Um método de teste pode executar o mesmo código, mas ter argumentos de entrada diferentes. Você pode usar o atributo DataRow para especificar valores para essas entradas.

Em vez de criar novos testes, aplique esses dois atributos para criar um único teste controlado por dados. O teste controlado por dados é um método que testa vários valores menores que dois, que é o número principal mais baixo. Adicione um novo método de teste em PrimeService_IsPrimeShould.cs:

[TestMethod]
[DataRow(-1)]
[DataRow(0)]
[DataRow(1)]
public void IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    bool result = _primeService.IsPrime(value);

    Assert.IsFalse(result, $"{value} should not be prime");
}

Execute dotnet teste dois desses testes falharão. Para que todos os testes passem, altere a if cláusula no início do IsPrime método no arquivo PrimeService.cs :

if (candidate < 2)

Continue a iterar adicionando mais testes, mais teorias e mais código na biblioteca principal. Você tem a versão concluída dos testes e a implementação completa da biblioteca.

Você criou uma pequena biblioteca e um conjunto de testes de unidade para essa biblioteca. Você estruturou a solução para que a adição de novos pacotes e testes faça parte do fluxo de trabalho normal. Você concentrou a maior parte do seu tempo e esforço na resolução das metas do aplicativo.

Executar testes no Azure Pipelines

Para executar seus testes automaticamente ao enviar alterações por push, adicione uma configuração de Azure Pipelines ao repositório que contém sua solução concluída. Você precisa de um projeto Azure DevOps e acesso a um agente hospedado por Microsoft. Para ver os pré-requisitos, consulte Crie seu primeiro pipeline.

1. Na raiz do repositório, crie um arquivo azure-pipelines.yml com o conteúdo a seguir. O exemplo pressupõe que os diretórios PrimeService e PrimeService.Tests estão na raiz do repositório e ambos os projetos têm como destino o .NET 10.

   trigger:
   - main
   
   pool:
     vmImage: ubuntu-latest
   
   steps:
   - task: UseDotNet@2
     displayName: Install .NET SDK
     inputs:
       packageType: sdk
       version: 10.0.x
   
   - task: DotNetCoreCLI@2
     displayName: Run MSTest tests
     inputs:
       command: test
       projects: PrimeService.Tests/PrimeService.Tests.csproj
       arguments: --configuration Release
       publishTestResults: true
   

2. Ajuste a configuração para corresponder ao repositório:

   • Se o branch tiver um nome diferente, substitua main em trigger por esse nome de branch.
   • Se a solução estiver em um subdiretório, atualize projects para o caminho do projeto de teste em relação à raiz do repositório.
   • Se seus projetos tiverem como destino uma versão do .NET diferente, altere version na tarefa UseDotNet@2 para corresponder. Por exemplo, use 8.0.x para projetos direcionados a net8.0. Se o repositório contiver um arquivo global.json, verifique se o SDK instalado atende aos requisitos de versão.

3. Faça commit e push da sua solução e do arquivo azure-pipelines.yml para o seu repositório Git.

4. Em seu projeto de Azure DevOps, selecione Pipelines>Novo pipeline ou Crie pipeline se for seu primeiro pipeline. Selecione seu provedor de repositório e repositório.

5. Na página Configurar seu pipeline, selecione Arquivo YAML existente do Azure Pipelines, selecione o branch e o repositório/azure-pipelines.yml, em seguida, selecione Continuar. Examine a configuração e selecione Executar.

A UseDotNet@2 tarefa instala o SDK do .NET. A DotNetCoreCLI@2 tarefa executa dotnet test, que restaura dependências, compila o projeto de teste e sua biblioteca referenciada e executa os testes na configuração Release.

Com publishTestResults: true, a tarefa gera um arquivo de resultados TRX e publica os resultados, mesmo que um teste falhe. Após a execução, abra a guia Testes da execução do pipeline para examinar os testes aprovados e com falha. Um teste com falha também faz com que a tarefa de teste e o pipeline falhem.

Note

Este exemplo usa a configuração padrão do dotnet new mstest VSTest com o SDK do .NET 10. Se você habilitar Microsoft. Testing.Platform (MTP), consulte Executar testes MTP na integração contínua para a configuração de executor necessária.

Consulte também

• Microsoft.VisualStudio.TestTools.UnitTesting
• Usar a estrutura MSTest em testes de unidade
• Documentos da estrutura de teste do MSTest V2