Teste de unidade de bibliotecas do Visual Basic .NET usando dotnet test e TUnit

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.

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.

Prerequisites

  • .NET 10 SDK ou versões posteriores.
  • Um editor de texto ou editor de código de sua escolha.

O TUnit é baseado inteiramente em Microsoft.Testing.Platform (MTP) e não dá suporte ao VSTest. Este tutorial usa o modo MTP dedotnet test, que requer o SDK .NET 10.

Criando o projeto de origem

Abra uma janela do shell. Crie um diretório chamado unit-testing-vb-tunit para manter 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 esboço a seguir mostra a estrutura do arquivo até agora.

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

Torne o PrimeService o diretório atual e execute o seguinte comando para criar o projeto de origem:

dotnet new classlib -lang VB

Renomeie Class1.vb para PrimeService.vb. Você cria uma implementação com falha da classe PrimeService:

Namespace Prime.Services
    Public Class PrimeService
        Public Function IsPrime(candidate As Integer) As Boolean
            Throw New NotImplementedException("Please create a test first.")
        End Function
    End Class
End Namespace

Altere o diretório de volta para o diretório unit-testing-vb-tunit . Execute o seguinte comando para adicionar o projeto de biblioteca de classes à solução:

dotnet sln add ./PrimeService/PrimeService.vbproj

Criando o projeto de teste

Em seguida, crie o diretório PrimeService.Tests. O seguinte esquema mostra a estrutura do diretório:

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests

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

dotnet new install TUnit.Templates

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

dotnet new TUnit -lang VB

Note

Nomes curtos de modelo diferenciam entre maiúsculas e minúsculas. Use TUnit, não tunit.

O comando dotnet new cria um projeto de teste que usa o TUnit como a biblioteca de teste. O arquivo PrimeService.Tests.vbproj gerado é um projeto executável que faz referência ao pacote TUnit, que inclui a estrutura de teste, a biblioteca de asserções e o executor de teste do MTP, para que o projeto não precise de nenhum outro pacote de teste.

O modelo também adiciona testes de exemplo. Exclua todos os arquivos .vb e o diretório Data do diretório PrimeService.Tests, pois este tutorial os substitui por seus próprios testes.

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

dotnet reference add ../PrimeService/PrimeService.vbproj

Você tem o seguinte layout de solução final:

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.vbproj

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

dotnet sln add ./PrimeService.Tests/PrimeService.Tests.vbproj

Configurando o modo MTP do dotnet test

Como o TUnit não dá suporte ao VSTest, dotnet test deve ser executado em seu modo MTP. No diretório unit-testing-vb-tunit , crie um arquivo global.json com o seguinte conteúdo:

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

Para obter mais informações, consulte o modo MTP de dotnet test.

Criando o primeiro teste

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

Imports TUnit.Assertions
Imports TUnit.Assertions.Extensions
Imports TUnit.Core

Namespace PrimeService.Tests
    Public Class PrimeService_IsPrimeShould
        Private ReadOnly _primeService As Prime.Services.PrimeService = New Prime.Services.PrimeService()

        <Test>
        Public Async Function IsPrime_InputIs1_ReturnFalse() As Task
            Dim result As Boolean = _primeService.IsPrime(1)

            Await Assert.That(result).IsFalse()
        End Function

    End Class
End Namespace

O atributo <Test> indica um método executado pelo executor de teste. O TUnit não precisa de um atributo na classe. As asserções de TUnit são assíncronas, portanto, o teste é um método assíncrono Async Function que retorna um Task e aguarda Assert.That.

Visual Basic coloca o código em cada projeto no namespace raiz do projeto, portanto, a PrimeService classe está no PrimeService.Prime.Services namespace. O teste se refere a ele como Prime.Services.PrimeService, porque, dentro dos namespaces do projeto de teste, o nome PrimeService refere-se a um namespace em vez da classe.

No diretório unit-testing-vb-tunit, execute dotnet test para criar os testes e a biblioteca de classes e, em seguida, executar os testes. O projeto de teste do TUnit contém o ponto de entrada do programa para executar seus testes. dotnet test inicia o aplicativo de teste usando o projeto de teste de unidade que você criou.

O teste falha. 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 Function IsPrime(candidate As Integer) As Boolean
    If candidate = 1 Then
        Return False
    End If
    Throw New NotImplementedException("Please create a test first.")
End Function

No diretório unit-testing-vb-tunit , 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.

Adicionando mais recursos

Agora que você fez um teste aprovado, é hora de escrever mais. Há alguns outros casos simples para números primos: 0, -1. Você pode adicionar esses casos como novos testes com o atributo <Test>, mas isso rapidamente se torna entediante. 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 a função IsPrime_InputIs1_ReturnFalse pelo código a seguir, que testa vários valores menores que dois, o número primo mais baixo:

<Test>
<Arguments(-1)>
<Arguments(0)>
<Arguments(1)>
Public Async Function IsPrime_ValuesLessThan2_ReturnFalse(value As Integer) As Task
    Dim result As Boolean = _primeService.IsPrime(value)

    Await Assert.That(result).IsFalse()
End Function

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.vb :

If candidate < 2 Then

Continue a iterar adicionando mais testes e mais códigos na biblioteca principal.

Você criou uma pequena biblioteca e um conjunto de testes unitários 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.

Consulte também

  • Última atualização em