Bien démarrer avec Live Unit Testing

Article
02/03/2025

Lorsque vous activez Live Unit Testing dans une solution Visual Studio, elle représente visuellement votre couverture de test et l’état de vos tests. Live Unit Testing exécute également dynamiquement des tests chaque fois que vous modifiez votre code et vous avertit immédiatement lorsque vos modifications entraînent l’échec des tests.

Live Unit Testing peut être utilisé pour tester des solutions qui ciblent .NET Framework, .NET Core ou .NET 5+. Dans ce tutoriel, vous allez apprendre à utiliser Live Unit Testing en créant une bibliothèque de classes simple qui cible .NET, et vous allez créer un projet MSTest qui cible .NET pour le tester.

La solution C# complète peut être téléchargée à partir du dépôt MicrosoftDocs/visualstudio-docs sur GitHub.

Conditions préalables

Dans le cadre de ce tutoriel, l’édition Visual Studio Enterprise doit être installée avec la charge de travail Développement de bureau .NET.

Créer la solution et le projet de bibliothèque de classes

Commencez par créer une solution Visual Studio nommée UtilityLibraries qui se compose d’un seul projet de bibliothèque de classes .NET, StringLibrary.

La solution n’est qu’un conteneur pour un ou plusieurs projets. Pour créer une solution vide, ouvrez Visual Studio et procédez comme suit :

Sélectionnez Fichier>Nouveau>Projet dans le menu Visual Studio du plus haut niveau.
Tapez solution dans la zone de recherche du modèle, puis sélectionnez le modèle Solution Vide. Nommez le projet UtilityLibraries.
Terminez la création de la solution.

Maintenant que vous avez créé la solution, vous allez créer une bibliothèque de classes nommée StringLibrary qui contient un certain nombre de méthodes d’extension pour l’utilisation de chaînes.

Dans Explorateur de solutions, cliquez avec le bouton droit sur la solution UtilityLibraries et sélectionnez Ajouter>Nouveau projet.
Tapez bibliothèque de classes dans la zone de recherche du modèle, puis sélectionnez le modèle bibliothèque de classes qui cible .NET ou .NET Standard. Cliquez sur suivant.
Nommez le projet StringLibrary .
Cliquez sur Créer pour créer le projet.

Remplacez tout le code existant dans l’éditeur de code par le code suivant :

using System;

namespace UtilityLibraries
{
    public static class StringLibrary
    {
        public static bool StartsWithUpper(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsUpper(s[0]);
        }

        public static bool StartsWithLower(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsLower(s[0]);
        }

        public static bool HasEmbeddedSpaces(this string s)
        {
            foreach (var ch in s.Trim())
            {
                if (ch == ' ')
                    return true;
            }
            return false;
        }
    }
}

StringLibrary a trois méthodes statiques :

StartsWithUpper retourne true si une chaîne commence par un caractère majuscule ; sinon, elle retourne false.
StartsWithLower retourne true si une chaîne commence par un caractère minuscule ; sinon, elle retourne false.
HasEmbeddedSpaces retourne true si une chaîne contient un caractère d’espace blanc incorporé ; sinon, elle retourne false.

Sélectionnez Build>Build Solution dans le menu Visual Studio de niveau supérieur. La construction devrait réussir.

Créer le projet de test

L’étape suivante consiste à créer le projet de test unitaire pour tester la bibliothèque StringLibrary. Créez les tests unitaires en effectuant les étapes suivantes :

Dans Explorateur de solutions, cliquez avec le bouton droit sur la solution UtilityLibraries et sélectionnez Ajouter>Nouveau Projet.
Tapez test unitaire dans la zone de recherche du modèle, sélectionnez C# comme langue, puis sélectionnez le projet de test unitaire MSTest pour le modèle .NET. Cliquez sur Suivant.

Remarque

Dans Visual Studio 2019 version 16.9, le nom du modèle de projet MSTest est projet de test unitaire.
Nommez le projet StringLibraryTests et cliquez sur suivant.
Choisissez le framework cible recommandé ou .NET 8, puis choisissez Créer.

