Unit test di C# con TUnit e .NET

Questa esercitazione illustra un'esperienza interattiva che crea una soluzione di esempio dettagliata per apprendere i concetti di unit test.

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.

Prerequisites

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

TUnit è interamente costruito su Microsoft.Testing.Platform (MTP) e non supporta VSTest. Questa esercitazione usa la modalità MTP di dotnet test, che richiede l'SDK .NET 10.

Creazione del progetto di origine

Aprire una finestra della shell. Creare una directory denominata unit-testing-using-tunit 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 la struttura di directory e file:

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

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

dotnet new classlib

Rinominare Class1.cs in PrimeService.cs. Si crea un'implementazione non riuscita della classe PrimeService:

using System;

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

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

dotnet sln add PrimeService/PrimeService.csproj

Creazione del progetto di test

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

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

I modelli di progetto TUnit non sono inclusi nell'SDK di .NET. Installarli con il comando seguente:

dotnet new install TUnit.Templates

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

dotnet new TUnit

Il comando dotnet new crea un progetto di test che usa TUnit come libreria di test. Il file PrimeService.Tests.csproj generato è un progetto eseguibile che fa riferimento al pacchetto TUnit (il numero di versione potrebbe differire):

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

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

Il TUnit pacchetto include il framework di test, la libreria di asserzioni e lo strumento di esecuzione dei test MTP, quindi il progetto non necessita di altri pacchetti di test. Il modello aggiunge anche test di esempio. Eliminare tutti i file .cs e la directory Data dalla directory PrimeService.Tests , perché questa esercitazione li sostituisce con i propri test.

Aggiungere ora la libreria di classi PrimeService come altra dipendenza al progetto. Usare il comando dotnet reference add:

dotnet reference add ../PrimeService/PrimeService.csproj

La struttura seguente illustra il layout finale della soluzione:

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

Eseguire il comando seguente nella directory unit-testing-using-tunit :

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

Configurazione della modalità MTP di dotnet test

Poiché TUnit non supporta VSTest, dotnet test deve essere eseguito nella modalità MTP. Nella directory unit-testing-using-tunit creare un file global.json con il contenuto seguente:

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

Per altre informazioni, vedere Modalità MTP del test dotnet.

Creazione del primo test

Si scrive un test con esito negativo, si passa e quindi si ripete il processo. Nella directory PrimeService.Tests creare un file PrimeService_IsPrimeShould.cs con il codice seguente:

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();
        }
    }
}

L'attributo [Test] indica che un metodo è un metodo di test. TUnit non richiede un attributo nella classe . Le asserzioni TUnit sono asincrone, quindi il metodo di test restituisce un Assert.That e attende Task. Il TUnit pacchetto aggiunge direttive globali using per i relativi spazi dei nomi, quindi il file non ne ha bisogno.

Salvare questo file ed eseguire il dotnet test comando per compilare i test e la libreria di classi ed eseguire i test. Il progetto di test TUnit contiene il punto di ingresso del programma per eseguire i test. Questo comando dotnet test avvia l'applicazione di test usando il progetto di unit test creato.

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

public bool IsPrime(int candidate)
{
    if (candidate == 1)
    {
        return false;
    }
    throw new NotImplementedException("Please create a test first.");
}

Nella directory unit-testing-using-tunit eseguire dotnet test di nuovo. Il comando dotnet test esegue una compilazione per il progetto PrimeService e quindi per il progetto PrimeService.Tests. Dopo aver compilato 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 nuovi test con l'attributo [Test] , ma questo diventa rapidamente noioso. TUnit fornisce l'attributo [Arguments] per creare una suite di test che eseguono lo stesso codice ma hanno argomenti di input diversi.

Anziché creare nuovi test, applicare questo attributo per creare un singolo test basato sui dati. Sostituire il IsPrime_InputIs1_ReturnFalse metodo con il codice seguente. Il test basato sui dati è un metodo che verifica diversi valori minori di due, ovvero il numero primo più basso:

[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();
}

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

if (candidate < 2)

Continuare a eseguire l'iterazione aggiungendo altri test e codice nella libreria principale.

Hai costruito una piccola libreria e un set di unit test per quella libreria. È stata strutturata anche la soluzione in modo che l'aggiunta di nuovi pacchetti e test faccia parte del flusso di lavoro standard. La maggior parte del tempo e dello sforzo è stata concentrata sulla risoluzione degli obiettivi dell'applicazione.

Vedere anche

• Documentazione di TUnit
• Eseguire unit test selezionati
• Esegui test di unità
• dotnet aggiungi riferimento
• di test dotnet