Partager via

Test unitaire C# avec NUnit et .NET Core

Ce tutoriel vous guide tout au long d’une expérience interactive qui crée un exemple de solution pas à pas pour apprendre les concepts de test unitaire. Si vous préférez suivre le didacticiel à l’aide d’une solution prédéfinie, afficher ou télécharger l’exemple de code avant de commencer. Pour obtenir des instructions de téléchargement, consultez Exemples et didacticiels.

Cet article concerne le test d’un projet .NET Core. Si vous testez un projet ASP.NET Core, consultez tests d’intégration dans ASP.NET Core.

Conditions préalables

Création du projet source

Ouvrez une fenêtre shell. Créez un répertoire appelé unit-testing-using-nunit pour contenir la solution. Dans ce nouveau répertoire, exécutez la commande suivante pour créer un fichier solution pour la bibliothèque de classes et le projet de test :

dotnet new sln

Ensuite, créez un répertoire PrimeService . Le plan suivant montre la structure de répertoire et de fichier jusqu’à présent :

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

Rendez PrimeService le répertoire actif et exécutez la commande suivante pour créer le projet source :

dotnet new classlib

Renommez Class1.cs en PrimeService.cs. Vous créez une implémentation défaillante de la classe PrimeService :

using System;

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

Revenez au répertoire unit-testing-using-nunit . Exécutez la commande suivante pour ajouter le projet de bibliothèque de classes à la solution :

dotnet sln add PrimeService/PrimeService.csproj

Création du projet de test

Ensuite, créez le répertoire PrimeService.Tests. Le plan suivant montre la structure de répertoires :

/unit-testing-using-nunit
    unit-testing-using-nunit.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests

Faites du répertoire PrimeService.Tests le répertoire actif et créez un projet à l’aide de la commande suivante :

dotnet new nunit

La commande dotnet new crée un projet de test qui utilise NUnit comme bibliothèque de tests. Le modèle généré configure l’exécuteur de test dans le fichier PrimeService.Tests.csproj :

<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" />
  <PackageReference Include="NUnit.Analyzers" Version="4.9.2">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
  </PackageReference>
</ItemGroup>

Remarque

Avant .NET 9, le code généré peut référencer des versions antérieures de l’infrastructure de test NUnit. Vous pouvez utiliser dotnet CLI pour mettre à jour les packages. Vous pouvez également ouvrir le fichier PrimeService.Tests.csproj et remplacer le contenu du groupe d'éléments de référence de package par le code ci-dessus.

Le projet de test nécessite d’autres packages pour créer et exécuter des tests unitaires. La dotnet new commande de l’étape précédente a ajouté le Kit de développement logiciel (SDK) de test Microsoft, l’infrastructure de test NUnit et l’adaptateur de test NUnit. À présent, ajoutez la bibliothèque de classes PrimeService comme autre dépendance au projet. Utilisez la commande dotnet reference add :

dotnet reference add ../PrimeService/PrimeService.csproj

Vous pouvez voir l’intégralité du fichier dans le référentiel d’exemples sur GitHub.

Le plan suivant montre la disposition finale de la solution :

/unit-testing-using-nunit
    unit-testing-using-nunit.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.csproj

Exécutez la commande suivante dans le répertoire unit-testing-using-nunit :

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

Création du premier test

Vous écrivez un test défaillant, faites-le passer, puis répétez le processus. Dans le répertoire PrimeService.Tests , renommez le fichier UnitTest1.cs en PrimeService_IsPrimeShould.cs et remplacez son contenu entier par le code suivant :

using NUnit.Framework;
using Prime.Services;

namespace Prime.UnitTests.Services
{
    [TestFixture]
    public class PrimeService_IsPrimeShould
    {
        private PrimeService _primeService;

        [SetUp]
        public void SetUp()
        {
            _primeService = new PrimeService();
        }

        [Test]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            var result = _primeService.IsPrime(1);

            Assert.That(result, Is.False, "1 should not be prime");
        }
    }
}

L’attribut [TestFixture] désigne une classe qui contient des tests unitaires. L’attribut [Test] indique qu’une méthode est une méthode de test.

Enregistrez ce fichier et exécutez la dotnet test commande pour générer les tests et la bibliothèque de classes et exécuter les tests. L’exécuteur de test NUnit contient le point d’entrée du programme pour exécuter vos tests. dotnet test démarre l’exécuteur de test à l’aide du projet de test unitaire que vous avez créé.

Votre test échoue. Vous n’avez pas encore créé l’implémentation. Faites passer le test en écrivant le code le plus simple dans la PrimeService classe qui fonctionne :

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

Dans le répertoire unit-testing-using-nunit , réexécutez dotnet test . La commande dotnet test exécute une build pour le projet PrimeService, puis pour le projet PrimeService.Tests. Après avoir généré les deux projets, il exécute ce test unique. Ça passe.

Ajout de fonctionnalités supplémentaires

Maintenant que vous avez passé un test, il est temps d’écrire plus. Il existe quelques autres cas simples pour les nombres premiers : 0, -1. Vous pouvez ajouter de nouveaux tests avec l’attribut [Test] , mais cela devient rapidement fastidieux. Il existe d’autres attributs NUnit qui vous permettent d’écrire une suite de tests similaires. Un [TestCase] attribut est utilisé pour créer une suite de tests qui exécutent le même code, mais qui ont des arguments d’entrée différents. Vous pouvez utiliser l’attribut [TestCase] pour spécifier des valeurs pour ces entrées.

Au lieu de créer de nouveaux tests, appliquez cet attribut pour créer un seul test piloté par les données. Le test piloté par les données est une méthode qui teste plusieurs valeurs inférieures à deux, qui est le nombre premier le plus bas :

[TestCase(-1)]
[TestCase(0)]
[TestCase(1)]
public void IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    var result = _primeService?.IsPrime(value);

    Assert.That(result, Is.False, $"{value} should not be prime");
}

Exécutez dotnet test, et deux de ces tests échouent. Pour passer tous les tests, modifiez la if clause au début de la Main méthode dans le fichier PrimeService.cs :

if (candidate < 2)

Continuez à itérer en ajoutant d’autres tests, théories et code dans la bibliothèque principale. Vous disposez de la version terminée des tests et de l’implémentation complète de la bibliothèque.

Vous avez créé une petite bibliothèque et un ensemble de tests unitaires pour cette bibliothèque. Vous avez également structuré la solution pour que l’ajout de nouveaux packages et tests fasse partie du flux de travail standard. Vous avez concentré la plupart de votre temps et votre effort sur la résolution des objectifs de l’application.