Remarque

Ce didacticiel de prise en main utilise Live Unit Testing avec l’infrastructure de test MSTest. Vous pouvez également utiliser les frameworks de test xUnit et NUnit.
Le projet de test unitaire ne peut pas accéder automatiquement à la bibliothèque de classes qu’il teste. Vous accordez l’accès à la bibliothèque de test en ajoutant une référence au projet de bibliothèque de classes. Pour ce faire, cliquez avec le bouton droit sur le projet StringLibraryTests, puis sélectionnez Ajouter>référence de projet. Dans la boîte de dialogue Gestionnaire de références, vérifiez que l’onglet solution est sélectionné, puis sélectionnez le projet StringLibrary, comme illustré dans l’illustration suivante.

Remplacez le code de test unitaire réutilisable fourni par le modèle par le code suivant :

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва" };
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result,
                              $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                               "1234", ".", ";", " " };
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result,
                               $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string[] words = { String.Empty, null };
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result,
                               $"Expected for '{(word == null ? "<null>" : word)}': " +
                               $"false; Actual: {result}");
            }
        }
    }
}

Enregistrez votre projet en sélectionnant l’icône Enregistrer dans la barre d’outils.

Étant donné que le code de test unitaire inclut des caractères non ASCII, vous verrez la boîte de dialogue suivante pour avertir que certains caractères seront perdus si vous enregistrez le fichier dans son format ASCII par défaut.
Choisissez le bouton Enregistrer avec un autre encodage.
Dans la liste déroulante Encodage de la boîte de dialogue Options d’enregistrement avancées, choisissez Unicode (UTF-8 sans signature) - Codepage 65001, comme l’illustre l’illustration suivante :
Compilez le projet de test unitaire en sélectionnant Build>Rebuild Solution dans le menu Visual Studio de niveau supérieur.

Vous avez créé une bibliothèque de classes ainsi que des tests unitaires pour celui-ci. Vous avez maintenant terminé les préliminaires nécessaires pour utiliser Live Unit Testing.

Activer Live Unit Testing

Jusqu’à présent, même si vous avez écrit les tests pour la bibliothèque de classes StringLibrary, vous ne les avez pas exécutés. Live Unit Testing les exécute automatiquement une fois que vous l’activez. Pour ce faire, procédez comme suit :

Si vous le souhaitez, sélectionnez la fenêtre de l’éditeur de code qui contient le code de StringLibrary. Il s’agit de Class1.cs pour un projet C# ou Class1.vb pour un projet Visual Basic. (Cette étape vous permet d’inspecter visuellement le résultat de vos tests et l’étendue de votre couverture de code une fois que vous avez activé Live Unit Testing.)
Sélectionnez Test>Live Unit Testing>Démarrer dans le menu Visual Studio de niveau supérieur.
Vérifiez la configuration de Live Unit Testing en veillant à ce que la racine du référentiel inclut le chemin d’accès aux fichiers sources pour le projet utilitaire et le projet de test. Sélectionnez Suivant, puis Terminer.

Dans la fenêtre Live Unit Testing, sélectionnez le lien Inclure tous les tests (sinon, sélectionnez l’icône du bouton Playlist, puis sélectionnez StringLibraryTest, qui sélectionne tous les tests sous celui-ci. Désélectionnez ensuite le bouton Playlist pour quitter le mode d’édition.)
Visual Studio régénère le projet et démarre Live Unit Test, qui exécute automatiquement tous vos tests.

Visual Studio régénère le projet et démarre Live Unit Test, qui exécute automatiquement tous vos tests.

