Teste de unidade de bibliotecas do Visual Basic .NET Core usando o teste dotnet e o NUnit

2025-04-08

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

SDK do .NET 8 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-vb-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. O esquema a seguir mostra a estrutura do arquivo até agora.

/unit-testing-vb-nunit
    unit-testing-vb-nunit.sln
    /PrimeService

Faça 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 para o diretório unit-testing-vb-using-mstest novamente. 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 esquema a seguir mostra a estrutura de diretórios:

/unit-testing-vb-nunit
    unit-testing-vb-nunit.sln
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests

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

dotnet new nunit -lang VB

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 PrimeServiceTests.vbproj :

<ItemGroup>
  <PackageReference Include="nunit" Version="4.3.2" />
  <PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
</ItemGroup>

Observação

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 a CLI dotnet para atualizar os pacotes. Como alternativa, abra o arquivo PrimeService.Tests.vbproj 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. dotnet new adicionou o NUnit e o adaptador de teste NUnit na etapa anterior. 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ê pode ver o arquivo inteiro no repositório de amostras no GitHub.

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

/unit-testing-vb-nunit
    unit-testing-vb-nunit.sln
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.vbproj

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

dotnet sln add .\PrimeService.Tests\PrimeService.Tests.vbproj

Criando o primeiro teste

Você escreve um teste que falha, faz com que ele passe, e, em seguida, repete o processo. No diretório PrimeService.Tests , renomeie o arquivo UnitTest1.vb para PrimeService_IsPrimeShould.VB e substitua todo o seu conteúdo pelo seguinte código:

Imports NUnit.Framework

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

        <Test>
        Sub IsPrime_InputIs1_ReturnFalse()
            Dim result As Boolean = _primeService.IsPrime(1)

            Assert.That(result, [Is].False, $"1 should not be prime")
        End Sub

    End Class
End Namespace

O atributo <TestFixture> indica uma classe que contém testes. O atributo <Test> indica um método que é executado pelo executor de teste. A partir do unit-testing-vb-nunit, execute dotnet test para construir os testes e a biblioteca de classes e, em seguida, execute 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 este 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-nunit , 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 ú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 esses casos como novos testes com o atributo <Test>, mas isso rapidamente se torna tedioso. Existem outros atributos xUnit que permitem escrever um conjunto de testes semelhantes. Um <TestCase> atributo representa um conjunto de testes que executam o mesmo código, mas têm argumentos de entrada diferentes. Você pode usar o atributo <TestCase> para especificar valores para essas entradas.

Em vez de criar novos testes, aplique esses dois atributos para criar uma série de testes que testam vários valores menores que dois, que é o número primo mais baixo:

<TestFixture>
Public Class PrimeService_IsPrimeShould
    Private _primeService As Prime.Services.PrimeService = New Prime.Services.PrimeService()

    <TestCase(-1)>
    <TestCase(0)>
    <TestCase(1)>
    Sub IsPrime_ValuesLessThan2_ReturnFalse(value As Integer)
        Dim result As Boolean = _primeService.IsPrime(value)

        Assert.That(result, [Is].False, $"{value} should not be prime")
    End Sub

    <TestCase(2)>
    <TestCase(3)>
    <TestCase(5)>
    <TestCase(7)>
    Public Sub IsPrime_PrimesLessThan10_ReturnTrue(value As Integer)
        Dim result As Boolean = _primeService.IsPrime(value)

        Assert.That(result, [Is].True, $"{value} should be prime")
    End Sub

    <TestCase(4)>
    <TestCase(6)>
    <TestCase(8)>
    <TestCase(9)>
    Public Sub IsPrime_NonPrimesLessThan10_ReturnFalse(value As Integer)
        Dim result As Boolean = _primeService.IsPrime(value)

        Assert.That(result, [Is].False, $"{value} should not be prime")
    End Sub
End Class

Execute dotnet teste dois desses testes falharão. Para que todos os testes sejam aprovados, altere a if cláusula no início do Main método no arquivo PrimeServices.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 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 dos objetivos do aplicativo.

Partilhar via