Bien démarrer avec Live Unit Testing

Article
12/18/2023

Quand vous l’activez dans une solution Visual Studio, Live Unit Testing décrit visuellement la couverture et l’état de vos tests. Par ailleurs, il exécute dynamiquement des tests chaque fois que vous modifiez votre code et vous avertit immédiatement quand vos modifications provoquent 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 découvrir comment utiliser Live Unit Testing en créant une bibliothèque de classes simple qui cible .NET, et vous allez générer un projet MSTest qui cible .NET pour la tester.

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

Prérequis

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 est simplement un conteneur pour un ou plusieurs projets. Pour créer une solution vide, ouvrez Visual Studio et effectuez les étapes suivantes :

Sélectionnez Fichier>Nouveau>Projet dans le menu Visual Studio du plus haut niveau.
Tapez solution dans la zone de recherche des modèles, 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 plusieurs méthodes d’extension pour manipuler des chaînes.

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution UtilityLibraries, puis sélectionnez Ajouter>Nouveau projet.
Tapez bibliothèque de classes dans la zone de recherche des modèles, puis sélectionnez le modèle Bibliothèque de classes qui cible .NET Standard ou .NET. Sélectionnez 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 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 comporte 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 espace incorporé ; sinon, elle retourne false.

Sélectionnez Générer>Générer la solution dans le menu Visual Studio du plus haut niveau. La génération doit s’effectuer correctement.

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 procédant comme suit :

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution UtilityLibraries, puis sélectionnez Ajouter>Nouveau projet.
Tapez test unitaire dans la zone de recherche de modèle, sélectionnez C# comme langage, puis sélectionnez le modèle Projet de test unitaire MSTest pour le modèle .NET. Sélectionnez 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, puis cliquez sur Suivant.
Choisissez l’infrastructure cible recommandée ou .NET 8, puis sélectionnez Créer.

Remarque

Ce didacticiel de démarrage utilise Live Unit Testing avec le framework 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 donnez l’accès à la bibliothèque 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 dans la figure 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.

Comme le code des tests unitaires comporte des caractères non ASCII, la boîte de dialogue suivante apparaît pour prévenir que certains caractères seront perdus si le fichier est enregistré 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) – Page de codes 65001 comme dans la figure suivante :
Compilez le projet de test unitaire en sélectionnant Générer>Regénérer la solution dans le menu Visual Studio du plus haut niveau.

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

Activer Live Unit Testing

Bien que vous ayez écrit les tests pour la bibliothèque de classes StringLibrary, vous ne les avez pas exécutés pour l’instant. Live Unit Testing les exécute automatiquement une fois que vous l’activez. Pour cela, 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 de Class1.vb pour un projet Visual Basic. (Cette étape vous permet d’inspecter visuellement le résultat de vos tests et l’étendue de la couverture de votre code une fois que vous avez activé Live Unit Testing.)
Sélectionnez Tester>Live Unit Testing>Démarrer dans le menu Visual Studio du plus haut niveau.
Vérifiez la configuration de Live Unit Testing en vous assurant que la racine du référentiel inclut le chemin des fichiers sources du projet d’utilitaire et du 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 lance Live Unit Test, qui exécute automatiquement tous vos tests.

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

Quand il a terminé l’exécution de vos tests, Live Unit Testing affiche les résultats globaux et le résultat de chacun des tests. En outre, la fenêtre de l’éditeur de code affiche graphiquement la couverture du code et le résultat de vos tests. Comme le montre la figure suivante, les trois tests ont réussi. Elle 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, « ✓ »). Elle montre enfin qu’aucune autre méthode de StringLibrary ne dispose d’une couverture du code (indiquée par une ligne bleue, « ➖ »).

Explorateur de tests dynamique et fenêtre de l’éditeur de code après le démarrage de Live Unit Testing.