Une fois vos tests terminés, Live Unit Testing affiche les résultats globaux et le résultat des tests individuels. En outre, la fenêtre de l’éditeur de code affiche graphiquement votre couverture de code de test et le résultat de vos tests. Comme l’illustre l’illustration suivante, les trois tests ont été exécutés avec succès. Il montre également que nos tests ont couvert tous les chemins de code de la méthode StartsWithUpper, et que ces tests ont tous été exécutés avec succès (ce qui est indiqué par la coche verte, « ✓ »). Enfin, il montre qu’aucune des autres méthodes de StringLibrary n’a de couverture de code (qui est indiquée par une ligne bleue, « ➖ »).

La fenêtre de l’Explorateur de tests en direct et de l’éditeur de code après le démarrage du test Live Unit

Vous pouvez également obtenir des informations plus détaillées sur la couverture des tests et les résultats des tests en sélectionnant une icône de couverture de code particulière dans la fenêtre de l’éditeur de code. Pour examiner ces détails, procédez comme suit :

Cliquez sur la marque de coche verte pour la ligne qui contient if (String.IsNullOrWhiteSpace(s)) dans la méthode StartsWithUpper. Comme l’illustre l’illustration suivante, Live Unit Testing indique que trois tests couvrent cette ligne de code et que tous ont été exécutés avec succès.
Cliquez sur la marque de coche verte pour la ligne qui contient return Char.IsUpper(s[0]) dans la méthode StartsWithUpper. Comme l’illustre l’illustration suivante, Live Unit Testing indique que seuls deux tests couvrent cette ligne de code et que tous ont été exécutés avec succès.

Le problème majeur que Live Unit Testing identifie est une couverture de code incomplète. Vous allez l’aborder dans la section suivante.

Développer la couverture des tests

Dans cette section, vous allez étendre vos tests unitaires à la méthode StartsWithLower. Pendant cela, Live Unit Testing continuera de tester dynamiquement votre code.

Pour étendre la couverture du code à la méthode StartsWithLower, procédez comme suit :

Ajoutez les méthodes TestStartsWithLower et TestDoesNotStartWithLower suivantes au fichier de code source de test de votre projet :

// Code to add to UnitTest1.cs
[TestMethod]
public void TestStartsWithLower()
{
    // Tests that we expect to return true.
    string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство" };
    foreach (var word in words)
    {
        bool result = word.StartsWithLower();
        Assert.IsTrue(result,
                      $"Expected for '{word}': true; Actual: {result}");
    }
}

[TestMethod]
public void TestDoesNotStartWithLower()
{
    // Tests that we expect to return false.
    string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва",
                       "1234", ".", ";", " "};
    foreach (var word in words)
    {
        bool result = word.StartsWithLower();
        Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}");
    }
}

Modifiez la méthode DirectCallWithNullOrEmpty en ajoutant le code suivant immédiatement après l’appel à la méthode Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse.

// Code to add to UnitTest1.cs
result = StringLibrary.StartsWithLower(word);
Assert.IsFalse(result,
               $"Expected for '{(word == null ? "<null>" : word)}': " +
               $"false; Actual: {result}");

Live Unit Testing exécute automatiquement des tests nouveaux et modifiés lorsque vous modifiez votre code source. Comme l’illustre l’illustration suivante, tous les tests, y compris les deux que vous avez ajoutés et celui que vous avez modifié, ont réussi.
Basculez vers la fenêtre qui contient le code source de la classe StringLibrary. Live Unit Testing montre maintenant que notre couverture de code est étendue à la méthode StartsWithLower.

Couverture de Code

Dans certains cas, les tests réussis dans Explorateur de tests peuvent être grisés. Cela indique qu’un test est en cours d’exécution ou que le test n’a pas réexécuté, car il n’y a pas eu de modifications de code qui impacteraient le test depuis sa dernière exécution.

Jusqu’à présent, tous nos tests ont réussi. Dans la section suivante, nous allons examiner la façon dont vous pouvez gérer les échecs de test.

Gérer un échec de test

Dans cette section, vous allez découvrir comment utiliser Live Unit Testing pour identifier, dépanner et résoudre les échecs de test. Pour ce faire, vous allez étendre la portée des tests à la méthode HasEmbeddedSpaces.

