Partager via

Test unitaire C# dans .NET à l’aide de dotnet test et xUnit

Ce tutoriel montre comment créer une solution contenant un projet de test unitaire et un projet de code source. Pour suivre le tutoriel à l’aide d’une solution prédéfinie, affichez ou téléchargez l’exemple de code. Pour obtenir des instructions de téléchargement, consultez Exemples et didacticiels.

Créer la solution

Dans cette section, une solution est créée qui contient les projets source et de test. La solution terminée a la structure de répertoire suivante :

/unit-testing-using-dotnet-test
    unit-testing-using-dotnet-test.sln
    /PrimeService
        PrimeService.cs
        PrimeService.csproj
    /PrimeService.Tests
        PrimeService_IsPrimeShould.cs
        PrimeServiceTests.csproj

Les instructions suivantes fournissent les étapes de création de la solution de test. Consultez Commandes pour créer une solution de test pour obtenir des instructions pour créer la solution de test en une seule étape.

  • Ouvrez une fenêtre shell.

  • Exécutez la commande suivante:

    dotnet new sln -o unit-testing-using-dotnet-test

    La dotnet new sln commande crée une solution dans le répertoire unit-testing-using-dotnet-test .

  • Remplacez le répertoire par le dossier unit-testing-using-dotnet-test .

  • Exécutez la commande suivante:

    dotnet new classlib -o PrimeService

    La dotnet new classlib commande crée un projet de bibliothèque de classes dans le dossier PrimeService . La nouvelle bibliothèque de classes contient le code à tester.

  • Renommez Class1.cs en PrimeService.cs.

  • Remplacez le code dans PrimeService.cs par le code suivant :

    using System;

namespace Prime.Services
{
    public class PrimeService
    {
        public bool IsPrime(int candidate)
        {
            throw new NotImplementedException("Not implemented.");
        }
    }
}

    Actuellement, ce code lève un NotImplementedException, mais vous allez implémenter la méthode plus loin dans le tutoriel.

  • Dans le répertoire unit-testing-using-dotnet-test , exécutez la commande suivante pour ajouter le projet de bibliothèque de classes à la solution :

    dotnet sln add ./PrimeService/PrimeService.csproj

  • Créez le projet PrimeService.Tests en exécutant la commande suivante :

    dotnet new xunit -o PrimeService.Tests

    La commande précédente crée le projet PrimeService.Tests dans le répertoire PrimeService.Tests . Le projet de test utilise xUnit comme bibliothèque de tests. La commande configure également l’exécuteur de test en ajoutant les éléments suivants <PackageReference />au fichier projet :

    • Microsoft.NET.Test.Sdk
    • xunit
    • xunit.runner.visualstudio
    • coverlet.collector

  • Ajoutez le projet de test au fichier solution en exécutant la commande suivante :

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

  • Ajoutez la PrimeService bibliothèque de classes en tant que dépendance au projet PrimeService.Tests :

    dotnet add ./PrimeService.Tests/PrimeService.Tests.csproj reference ./PrimeService/PrimeService.csproj

Commandes pour créer la solution

Cette section récapitule toutes les commandes de la section précédente. Ignorez cette section si vous avez effectué les étapes de la section précédente.

Les commandes suivantes créent la solution de test sur une machine Windows. Pour macOS et Unix, mettez à jour la commande ren pour la version ren du système d’exploitation afin de renommer un fichier :

dotnet new sln -o unit-testing-using-dotnet-test
cd unit-testing-using-dotnet-test
dotnet new classlib -o PrimeService
ren .\PrimeService\Class1.cs PrimeService.cs
dotnet sln add ./PrimeService/PrimeService.csproj
dotnet new xunit -o PrimeService.Tests
dotnet add ./PrimeService.Tests/PrimeService.Tests.csproj reference ./PrimeService/PrimeService.csproj
dotnet sln add ./PrimeService.Tests/PrimeService.Tests.csproj

Suivez les instructions pour « Remplacer le code dans PrimeService.cs par le code suivant » dans la section précédente.

Créer un test

