Teste de unidade C# com MSTest e .NET
Este tutorial leva você através de uma experiência interativa criando uma solução de exemplo passo a passo para aprender conceitos de teste de unidade. Se preferir seguir o tutorial usando uma solução pré-criada, visualize ou baixe o código de exemplo antes de começar. Para obter instruções de download, consulte Exemplos e tutoriais.
Este artigo é sobre como testar um projeto .NET Core. Se você estiver testando um projeto ASP.NET Core, consulte Testes de integração no ASP.NET Core.
Pré-requisitos
Criar o projeto de origem
Abra uma janela de shell. Crie um diretório chamado unit-testing-using-mstest para armazenar 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 . A estrutura de tópicos a seguir mostra o diretório e a estrutura de arquivos até agora:
/unit-testing-using-mstest
unit-testing-using-mstest.sln
/PrimeService
Faça do PrimeService o diretório atual e execute dotnet new classlib para criar o projeto de origem. Renomeie Class1.cs para PrimeService.cs. Substitua o código no arquivo com o 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.");
}
}
}
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
Criar o projeto de teste
Crie o diretório PrimeService.Tests . A estrutura de tópicos a seguir mostra a estrutura de diretórios:
/unit-testing-using-mstest
unit-testing-using-mstest.sln
/PrimeService
Source Files
PrimeService.csproj
/PrimeService.Tests
Faça do diretório PrimeService.Tests o diretório atual e crie um novo projeto usando dotnet new mstesto . O comando dotnet new 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="3.2.0" />
<PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="17.10.1" />
</ItemGroup>
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 relatórios de cobertura de código.
Adicione a biblioteca de PrimeService classes como outra dependência ao projeto. Use o dotnet add reference comando:
dotnet add reference ../PrimeService/PrimeService.csproj
Você pode ver o arquivo inteiro no repositório de amostras no GitHub.
A estrutura de tópicos a seguir mostra o layout 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
Mude 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, em seguida, 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 should not be prime");
}
}
}
O atributo TestClass denota uma classe que contém testes de unidade. O atributo TestMethod indica que um método é um método de teste.
Salve esse arquivo e execute dotnet test para criar os testes e a biblioteca de classes e, em seguida, execute os testes. O executor de teste MSTest contém o ponto de entrada do programa para executar seus testes. dotnet test Inicia o executor de teste usando o projeto de teste de unidade que você criou.
O seu teste falha. Você ainda não criou a implementação. Faça este teste passar escrevendo o PrimeService código mais simples na classe 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 dotnet test comando executa uma compilação para o PrimeService projeto e, em seguida, para o PrimeService.Tests projeto. Depois de construir ambos os projetos, ele executa esse teste único. Passa.
Adicionar mais funcionalidades
Agora que você fez um teste aprovado, é hora de escrever mais. Existem alguns outros casos simples para números primos: 0, -1. Você pode adicionar novos testes com o atributo TestMethod, mas isso rapidamente se torna tedioso. Existem outros atributos MSTest que permitem escrever 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 orientado por dados é um método que testa vários valores inferiores a dois, que é o número primo 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)
{
var result = _primeService.IsPrime(value);
Assert.IsFalse(result, $"{value} should not be prime");
}
Execute dotnet test, e dois desses testes falharão. Para que todos os testes sejam aprovados, altere a if cláusula no início do método no arquivo PrimeService.csIsPrime:
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 dos objetivos do aplicativo.
