Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
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é-construída, baixe ou visualize 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
- O mais recente SDK do .NET
- Editor de código do Visual Studio
- O Kit de Desenvolvimento C#
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. O esquema seguinte mostra o diretório e a estrutura de arquivos até ao momento.
/unit-testing-using-mstest
unit-testing-using-mstest.sln
/PrimeService
Faça PrimeService o diretório atual e execute dotnet new classlib para criar o projeto de origem.
Mude 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 com o seguinte código para criar uma implementação com falha da classe PrimeService:
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 esquema 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
<ItemGroup>
<PackageReference Include="MSTest" Version="4.1.0" />
</ItemGroup>
Note
As versões do pacote apresentadas são exemplos. As versões geradas por dotnet new mstest dependem do seu SDK .NET. Modelos e samples descarregados podem não usar as versões mais recentes dos pacotes NuGet.
Para verificar atualizações após criar e executar os seus testes, execute dotnet package list --outdated a partir do diretório do projeto de teste. Utilize dotnet package add <PACKAGE_NAME> para atualizar uma referência de pacote para a versão estável compatível mais recente. Revise as notas de atualização para alterações incompatíveis antes de atualizar, e execute dotnet test novamente depois.
Se usar o SDK .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 a geração de relatórios de cobertura de código.
Adicione a biblioteca de classes PrimeService como outra dependência ao projeto. Use o comando dotnet reference add:
dotnet reference add ../PrimeService/PrimeService.csproj
Você pode ver o arquivo inteiro no repositório de amostras no GitHub.
O esquema 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 que falha, faça-o passar e a seguir 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, pelo que o construtor cria uma PrimeService separada para cada teste. O construtor contém apenas a configuração que todos os testes desta classe necessitam. Se os teus testes precisarem de uma configuração diferente, cria objetos nos métodos de teste ou chama métodos auxiliares a partir desses métodos. Para orientações, veja 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, 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.
Seu teste falha porque você ainda não criou a implementação. Faça este 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 novamente dotnet test. O comando dotnet test executa uma compilação para o projeto PrimeService e, em seguida, para o projeto PrimeService.Tests. Depois de compilar ambos os projetos, ele executa este 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)
{
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 sejam aprovados, altere a cláusula if no início do método IsPrime 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 dos objetivos do aplicativo.
Run tests in Azure Pipelines
Para executar os seus testes automaticamente quando fizer push das alterações, adicione uma configuração do Azure Pipelines ao repositório que contém a sua solução concluída. Precisas de um projeto Azure DevOps e acesso a um agente hospedado pela Microsoft. Para conhecer os pré-requisitos, veja Criar o seu primeiro pipeline.
Na raiz do seu repositório, crie um
azure-pipelines.ymlficheiro com o seguinte conteúdo. O exemplo assume que os diretóriosPrimeServiceePrimeService.Testsestão na raiz do repositório e que ambos os projetos têm como objetivo 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: trueAjusta a configuração para corresponder ao teu repositório:
- Se a sua ramificação tiver um nome diferente, substitua
mainemtriggerpor esse nome da ramificação. - Se a sua solução estiver num subdiretório, atualize
projectspara o caminho do projeto de teste relativamente à raiz do repositório. - Se os teus projetos tiverem como alvo uma versão diferente do .NET, altera
versionna tarefaUseDotNet@2para corresponder. Por exemplo, use8.0.xpara projetos que visemnet8.0. Se o seu repositório contiver umglobal.jsonficheiro, certifique-se de que o SDK instalado cumpre os requisitos de versão.
- Se a sua ramificação tiver um nome diferente, substitua
Faz commit e faz push da tua solução e do ficheiro
azure-pipelines.ymlpara o teu repositório Git.No seu projeto Azure DevOps, selecione Pipelines>Novo pipeline, ou Criar pipeline se for o seu primeiro pipeline. Selecione o seu fornecedor de repositório e o repositório.
Na página Configurar o seu pipeline, selecione ficheiro YAML do Azure Pipelines existente, selecione o branch e
/azure-pipelines.yml, e depois selecione Continuar. Revê a configuração e seleciona Executar.
A UseDotNet@2 tarefa instala o SDK .NET.
DotNetCoreCLI@2A tarefa executa dotnet test, que restaura dependências, constrói o projeto de teste e a sua biblioteca referenciada, e executa os testes na configuração Release.
Com publishTestResults: true, a tarefa gera um ficheiro de resultados TRX e publica os resultados, mesmo que um teste falhe. Após a execução, abra o separador Testes da execução do pipeline para rever os testes aprovados e falhados. Um teste falhado também faz com que a tarefa de teste e o pipeline falhem.
Note
Este exemplo utiliza a configuração VSTest padrão de dotnet new mstest com o SDK .NET 10. Se ativar a Microsoft. Testing.Platform (MTP), veja Executar testes MTP em integração contínua para a configuração do runner necessária.