Unit test

Articolo
06/06/2024

Le app multipiattaforma devono essere testate perché verrebbero usate nel mondo reale per migliorare la qualità, l'affidabilità e le prestazioni. Molti tipi di test devono essere eseguiti in un'app, tra cui unit test, test di integrazione e test dell'interfaccia utente. Gli unit test sono il formato più comune ed è essenziale per la creazione di app di alta qualità.

Uno unit test accetta una piccola unità di un'app, in genere un metodo, lo isola dal resto del codice e verifica che si comporti come previsto. L'obiettivo è verificare che ogni unità di funzionalità venga eseguita come previsto, quindi gli errori non vengono propagati in tutta l'app. Il rilevamento di un bug in cui si verifica è più efficiente rispetto all'osservazione dell'effetto di un bug indirettamente in un punto secondario di errore.

Gli unit test devono in genere usare il modello arrange-act-assert:

Procedi	Descrizione
Disponi	Inizializzare gli oggetti e impostare il valore dei dati passati al metodo sottoposto a test.
Azione	Richiamare il metodo sottoposto a test con gli argomenti obbligatori.
Assert	Verificare che l'azione del metodo sottoposto a test si comporti come previsto.

Questo modello garantisce che gli unit test siano leggibili, autodescritti e coerenti.

Gli unit test hanno l'effetto più significativo sulla qualità del codice quando è parte integrante del flusso di lavoro di sviluppo software. Gli unit test possono fungere da documentazione di progettazione e specifiche funzionali per l'app. Non appena è stato scritto un metodo, gli unit test devono essere scritti per verificare il comportamento del metodo in risposta a casi di dati di input standard, limite e non corretti e verificare eventuali presupposti espliciti o impliciti effettuati dal codice. In alternativa, con lo sviluppo basato su test, gli unit test vengono scritti prima del codice.

Importante

Gli unit test sono molto efficaci rispetto alla regressione. Ovvero, funzionalità usate per funzionare, ma che sono state disturbate da un aggiornamento difettoso.

xUnit è il framework di test consigliato per le app MAUI .NET.

Aggiungere test xUnit a una soluzione MAUI .NET

Per aggiungere test xUnit alla soluzione MAUI .NET, eseguire una delle operazioni seguenti:

Usare Visual Studio per aggiungere un nuovo progetto di test xUnit alla soluzione.

OPPURE
Usare l'interfaccia della riga di comando di .NET per creare un nuovo progetto di test xUnit e aggiungerlo alla soluzione. Per altre informazioni, vedere Unit testing C# in .NET con dotnet test e xUnit.

Il file di progetto (con estensione csproj) per il progetto di test xUnit sarà simile all'esempio seguente:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="xunit" Version="2.5.3" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
  </ItemGroup>

  <ItemGroup>
    <Using Include="Xunit" />
  </ItemGroup>

</Project>

La $(TargetFramework) proprietà di compilazione specifica il framework di destinazione per il progetto di test. Questa sarà la versione più recente di .NET installata nel computer.

Il xunit pacchetto include pacchetti figlio che includono il framework di test stesso e analizzatori Roslyn che rilevano problemi comuni con gli unit test. I xunit.runner.visualstudio pacchetti e Microsoft.NET.Test.Sdk sono necessari per eseguire gli unit test in Visual Studio e con il dotnet test comando . I coverlet.collector pacchetti consentono di raccogliere code coverage. Se non si intende raccogliere il code coverage, è possibile rimuovere questo riferimento al pacchetto. Per altre informazioni sul code coverage per unit test, vedere Usare il code coverage per unit test.

Esistono due approcci principali per strutturare l'app per gli unit test:

Il codice che verrà unit test si trova in un progetto di libreria di classi MAUI .NET.
Il codice che verrà unit test si trova in un progetto di app MAUI .NET.

Ogni approccio richiede una configurazione specifica.

Configurare un progetto di libreria di classi MAUI .NET per unit test

Con questo approccio, il codice che si vuole eseguire unit test si trova in un progetto di libreria di classi MAUI .NET usato dal progetto di app MAUI .NET. Per scrivere unit test sulla libreria di classi MAUI .NET, è necessario aggiornare i framework di destinazione usati dal progetto. A tale scopo, è possibile aggiungere il valore della proprietà di $(TargetFramework) compilazione dal file di progetto di test xUnit (con estensione csproj) alla $(TargetFrameworks) proprietà di compilazione nel file di progetto della libreria di classi MAUI .NET:

