Bien démarrer avec les tests unitaires

Article
01/19/2024

Utilisez Visual Studio pour définir et exécuter des tests unitaires afin de maintenir l’intégrité du code, garantir la couverture du code, et rechercher les erreurs et les défauts avant que vos clients les trouvent. Exécutez vos tests unitaires fréquemment pour vérifier que votre code fonctionne correctement.

Dans cet article, le code utilise C# et C++, les illustrations sont en C#, mais les concepts et fonctionnalités s’appliquent aux langages .NET, C++, Python, JavaScript et TypeScript.

Créer des tests unitaires

Cette section explique comment créer un projet de test unitaire.

Ouvrez le projet que vous souhaitez tester dans Visual Studio.

Dans le but de démontrer un exemple de test unitaire, cet article teste un simple projet de console C# ou C++ « Hello World » nommé HelloWorld. L’exemple de code pour un tel projet est comme suit :
- .NET
- C++
```
namespace HelloWorld
{
   public class Program
   {
      public static void Main()
      {
         Console.WriteLine("Hello World!");
      }
   }
}
```
```
#include <iostream>

int main()
{
   std::cout << "Hello World!\n";
}
```
Dans l’Explorateur de solutions, sélectionnez le nœud de la solution. Ensuite, dans la barre de menus supérieure, sélectionnez Fichier>Ajouter>Nouveau projet.
Dans la boîte de dialogue nouveau projet, recherchez le projet de test unitaire à utiliser.