Ajoutez la méthode suivante à votre fichier de test :

[TestMethod]
public void TestHasEmbeddedSpaces()
{
    // Tests that we expect to return true.
    string[] phrases = { "one car", "Name\u0009Description",
                         "Line1\nLine2", "Line3\u000ALine4",
                         "Line5\u000BLine6", "Line7\u000CLine8",
                         "Line0009\u000DLine10", "word1\u00A0word2" };
    foreach (var phrase in phrases)
    {
        bool result = phrase.HasEmbeddedSpaces();
        Assert.IsTrue(result,
                      $"Expected for '{phrase}': true; Actual: {result}");
    }
}

Lorsque le test s’exécute, Live Unit Testing indique que la méthode TestHasEmbeddedSpaces a échoué, comme l’illustre l’illustration suivante :

test échoué
Sélectionnez la fenêtre qui affiche le code de la bibliothèque. Live Unit Testing a étendu la couverture du code à la méthode HasEmbeddedSpaces. Il signale également l’échec de test en ajoutant un🞩rouge aux lignes couvertes par des tests défaillants.
Passez la souris sur la ligne avec la signature de méthode HasEmbeddedSpaces. Live Unit Testing affiche une info-bulle qui signale que la méthode est couverte par un test, comme l’illustre l’illustration suivante :

ayant échoué
Sélectionnez le test TestHasEmbeddedSpaces qui a échoué. Live Unit Testing vous offre quelques options telles que l’exécution de tous les tests et le débogage de tous les tests, comme l’illustre l’illustration suivante :

ayant échoué
Sélectionnez Tout déboguer pour déboguer le test ayant échoué.
Visual Studio exécute le test en mode débogage.

Le test affecte chaque chaîne d’un tableau à une variable nommée phrase et la transmet à la méthode HasEmbeddedSpaces. L’exécution du programme s’interrompt et appelle le débogueur la première fois que l’expression d’assertion est false. La boîte de dialogue d’exception qui résulte de la valeur inattendue dans l’appel de méthode Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue est illustrée dans l’illustration suivante.

boîte de dialogue

boîte de dialogue d'exception de tests unitaires en direct

En outre, tous les outils de débogage fournis par Visual Studio sont disponibles pour nous aider à résoudre nos échecs de test, comme l’illustre l’illustration suivante :

Notez dans la fenêtre Autos que la valeur de la variable phrase est « Name\tDescription », qui est le deuxième élément du tableau. La méthode de test s’attend à ce que HasEmbeddedSpaces retourne true lorsque cette chaîne lui est passée ; au lieu de cela, elle retourne false. Évidemment, il ne reconnaît pas « \t », le caractère de tabulation, en tant qu’espace incorporé.
Sélectionnez Déboguer>Continuer, appuyez sur F5, ou cliquez sur le bouton Continuer dans la barre d’outils pour continuer à exécuter le programme de test. Étant donné qu’une exception non gérée s’est produite, le test se termine. Cela fournit suffisamment d’informations pour une enquête préliminaire du bogue. Soit TestHasEmbeddedSpaces (la routine de test) a fait une hypothèse incorrecte, soit HasEmbeddedSpaces ne reconnaît pas correctement tous les espaces incorporés.
Pour diagnostiquer et corriger le problème, commencez par la méthode StringLibrary.HasEmbeddedSpaces. Examinez la comparaison dans la méthode HasEmbeddedSpaces. Il considère qu’un espace incorporé est U+0020. Toutefois, la norme Unicode inclut un certain nombre d’autres caractères d’espace. Cela suggère que le code de la bibliothèque a mal vérifié la présence d'un caractère d'espacement.
Remplacez la comparaison d’égalité par un appel à la méthode System.Char.IsWhiteSpace :
```
if (Char.IsWhiteSpace(ch))
```
Live Unit Testing réexécute automatiquement la méthode de test ayant échoué.

Live Unit Testing affiche les résultats mis à jour qui apparaissent également dans la fenêtre de l’éditeur de code.