<TargetFrameworks>net8.0;net8.0-android;net8.0-ios;net8.0-maccatalyst</TargetFrameworks>

In questo esempio è stato aggiunto un valore di alla $(TargetFrameworks) proprietà di compilazione nel file di progetto della libreria di net8.0 classi MAUI .NET.

È quindi necessario aggiungere un riferimento al progetto di libreria di classi MAUI .NET dal progetto di test xUnit.

Configurare un progetto di app .NET MAUI per unit test

Con questo approccio, il codice che si vuole eseguire unit test si trova in un progetto di app MAUI .NET. Per scrivere unit test sul progetto di app MAUI .NET, è necessario aggiornare i framework di destinazione usati dal progetto. A tale scopo, è possibile aggiungere il valore della proprietà di $(TargetFramework) compilazione dal file di progetto di test xUnit (con estensione csproj) alla $(TargetFrameworks) proprietà di compilazione nel file di progetto dell'app MAUI .NET:

<TargetFrameworks>net8.0;net8.0-android;net8.0-ios;net8.0-maccatalyst</TargetFrameworks>

In questo esempio è stato aggiunto un valore di net8.0 alla $(TargetFrameworks) proprietà di compilazione nel file di progetto dell'app MAUI .NET.

È anche necessario modificare il progetto di app MAUI .NET in modo che non restituisca un eseguibile per il framework di destinazione usato dal progetto di test xUnit. A tale scopo, è possibile aggiungere una condizione alla $(OutputType) proprietà di compilazione nel file di progetto dell'app MAUI .NET:

<OutputType Condition="'$(TargetFramework)' != 'net8.0'">Exe</OutputType>

In questo esempio, il progetto di app .NET MAUI produce solo un eseguibile quando il framework di destinazione non net8.0è .

È quindi necessario aggiungere un riferimento al progetto di app MAUI .NET dal progetto di test xUnit.

Scrivere unit test

xUnit supporta due tipi diversi di unit test:

Tipo di test	Attributo	Descrizione
Fatti	`Fact`	Test che sono sempre true, che testano condizioni invarianti.
Teorie	`Theory`	Test che sono true solo per un determinato set di dati.

Gli unit test devono essere inseriti nel progetto di test xUnit e devono essere decorati con l'attributo [Fact] o [Theory] . L'esempio seguente illustra gli unit test che usano l'attributo [Fact] :

namespace MyUnitTests
{
    public class MyTests
    {
        [Fact]
        public void PassingTest()
        {
            Assert.AreEqual(4, 2+2);
        }

        [Fact]
        public void FailingTest()
        {
            Assert.AreEqual(5, 2+2);
        }
    }
}

In questo esempio, i test rappresentano un test deliberatamente superato e non superato.

L'esempio seguente illustra gli unit test che usano l'attributo [Theory] :

namespace MyUnitTests
{
    public class MyTests
    {
        [Theory]
        [InlineData(3)]
        [InlineData(4)]
        [InlineData(5)]
        public void MyTheoryTest(int value)
        {
            Assert.True(value % 2 == 1);
        }
    }
}

In questo esempio, anche se è presente un solo metodo di test, esistono in realtà tre test perché la teoria verrà eseguita una volta per ogni elemento di dati.

Suggerimento

Testare un'operazione con ogni unit test. Man mano che la complessità di un test si espande, rende più difficile la verifica di tale test. Limitando uno unit test a un singolo problema, è possibile assicurarsi che i test siano ripetibili, isolati e abbiano un tempo di esecuzione più breve. Per altre informazioni, vedere Procedure consigliate per unit test.

Esecuzione di unit test

Gli unit test possono essere eseguiti in Esplora test in Visual Studio o con il dotnet test comando . Per informazioni su Esplora test, vedere Eseguire unit test con Esplora test. Per informazioni sul dotnet test comando, vedere Unit testing C# in .NET con dotnet test e xUnit e dotnet test.

Eseguire unit test usando gli strumenti di esecuzione dei dispositivi

Gli unit test possono anche essere eseguiti in un dispositivo con uno strumento di esecuzione dei dispositivi. Uno strumento di esecuzione dei dispositivi è un'app di test runner che fornisce una shell dello strumento di esecuzione visivo e alcuni hook da eseguire dall'interfaccia della riga di comando usando XHarness. Per altre informazioni, vedere la documentazione nel wiki Test device runners (Strumenti di esecuzione dispositivi di test).

Condividi tramite