Une approche populaire dans le développement piloté par les tests (TDD) consiste à écrire un test (défaillant) avant d’implémenter le code cible. Ce tutoriel utilise l’approche TDD. La IsPrime méthode est appelante, mais n’est pas implémentée. Un appel de test à IsPrime échoue. Avec le TDD, vous écrivez un test dont vous savez qu'il va échouer. Ensuite, vous mettez à jour le code cible pour passer le test. Vous continuez à répéter cette approche, en écrivant un test défaillant, puis en mettant à jour le code cible pour réussir.

Mettez à jour le projet PrimeService.Tests :

  • Supprimez PrimeService.Tests/UnitTest1.cs.

  • Créez un fichier PrimeService.Tests/PrimeService_IsPrimeShould.cs .

  • Remplacez le code dans PrimeService_IsPrimeShould.cs par le code suivant :

    using Xunit;
using Prime.Services;

namespace Prime.UnitTests.Services
{
    public class PrimeService_IsPrimeShould
    {
        [Fact]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            var primeService = new PrimeService();
            bool result = primeService.IsPrime(1);

            Assert.False(result, "1 shouldn't be prime");
        }
    }
}

L’attribut [Fact] déclare une méthode de test exécutée par l’exécuteur de test. Dans le dossier PrimeService.Tests , exécutez dotnet test. La commande de test dotnet génère les deux projets et exécute les tests. L’exécuteur de test xUnit contient le point d’entrée du programme pour exécuter les tests. dotnet test démarre l’exécuteur de tests à l’aide du projet de test unitaire.

Le test échoue car IsPrime n’a pas été implémenté. À l’aide de l’approche TDD, écrivez uniquement suffisamment de code pour que ce test réussisse. Mettez à jour IsPrime à l’aide du code suivant :

public bool IsPrime(int candidate)
{
    if (candidate == 1)
    {
        return false;
    }
    throw new NotImplementedException("Not fully implemented.");
}

Exécutez dotnet test. Le test réussit.

Ajouter des tests

Ajoutez des tests de nombres premiers pour 0 et -1. Vous pouvez copier le test créé à l’étape précédente et effectuer des copies du code suivant pour tester 0 et -1. Mais ne le faites pas, car il y a une meilleure façon.

var primeService = new PrimeService();
bool result = primeService.IsPrime(1);

Assert.False(result, "1 shouldn't be prime");

La copie du code de test lorsqu'un seul paramètre change entraîne une duplication du code et l'enflure des tests. Les attributs xUnit suivants permettent d’écrire une suite de tests similaires :

  • [Theory] représente une suite de tests qui exécutent le même code, mais qui ont des arguments d’entrée différents.
  • [InlineData] l’attribut spécifie des valeurs pour ces entrées.

Au lieu de créer de nouveaux tests, appliquez les attributs xUnit précédents pour créer une théorie unique. Remplacez le code suivant...

[Fact]
public void IsPrime_InputIs1_ReturnFalse()
{
    var primeService = new PrimeService();
    bool result = primeService.IsPrime(1);

    Assert.False(result, "1 shouldn't be prime");
}

... avec le code suivant :

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

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

Dans le code précédent, [Theory] puis [InlineData] activez le test de plusieurs valeurs inférieures à deux. Deux est le plus petit nombre premier.

Ajoutez le code suivant après la déclaration de classe et avant l’attribut [Theory] :

private readonly PrimeService _primeService;

public PrimeService_IsPrimeShould()
{
    _primeService = new PrimeService();
}

Exécutez dotnet testet deux des tests échouent. Pour passer tous les tests, mettez à jour la IsPrime méthode avec le code suivant :

public bool IsPrime(int candidate)
{
    if (candidate < 2)
    {
        return false;
    }
    throw new NotImplementedException("Not fully implemented.");
}

Après l’approche TDD, ajoutez d’autres tests défaillants, puis mettez à jour le code cible. Consultez la version terminée des tests et l’implémentation complète de la bibliothèque.

La méthode terminée IsPrime n’est pas un algorithme efficace pour tester la primalité.

Ressources supplémentaires

  • Last updated on