Unit testing C# with NUnit and .NET Core (Testes de unidades em C# com NUnit e .NET Core)

Artigo
04/05/2024

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

.NET 8.0 ou versões posteriores.
Um editor de texto ou editor de código da sua preferência.

Criando o projeto de origem

Abra uma janela de shell. Crie um diretório chamado unit-testing-using-nunit para armazenar a solução. Dentro desse novo diretório, execute o seguinte comando para criar um novo arquivo de solução para a biblioteca de classes e o projeto de teste:

dotnet new sln

Em seguida, 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-nunit
    unit-testing-using-nunit.sln
    /PrimeService

Faça do PrimeService o diretório atual e execute o seguinte comando para criar o projeto de origem:

dotnet new classlib

Renomeie Class1.cs para PrimeService.cs. Você cria 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-nunit . Execute o seguinte comando para adicionar o projeto de biblioteca de classes à solução:

dotnet sln add PrimeService/PrimeService.csproj

Criando o projeto de teste

Em seguida, crie o diretório PrimeService.Tests . A estrutura de tópicos a seguir mostra a estrutura de diretórios:

/unit-testing-using-nunit
    unit-testing-using-nunit.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 o seguinte comando:

dotnet new nunit

O comando dotnet new cria um projeto de teste que usa NUnit como a biblioteca de teste. O modelo gerado configura o executor de teste no arquivo PrimeService.Tests.csproj :

<ItemGroup>
  <PackageReference Include="nunit" Version="4.2.2" />
  <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
  <PackageReference Include="NUnit.Analyzers" Version="4.3.0">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
  </PackageReference>
</ItemGroup>

Nota

Antes do .NET 9, o código gerado pode fazer referência a versões mais antigas da estrutura de teste NUnit. Você pode usar dotnet CLI para atualizar os pacotes. Como alternativa, abra o arquivo PrimeService.Tests.csproj e substitua o conteúdo do grupo de itens de referências de pacote pelo código acima.

O projeto de teste requer outros pacotes para criar e executar testes de unidade. O dotnet new comando na etapa anterior adicionou o SDK de teste da Microsoft, a estrutura de teste NUnit e o adaptador de teste NUnit. Agora, 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-nunit
    unit-testing-using-nunit.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.csproj

Execute o seguinte comando no diretório unit-testing-using-nunit :

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

Criando o primeiro teste

Você escreve um teste com reprovação, faz com que ele seja aprovado e, em seguida, repita o processo. No diretório PrimeService.Tests, renomeie o arquivo UnitTest1.cs para PrimeService_IsPrimeShould.cs e substitua todo o seu conteúdo pelo seguinte código:

using NUnit.Framework;
using Prime.Services;

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

        [SetUp]
        public void SetUp()
        {
            _primeService = new PrimeService();
        }

        [Test]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            var result = _primeService.IsPrime(1);

            Assert.That(result, Is.False, "1 should not be prime");
        }
    }
}

O [TestFixture] atributo denota uma classe que contém testes de unidade. O [Test] atributo indica que um método é um método de teste.

Salve esse arquivo e execute o dotnet test comando para criar os testes e a biblioteca de classes e executar os testes. O executor de teste NUnit 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 o teste passar escrevendo o código mais simples na PrimeService 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-nunit, 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 criar ambos os projetos, ele executa esse teste único. Passa.

Adicionando mais recursos

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, mas isso rapidamente se torna tedioso [Test] . Existem outros atributos NUnit que permitem escrever um conjunto de testes semelhantes. Um [TestCase] atributo é usado para criar um conjunto de testes que executam o mesmo código, mas têm argumentos de entrada diferentes. Você pode usar o [TestCase] atributo para especificar valores para essas entradas.

Em vez de criar novos testes, aplique esse atributo para criar um único teste controlado por dados. O teste orientado por dados é um método que testa vários valores menores que dois, que é o número primo mais baixo:

[TestCase(-1)]
[TestCase(0)]
[TestCase(1)]
public void IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    var result = _primeService?.IsPrime(value);

    Assert.That(result, Is.False, $"{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.csMain:

if (candidate < 2)

Continue a iterar adicionando mais testes, teorias e 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ê também estruturou a solução para que a adição de novos pacotes e testes faça parte do fluxo de trabalho padrão. Você concentrou a maior parte do seu tempo e esforço na resolução dos objetivos do aplicativo.

Partilhar via