Testes unitários em C# com TUnit 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.

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.

Prerequisites

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

O TUnit é inteiramente baseado em Microsoft.Testing.Platform (MTP) e não suporta VSTest. Este tutorial utiliza o modo MTP de dotnet test, que requer o SDK .NET 10.

Criando o projeto de origem

Abra uma janela de terminal. Crie um diretório chamado unit-testing-using-tunit 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. O seguinte esboço apresenta o diretório e a estrutura de ficheiros até agora:

/unit-testing-using-tunit
    unit-testing-using-tunit.slnx
    /PrimeService

Faça 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 classe PrimeService:

using System;

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

Mude o diretório de volta para o diretório unit-testing-using-tunit . 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. O esquema a seguir mostra a estrutura de diretórios:

/unit-testing-using-tunit
    unit-testing-using-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests

Os modelos de projeto TUnit não estão incluídos no SDK .NET. Instale-os com o seguinte comando:

dotnet new install TUnit.Templates

Altere o diretório para o diretório PrimeService.Tests e crie um novo projeto usando o seguinte comando:

dotnet new TUnit

Note

Os nomes curtos do modelo são sensíveis a maiúsculas e minúsculas. Use TUnit, não tunit.

O comando dotnet new cria um projeto de teste que usa o TUnit como biblioteca de teste. O ficheiro PrimeService.Tests.csproj gerado é um projeto executável que faz referência ao TUnit pacote (o número de versão pode variar):

<PropertyGroup>
  <ImplicitUsings>enable</ImplicitUsings>
  <Nullable>enable</Nullable>
  <OutputType>Exe</OutputType>
  <TargetFramework>net10.0</TargetFramework>
</PropertyGroup>

<ItemGroup>
  <PackageReference Include="TUnit" Version="1.*" />
</ItemGroup>

O TUnit pacote inclui o framework de teste, a biblioteca de asserções e o executor de testes MTP, por isso o projeto não precisa de outros pacotes de teste. O modelo também adiciona testes de exemplo. Apaga todos os ficheiros .cs e o diretório Data do diretório PrimeService.Tests , porque este tutorial substitui-os pelos seus próprios testes.

Agora, adicione a biblioteca de classes PrimeService como outra dependência ao projeto. Utilize o comando dotnet reference add:

dotnet reference add ../PrimeService/PrimeService.csproj

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

/unit-testing-using-tunit
    unit-testing-using-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.csproj

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

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

Configuração do modo MTP do dotnet test

Como o TUnit não suporta VSTest, dotnet test tem de correr no seu modo MTP. No diretório unit-testing-using-tunit , crie um ficheiro global.json com o seguinte conteúdo:

{
    "test": {
        "runner": "Microsoft.Testing.Platform"
    }
}

Para mais informações, veja o modo MTP do dotnet test.

Criando o primeiro teste

Você escreve um teste que falha, faz com que ele passe, e depois repete o processo. No diretório PrimeService.Tests , crie um ficheiro PrimeService_IsPrimeShould.cs com o seguinte código:

namespace Prime.UnitTests.Services
{
    using Prime.Services;

    public class PrimeService_IsPrimeShould
    {
        private readonly PrimeService _primeService = new();

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

            await Assert.That(result).IsFalse();
        }
    }
}

O atributo [Test] indica que um método é um método de teste. O TUnit não precisa de um atributo na classe. As asserções TUnit são assíncronas, pelo que o método de teste retorna a Task e aguarda Assert.That. O TUnit pacote adiciona diretivas globais using para os seus namespaces, por isso o ficheiro não precisa delas.

Note

A using Prime.Services; directive está dentro do namespace de propósito. O MTP gera o ponto de entrada da aplicação de teste no espaço de nomes raiz do projeto, PrimeService.Tests. Esse namespace esconde a PrimeService classe de uma using diretiva no topo do ficheiro, mas não de uma dentro do namespace.

Salve esse arquivo e execute o comando dotnet test para criar os testes e a biblioteca de classes e executar os testes. O projeto de teste TUnit contém o ponto de entrada do programa para executar os seus testes. dotnet test Inicia a aplicação de teste usando o projeto de teste unitário que criaste.

O seu teste falha. Você ainda não criou a implementação. Faça o 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-tunit , execute dotnet test novamente. 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 individual. 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 [Test], mas isso rapidamente se torna tedioso. O TUnit fornece o [Arguments] atributo para criar um conjunto de testes que executam o mesmo código mas têm argumentos de entrada diferentes.

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

[Test]
[Arguments(-1)]
[Arguments(0)]
[Arguments(1)]
public async Task IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    var result = _primeService.IsPrime(value);

    await Assert.That(result).IsFalse();
}

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 e código na biblioteca principal.

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.

Ver também