Tests unitaires C# avec TUnit et .NET

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.

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.

Prerequisites

  • .NET 10 SDK ou versions ultérieures.
  • Un éditeur de texte ou un éditeur de code de votre choix.

TUnit est entièrement basé sur Microsoft.Testing.Platform (MTP) et ne prend pas en charge VSTest. Ce tutoriel utilise le mode MTP de dotnet test, qui nécessite le sdk .NET 10.

Création du projet source

Ouvrez une fenêtre shell. Créez un répertoire appelé unit-testing-using-tunit 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-tunit
    unit-testing-using-tunit.slnx
    /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-tunit. 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-tunit
    unit-testing-using-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests

Les modèles de projet TUnit ne sont pas inclus dans le Kit de développement logiciel (SDK) .NET. Installez-les avec la commande suivante :

dotnet new install TUnit.Templates

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

dotnet new TUnit

Note

Les noms courts de modèle sont sensibles à la casse. Utilisez TUnit, pas tunit.

La commande dotnet new crée un projet de test qui utilise TUnit comme bibliothèque de tests. Le fichier PrimeService.Tests.csproj généré est un projet exécutable qui référence le TUnit package (le numéro de version peut différer) :

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

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

Le TUnit package inclut l’infrastructure de test, la bibliothèque d’assertions et l’exécuteur de test MTP. Le projet n’a donc pas besoin d’autres packages de test. Le modèle ajoute également des exemples de tests. Supprimez tous les fichiers .cs et le répertoire Data du répertoire PrimeService.Tests, car ce didacticiel les remplace par ses propres tests.

À présent, ajoutez la bibliothèque de classes PrimeService comme autre dépendance au projet. Utiliser la commande dotnet reference add :

dotnet reference add ../PrimeService/PrimeService.csproj

Le plan suivant montre la disposition finale de la solution :

/unit-testing-using-tunit
    unit-testing-using-tunit.slnx
    /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-tunit :

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

Configuration du mode MTP de dotnet test

Étant donné que TUnit ne prend pas en charge VSTest, dotnet test doit s’exécuter en mode MTP. Dans le répertoire unit-testing-using-tunit , créez un fichier global.json avec le contenu suivant :

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

Pour plus d’informations, consultez mode MTP de dotnet test.

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 , créez un fichier PrimeService_IsPrimeShould.cs avec le code suivant :

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’attribut [Test] indique qu’une méthode est une méthode de test. TUnit n’a pas besoin d’un attribut sur la classe. Les assertions TUnit sont asynchrones, de sorte que la méthode de test retourne un Task et attend Assert.That. Le TUnit package ajoute des directives globales using pour ses espaces de noms, de sorte que le fichier n’en a pas besoin.

Note

La directive using Prime.Services; se trouve à l’intérieur de l’espace de noms exprès. MTP génère le point d’entrée de l’application de test dans l’espace de noms racine du projet, PrimeService.Tests. Cet espace de noms masque la PrimeService classe d’une directive using en haut du fichier, mais pas d’une directive à l’intérieur de l’espace de noms.

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. Le projet de test TUnit contient le point d’entrée du programme pour exécuter vos tests. dotnet test démarre l’application 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-tunit , 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 réussi 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. TUnit fournit l’attribut [Arguments] pour créer une suite de tests qui exécutent le même code, mais qui ont des arguments d’entrée différents.

Au lieu de créer de nouveaux tests, appliquez cet attribut pour créer un seul test piloté par les données. Remplacez la méthode par le code IsPrime_InputIs1_ReturnFalse suivant. 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 :

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

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

if (candidate < 2)

Continuez à itérer en ajoutant d’autres tests et du code dans la bibliothèque principale.

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.

Voir aussi

  • Dernière mise à jour :