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

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

• 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:

.NET CLI

dotnet new sln

Em seguida, crie um diretório PrimeService . A estrutura de tópicos a seguir mostra a estrutura do arquivo até agora:

Console

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

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

.NET CLI

dotnet new classlib -lang VB

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

VB

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-using-mstest . Execute o seguinte comando para adicionar o projeto de biblioteca de classes à solução:

.NET CLI

dotnet sln add .\PrimeService\PrimeService.vbproj

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:

Console

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

Faça do diretório PrimeService.Tests o diretório atual e crie um novo projeto usando o seguinte comando:

.NET CLI

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 :

XML

<ItemGroup>
  <PackageReference Include="nunit" Version="4.3.2" />
  <PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
</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.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 na etapa anterior adicionado 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:

.NET CLI

dotnet add reference ../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:

Console

/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 :

.NET CLI

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

Criando o primeiro teste

Você escreve um teste com reprovação, faz com que seja aprovado e, em seguida, repita 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:

VB

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 <TestFixture> atributo indica uma classe que contém testes. O <Test> atributo 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 PrimeService código mais simples na classe que funciona:

VB

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 dotnet test comando executa uma compilação para o PrimeService projeto e, em seguida, para o PrimeService.Tests projeto. Depois de construir 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ê poderia adicionar esses casos como novos testes com o atributo, mas isso rapidamente se torna tedioso <Test> . 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 <TestCase> atributo 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:

VB

<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 test, e 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 :

VB

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.