Bien démarrer avec C# et MSTest

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éer le projet source

Ouvrez une fenêtre shell. Créez un répertoire appelé unit-testing-using-mstest pour contenir la solution. Dans ce nouveau répertoire, exécutez dotnet new sln pour créer un fichier solution pour la bibliothèque de classes et le projet de test. Créez un répertoire PrimeService . Le plan suivant montre le répertoire et la structure de fichiers jusqu’à présent :

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

Créez PrimeService le répertoire actif et exécutez dotnet new classlib pour créer le projet source.

Revenez au répertoire unit-testing-using-mstest . Exécutez dotnet sln add pour ajouter le projet de bibliothèque de classes à la solution.

dotnet sln add PrimeService/PrimeService.csproj

Renommez-le Class1.cs dans le répertoire PrimeService en PrimeService.cs. Remplacez le code dans le fichier par le code suivant pour créer une implémentation défaillante de la PrimeService classe :

using System;

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

Créer le projet de test

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

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

Créez le répertoire PrimeService.Tests le répertoire actif et créez un projet à l’aide de dotnet new mstest. La commande dotnet new crée un projet de test qui utilise MSTest comme bibliothèque de tests. Le modèle configure l’exécuteur de test dans le fichier PrimeServiceTests.csproj :

<ItemGroup>
  <PackageReference Include="MSTest" Version="4.1.0" />
</ItemGroup>

Note

Les versions de paquet indiquées sont données à titre d’exemple. Les versions générées par dotnet new mstest dépendent de votre SDK .NET. Les modèles et les exemples téléchargés peuvent ne pas utiliser les dernières versions du package NuGet.

Pour rechercher les mises à jour après avoir créé et exécuté vos tests, exécutez-les dotnet package list --outdated à partir du répertoire du projet de test. Permet dotnet package add <PACKAGE_NAME> de mettre à jour une référence de package vers la dernière version stable compatible. Passez en revue les notes de publication pour connaître les changements incompatibles avant la mise à jour, puis exécutez de nouveau dotnet test par la suite.

Si vous utilisez .NET SDK 9 ou une version antérieure, utilisez plutôt dotnet list package --outdated et dotnet add package <PACKAGE_NAME>.

Le projet de test nécessite d’autres packages pour créer et exécuter des tests unitaires. dotnet new à l’étape précédente, vous avez ajouté les packages et outils MSTest nécessaires pour la création de rapports de couverture du code.

Ajoutez la PrimeService bibliothèque de classes 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-mstest
    unit-testing-using-mstest.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeServiceTests.csproj

Accédez au répertoire unit-testing-using-mstest , puis exécutez dotnet sln add:

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

Créer le premier test

Écrivez un test défaillant, faites-le passer, puis répétez le processus. Supprimez UnitTest1.cs du répertoire PrimeService.Tests et créez un fichier C# nommé PrimeService_IsPrimeShould.cs avec le contenu suivant :

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Prime.Services;

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

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

        [TestMethod]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            bool result = _primeService.IsPrime(1);

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

L’attribut TestClass désigne une classe qui contient des tests unitaires. L’attribut TestMethod indique qu’une méthode est une méthode de test.

MSTest crée une nouvelle instance de la classe de test pour chaque test, de sorte que le constructeur crée un PrimeService distinct pour chaque test. Le constructeur contient uniquement l’initialisation nécessaire à tous les tests de cette classe. Si vos tests ont besoin d’une configuration différente, créez des objets dans les méthodes de test ou appelez des méthodes d’assistance à partir de ces méthodes. Pour obtenir des conseils, consultez Utilisez des méthodes d’assistance au lieu de Setup et Teardown.

Enregistrez ce fichier et exécutez dotnet test pour générer les tests et la bibliothèque de classes, puis exécutez les tests. L’exécuteur de test MSTest 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, car vous n’avez pas encore créé l’implémentation. Effectuez ce test en écrivant le code le plus simple dans la classe PrimeService 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-mstest , exécutez dotnet test à nouveau. 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.

Ajouter d’autres fonctionnalités

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 TestMethod, mais cela devient rapidement fastidieux. Il existe d’autres attributs MSTest qui vous permettent d’écrire une suite de tests similaires. Une méthode de test peut exécuter le même code, mais elle a des arguments d’entrée différents. Vous pouvez utiliser l’attribut DataRow pour spécifier des valeurs pour ces entrées.

