Test unitari delle librerie .NET Core di Visual Basic usando dotnet test e NUnit

2025-04-16

Questa esercitazione illustra un'esperienza interattiva che crea una soluzione di esempio dettagliata per apprendere i concetti di unit test. Se preferisci seguire il tutorial usando una soluzione predefinita, visualizza o scarica il codice di esempio prima di iniziare. Per istruzioni sul download, vedere esempi ed esercitazioni .

Questo articolo descrive il test di un progetto .NET Core. Se si sta testando un progetto ASP.NET Core, vedere test di integrazione in ASP.NET Core.

Prerequisiti

.NET 8 SDK o versioni successive.
Un editor di testo o editor di codice di propria scelta.

Creazione del progetto di origine

Aprire una finestra della shell. Creare una directory denominata unit-testing-vb-nunit per contenere la soluzione. In questa nuova directory eseguire il comando seguente per creare un nuovo file di soluzione per la libreria di classi e il progetto di test:

dotnet new sln

Creare quindi una directory PrimeService . Il seguente schema mostra finora la struttura del file.

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

Impostare PrimeService sulla directory corrente ed eseguire il comando seguente per creare il progetto di origine:

dotnet new classlib -lang VB

Rinominare Class1.VB in PrimeService.VB. Si crea un'implementazione non riuscita della 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

Tornare alla directory unit-testing-vb-using-mstest directory. Eseguire il comando seguente per aggiungere il progetto di libreria di classi alla soluzione:

dotnet sln add .\PrimeService\PrimeService.vbproj

Creazione del progetto di test

Creare quindi la directory PrimeService.Tests. La seguente illustrazione mostra la struttura della directory:

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

Impostare la directory PrimeService.Tests nella directory corrente e creare un nuovo progetto usando il comando seguente:

dotnet new nunit -lang VB

Il comando dotnet new crea un progetto di test che usa NUnit come libreria di test. Il modello generato configura il test runner nel file 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>

Annotazioni

Prima di .NET 9, il codice generato può fare riferimento a versioni precedenti del framework di test NUnit. È possibile usare l'interfaccia della riga di comando dotnet per aggiornare i pacchetti. In alternativa, aprire il file PrimeService.Tests.vbproj e sostituire il contenuto del gruppo di elementi dei riferimenti al pacchetto con il codice precedente.

Il progetto di test richiede altri pacchetti per creare ed eseguire unit test. dotnet new nel passaggio precedente sono stati aggiunti NUnit e l'adattatore di test NUnit. Aggiungere ora la libreria di classi PrimeService come altra dipendenza al progetto. Usare il comando dotnet reference add:

dotnet reference add ../PrimeService/PrimeService.vbproj

È possibile visualizzare l'intero file nel repository degli esempi su GitHub.

Il layout finale della soluzione è il seguente:

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

Eseguire il comando seguente nella directory unit-testing-vb-nunit :

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

Creazione del primo test

Si scrive un test con esito negativo, si passa, quindi si ripete il processo. Nella directory PrimeService.Tests rinominare il file UnitTest1.vb in PrimeService_IsPrimeShould.VB e sostituirne l'intero contenuto con il codice seguente:

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

L'attributo <TestFixture> indica una classe che contiene test. L'attributo <Test> indica un metodo eseguito dal test runner. Dall'unit-testing-vb-nunit eseguire dotnet test per compilare i test e la libreria di classi e quindi eseguire i test. Il test runner NUnit contiene il punto di ingresso del programma per eseguire i test. dotnet test avvia lo strumento di esecuzione dei test usando il progetto di test unitario che hai creato.

Il tuo test fallisce. L'implementazione non è ancora stata creata. Eseguire questo test scrivendo il codice più semplice nella classe PrimeService che funziona:

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

Nella directory unit-testing-vb-nunit eseguire dotnet test di nuovo. Il comando dotnet test esegue una compilazione per il progetto PrimeService e quindi per il progetto PrimeService.Tests. Dopo la compilazione di entrambi i progetti, viene eseguito questo singolo test. Passa.

Aggiunta di altre funzionalità

Ora che hai superato un test, è il momento di scrivere altri test. Esistono alcuni altri semplici casi per i numeri primi: 0, -1. È possibile aggiungere questi casi come nuovi test con l'attributo <Test>, ma questo diventa rapidamente noioso. Esistono altri attributi xUnit che consentono di scrivere una suite di test simili. Un <TestCase> attributo rappresenta una suite di test che eseguono lo stesso codice ma hanno argomenti di input diversi. È possibile usare l'attributo <TestCase> per specificare i valori per tali input.

Anziché creare nuovi test, applicare questi due attributi per creare una serie di test che testano diversi valori minori di due, ovvero il numero primo più basso:

<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

Esegui dotnet test e due di questi test falliscono. Per far superare tutti i test, modificare la if clausola all'inizio del Main metodo nel file PrimeServices.cs :

if candidate < 2

Continuare a eseguire l'iterazione aggiungendo altri test, altre teorie e altro codice nella libreria principale. È stata completata la versione dei test e l'implementazione completa della libreria.

Hai creato una piccola libreria e un set di test unitari per tale libreria. La soluzione è stata strutturata in modo che l'aggiunta di nuovi pacchetti e test faccia parte del normale flusso di lavoro. La maggior parte del tempo e dello sforzo è stata concentrata sulla risoluzione degli obiettivi dell'applicazione.