Tapez test dans la zone de recherche pour rechercher un modèle de projet de test unitaire pour le cadre de test que vous souhaitez utiliser, comme MSTest (C#) ou le projet de test unitaire natif (C++), puis sélectionnez-le.

À partir de la version 14.8 de Visual Studio 2017, les langages .NET incluent des modèles intégrés pour NUnit et xUnit. Pour C++, dans cet exemple, sélectionnez le projet de test unitaire natif, qui utilise Microsoft Native Unit Test Framework. (Pour utiliser un autre cadre de test C++, consultez Écriture de tests unitaires pour C/C++). Pour Python, consultez Configurer des tests unitaires dans le code Python pour configurer votre projet de test.

Conseil

Pour C# uniquement, vous pouvez créer des projets de test unitaire à partir du code à l’aide d’une méthode plus rapide. Pour plus d’informations, consultez Créer des projets de test unitaire et des méthodes de test. Pour utiliser cette méthode avec .NET Core ou .NET Standard, Visual Studio 2019 ou une version ultérieure est nécessaire.

L’illustration suivante montre un test unitaire MSTest, pris en charge dans .NET.

Cliquez sur Suivant, choisissez un nom pour le projet de test, puis cliquez sur Créer.

Cliquez sur Suivant, choisissez un nom pour le projet de test, puis cliquez sur Créer.

Le projet est ajouté à votre solution.
Dans le projet de test unitaire, ajoutez une référence au projet que vous voulez tester. Pour ce faire, faites un clic droit sur Références ou Dépendances, puis choisissez Ajouter une référence ou Ajouter une référence de projet.
Sélectionnez le projet qui contient le code que vous allez tester, puis cliquez sur OK.

Ajoutez du code à la méthode de test unitaire.

Par exemple, vous pouvez utiliser le code suivant en sélectionnant l’onglet de documentation approprié qui correspond à votre cadre de test : MSTest, NUnit ou xUnit (pris en charge uniquement sur .NET) ou C++ Microsoft Native Unit Test Framework.

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

namespace HelloWorldTests
{
   [TestClass]
   public class UnitTest1
   {
      private const string Expected = "Hello World!";
      [TestMethod]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using NUnit.Framework;
using System.IO;
using System;

namespace HelloWorldTests
{
   public class Tests
   {
      private const string Expected = "Hello World!";

      [SetUp]
      public void Setup()
      {
      }
      [Test]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using System;
using Xunit;
using System.IO;

namespace HelloWorldTests
{
    public class UnitTest1
    {
        private const string Expected = "Hello World!";
        [Fact]
        public void Test1()
        {
            using (var sw = new StringWriter())
            {
                Console.SetOut(sw);
                HelloWorld.Program.Main();

                var result = sw.ToString().Trim();
                Assert.Equal(Expected, result);
            }
        }
    }
}

#include "pch.h"
#include "CppUnitTest.h"
#include "../HelloWorldUnitTestCPP/HelloWorldUnitTestCPP.cpp"   // Update using your project name

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace HelloWorldTests
{
   TEST_CLASS(HelloWorldTests)
   {
   public:

      TEST_METHOD(TestMethod)
      {
         std::string expected = "Hello World!\n";

         std::stringstream buffer;
         std::streambuf* sbuf = std::cout.rdbuf(); // Save cout's buffer
         std::cout.rdbuf(buffer.rdbuf()); // Redirect cout to the stringstream buffer

         // Call main() in your test
         int result = main();

         // When finished, redirect cout to the original buffer 
         std::cout.rdbuf(sbuf);
         std::cout << "std original buffer: \n";
         std::cout << buffer.get();

         // Test
         Assert::AreEqual(expected, buffer.str());
      }
   };
}

Exécuter des tests unitaires

Ouvrez l’Explorateur de tests.

Pour ouvrir l’Explorateur de tests, choisissez Test>Explorateur de tests dans la barre de menus supérieure (ou appuyez sur Ctrl + E, T).
Exécutez vos tests unitaires en cliquant sur Tout exécuter (ou appuyez sur Ctrl + R, V).

Une fois les tests terminés, une coche verte indique qu’un test a réussi. Une icône « x » rouge indique qu’un test a échoué.

Astuce

Vous pouvez utiliser l’Explorateur de tests pour exécuter des tests unitaires à partir du framework de tests intégré (MSTest) ou à partir de frameworks de tests tiers. Vous pouvez regrouper les tests en catégories, filtrer la liste de tests, ainsi que créer, enregistrer et exécuter des sélections de tests. Vous pouvez également déboguer des tests et analyser les performances des tests et la couverture du code.

Affichez les résultats des tests unitaires en direct (Visual Studio Enterprise)

Si vous utilisez le framework de tests MSTest, xUnit ou NUnit dans Visual Studio 2017 ou une version ultérieure, vous pouvez afficher les résultats temps réel de vos tests unitaires.

Notes

Pour suivre ces étapes, Visual Studio Enterprise est requis, ainsi que le code .NET et l’un des cadres de test suivants : MSTest, xUnit ou NUnit.

Activez les tests unitaires en direct à partir du menu Test en choisissant Test>Live Unit Testing>Démarrer.
Affichez les résultats des tests dans la fenêtre d’éditeur de code quand vous écrivez et modifiez le code.
Cliquez sur un indicateur de résultat de test pour afficher plus d’informations, comme les noms des tests qui couvrent cette méthode.

Pour plus d’informations sur les tests unitaires en direct, consultez Tests unitaires en direct.

Utiliser un framework de tests tiers

Vous pouvez exécuter des tests unitaires dans Visual Studio à l’aide de cadres de test tiers tels que NUnit, Boost ou Google C++ Testing Framework, en fonction de votre langage de programmation. Pour utiliser un cadre tiers :

Utilisez le Gestionnaire de package NuGet pour installer le package NuGet pour le framework de votre choix.
(.NET) À partir de Visual Studio 2017 version 14.6, Visual Studio inclut des modèles de projet de test préconfigurés pour les cadres de test NUnit et xUnit. Les modèles incluent également les packages NuGet nécessaires pour activer la prise en charge.
(C++) Dans Visual Studio 2017 et dans les versions ultérieures, certains cadres tels que Google C++ Testing Framework sont déjà inclus. Pour plus d’informations, consultez Écrire des tests unitaires pour C/C++ dans Visual Studio.

Ajoutez un projet de test unitaire :

Ouvrez la solution qui contient le code à tester.
Cliquez avec le bouton droit sur la solution dans l’Explorateur de solutions, puis choisissez Ajouter>Nouveau projet.
Sélectionnez un modèle de projet de test unitaire.

Dans cet exemple, sélectionnez NUnit

Cliquez sur Suivant, nommez le projet, puis cliquez sur Créer.

Le modèle de projet inclut des références NuGet à NUnit et NUnit3TestAdapter.
Ajoutez une référence du projet de test au projet qui contient le code à tester.

Cliquez avec le bouton droit sur le projet dans l’Explorateur de solutions, puis sélectionnez Ajouter>Référence. (Vous pouvez également ajouter une référence à partir du menu contextuel du nœud Références ou Dépendances.)
Ajoutez du code à votre méthode de test.
Exécutez le test à partir de l’Explorateur de tests, ou en faisant un clic droit sur le code de test et en choisissant Exécuter les tests (ou Ctrl + R, T).