Au lieu de créer de nouveaux tests, appliquez ces deux attributs 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. Ajoutez une nouvelle méthode de test dans PrimeService_IsPrimeShould.cs :

[TestMethod]
[DataRow(-1)]
[DataRow(0)]
[DataRow(1)]
public void IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    bool result = _primeService.IsPrime(value);

    Assert.IsFalse(result, $"{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 IsPrime méthode dans le fichier PrimeService.cs :

if (candidate < 2)

Continuez à itérer en ajoutant d’autres tests, plus de théories et plus de 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 structuré la solution afin que l’ajout de nouveaux packages et tests fasse partie du flux de travail normal. Vous avez concentré la plupart de votre temps et votre effort sur la résolution des objectifs de l’application.

Exécuter des tests dans Azure Pipelines

Pour exécuter automatiquement vos tests lorsque vous envoyez des modifications, ajoutez une configuration Azure Pipelines au référentiel qui contient votre solution terminée. Vous avez besoin d’un projet Azure DevOps et d’un accès à un agent hébergé par Microsoft. Pour connaître les conditions préalables, consultez Créer votre premier pipeline.

  1. À la racine de votre dépôt, créez un fichier azure-pipelines.yml avec le contenu suivant. L’exemple suppose que les répertoires PrimeService.Tests et PrimeService se trouvent à la racine du référentiel et que les deux projets ciblent .NET 10.

    trigger:
- main

pool:
  vmImage: ubuntu-latest

steps:
- task: UseDotNet@2
  displayName: Install .NET SDK
  inputs:
    packageType: sdk
    version: 10.0.x

- task: DotNetCoreCLI@2
  displayName: Run MSTest tests
  inputs:
    command: test
    projects: PrimeService.Tests/PrimeService.Tests.csproj
    arguments: --configuration Release
    publishTestResults: true

  2. Ajustez la configuration pour qu’elle corresponde à votre dépôt :

    • Si votre branche a un autre nom, remplacez main dans trigger par ce nom de branche.
    • Si votre solution se trouve dans un sous-répertoire, mettez à jour projects avec le chemin du projet de test par rapport à la racine du référentiel.
    • Si vos projets ciblent une autre version de .NET, modifiez version dans la tâche UseDotNet@2 pour qu’elle corresponde. Par exemple, utilisez 8.0.x pour les projets qui ciblent net8.0. Si votre référentiel contient un fichier global.json, assurez-vous que le Kit de développement logiciel (SDK) installé répond à ses exigences de version.

  3. Validez et envoyez (push) votre solution et votre fichier azure-pipelines.yml vers votre dépôt Git.

  4. Dans votre projet Azure DevOps, sélectionnez Pipelines>Nouveau pipeline ou Créez un pipeline s'il s'agit de votre premier pipeline. Sélectionnez votre fournisseur de référentiels et votre référentiel.

  5. Sur la page Configurer votre pipeline, sélectionnez fichier YAML Azure Pipelines existant, sélectionnez la branche et /azure-pipelines.yml, puis sélectionnez Continuer. Passez en revue la configuration et sélectionnez Exécuter.

La UseDotNet@2 tâche installe le Kit de développement logiciel (SDK) .NET. La DotNetCoreCLI@2 tâche exécute dotnet test, qui restaure les dépendances, génère le projet de test et sa bibliothèque référencée, puis exécute les tests dans la configuration Release.

Avec publishTestResults: true, la tâche génère un fichier de résultats TRX et publie les résultats, même si un test échoue. Après l’exécution, ouvrez l’onglet Tests du pipeline pour passer en revue les tests réussis et les tests ayant échoué. Un test ayant échoué entraîne également l’échec de la tâche de test et du pipeline.

Note

Cet exemple utilise la configuration VSTest par défaut issue de dotnet new mstest avec le SDK .NET 10. Si vous activez Microsoft. Testing.Platform (MTP), consultez Exécuter des tests MTP en intégration continue pour la configuration d’exécuteur requise.

Voir aussi

  • Dernière mise à jour :