Pour obtenir des informations plus détaillées sur la couverture et le résultat des tests, sélectionnez une icône de couverture du code en particulier dans la fenêtre de l’éditeur de code. Pour examiner ces informations détaillées, 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 le montre la figure suivante, Live Unit Testing indique que trois tests couvrent cette ligne de code, et que tous ont réussi.
Cliquez sur la marque de coche verte pour la ligne qui contient return Char.IsUpper(s[0]) dans la méthode StartsWithUpper. Comme le montre la figure suivante, Live Unit Testing indique que seuls deux tests couvrent cette ligne de code, et que tous ont réussi.

Le principal problème identifié par Live Unit Testing est une couverture du code incomplète. Vous le résolvez dans la section suivante.

Étendre la couverture des tests

Dans cette section, vous étendez vos tests unitaires à la méthode StartsWithLower. Quand vous faites cela, Live Unit Testing continue à 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 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 quand vous modifiez votre code source. Comme le montre la figure suivante, tous les tests (y compris les deux tests que vous avez ajoutés et celui que vous avez modifié) ont réussi.
Basculez vers la fenêtre contenant le code source de la classe StringLibrary. Live Unit Testing montre maintenant que la couverture de notre code est étendue à la méthode StartsWithLower.

Dans certains cas, des tests réussis dans l’Explorateur de tests peuvent apparaître en grisé. Ceci indique qu’un test est en cours d’exécution ou que le test n’a pas été réexécuté, car il n’y a pas eu de modification du code impactant le test depuis sa dernière exécution.

Jusqu’à présent, tous nos tests ont réussi. Dans la section suivante, nous allons examiner comment vous pouvez gérer l’échec d’un test.

Gérer l’échec d’un test

Dans cette section, vous découvrez comment vous pouvez utiliser Live Unit Testing pour identifier, dépanner et résoudre les échecs des tests. Vous faites cela en étendant la couverture de test à 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}");
    }
}

Quand le test s’exécute, Live Unit Testing indique que la méthode TestHasEmbeddedSpaces a échoué, comme le montre la figure suivante :
Sélectionnez la fenêtre qui affiche le code de la bibliothèque. Notez que Live Unit Testing a étendu la couverture du code à la méthode HasEmbeddedSpaces. Il signale également l’échec d’un test en ajoutant une croix (« 🞩 ») rouge sur les lignes couvertes par le test.
Placez le curseur sur la ligne avec la signature de méthode HasEmbeddedSpaces. Live Unit Testing affiche une info-bulle qui indique que la méthode est couverte par un test, comme le montre la figure suivante :
Sélectionnez le test TestHasEmbeddedSpaces qui a échoué. Notez que Live Unit Testing vous offre plusieurs options, par exemple exécuter tous les tests, comme le montre la figure suivante :
Sélectionnez Tout déboguer pour déboguer le test ayant échoué.
Visual Studio exécute le test en mode débogage.

Notre test affecte chacune des chaînes 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 figure suivante illustre la boîte de dialogue d’exception résultant de la valeur inattendue dans l’appel de méthode Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue.

En outre, tous les outils de débogage fournis par Visual Studio sont disponibles pour nous aider à résoudre les problèmes de notre test qui a échoué, comme le montre la figure suivante :

Notez que, dans la fenêtre Automatique, la valeur de la variable phrase est « Name\tDescription », qui est le deuxième élément du tableau. La méthode de test attend que HasEmbeddedSpaces retourne true quand cette chaîne lui est passée ; au lieu de cela, elle retourne false. De toute évidence, elle ne reconnaît pas « \t », le caractère de tabulation, comme espace incorporé.
Sélectionnez Déboguer>Continuer, appuyez sur F5 ou cliquez sur le bouton Continuer dans la barre d’outils pour continuer l’exécution du programme de test. Comme une exception non gérée s’est produite, le test s’arrête. Ceci fournit suffisamment d’informations pour un examen préliminaire du bogue. TestHasEmbeddedSpaces (la routine de test) a fait une supposition incorrecte ou 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. Regardez la comparaison dans la méthode HasEmbeddedSpaces. Elle considère qu’un espace incorporé est représenté par U+0020. Le standard Unicode inclut plusieurs autres caractères espace. Ceci suggère que le code de la bibliothèque a été incorrectement testé pour un caractère espace.
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.