Prise en main des tests unitaires

Utilisez Visual Studio pour définir et exécuter des tests unitaires pour maintenir l’intégrité du code, garantir la couverture du code et rechercher des erreurs et des erreurs avant que vos clients ne le fassent. Exécutez fréquemment vos tests unitaires pour vous assurer 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.

1. Ouvrez le projet que vous souhaitez tester dans Visual Studio.

   Dans le cadre de la démonstration d’un exemple de test unitaire, cet article teste un simple projet de console C# ou C++ « Hello World » nommé HelloWorld. L’exemple de code d’un tel projet est le suivant :

   .NET

   namespace HelloWorld
   {
      public class Program
      {
         public static void Main()
         {
            Console.WriteLine("Hello World!");
         }
      }
   }
   

   C++

   #include <iostream>
   
   int main()
   {
      std::cout << "Hello World!\n";
   }
   

2. Dans l’Explorateur de solutions, sélectionnez le nœud de solution. Ensuite, dans la barre de menus supérieure, sélectionnez Fichier>Ajouter>un nouveau projet.

3. Dans la boîte de dialogue nouveau projet, recherchez le projet de test unitaire à utiliser.

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

   À compter de Visual Studio 2017 version 14.8, 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 une autre infrastructure 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 / Astuce

   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 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.

   Le projet est ajouté à votre solution.

   

4. Dans le projet de test unitaire, ajoutez une référence au projet que vous souhaitez tester en cliquant avec le bouton droit sur Références ou Dépendances , puis en choisissant Ajouter une référence ou Ajouter une référence de projet.

5. Sélectionnez le projet qui contient le code que vous allez tester, puis cliquez sur OK.

   

6. 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 infrastructure de test : MSTest, NUnit ou xUnit (pris en charge uniquement sur .NET) ou C++ Microsoft Native Unit Test Framework.

   MSTest

   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);
            }
         }
      }
   }
   

   NUnit

   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);
            }
         }
      }
   }
   

   xUnit

   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);
               }
           }
       }
   }
   

   Microsoft Native Unit Test Framework

   #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

1. Ouvrez l’Explorateur de tests.

   Pour ouvrir l’Explorateur de tests, choisissez l’Explorateur>de tests dans la barre de menus supérieure (ou appuyez sur Ctrl + E, T).

2. Exécutez vos tests unitaires en cliquant sur Exécuter tout (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 rouge « x » indique qu’un test a échoué.

   

Conseil / Astuce

Vous pouvez utiliser l’Explorateur de tests pour exécuter des tests unitaires à partir de l’infrastructure de test intégrée (MSTest) ou à partir d’infrastructures de test tierces. Vous pouvez regrouper des tests en catégories, filtrer la liste de tests et créer, enregistrer et exécuter des playlists de tests. Vous pouvez également déboguer des tests et analyser les performances des tests et la couverture du code.

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

Si vous utilisez l’infrastructure de test MSTest, xUnit ou NUnit dans Visual Studio 2017 ou une version ultérieure, vous pouvez voir les résultats en direct de vos tests unitaires.

Note

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

1. Activez les tests unitaires en direct à partir du menu Test en choisissant Test>>.

   

2. Affichez les résultats des tests dans la fenêtre de l’éditeur de code lorsque vous écrivez et modifiez du code.

   

3. Cliquez sur un indicateur de résultat de test pour afficher plus d’informations, telles que les noms des tests qui couvrent cette méthode.

   

Pour plus d’informations sur les tests unitaires en direct, consultez Live Unit Testing.

Utiliser une infrastructure de test tierce

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

• Utilisez le Gestionnaire de package NuGet pour installer le package NuGet pour l’infrastructure de votre choix.

• (.NET) À compter de Visual Studio 2017 version 14.6, Visual Studio inclut des modèles de projet de test préconfigurés pour les infrastructures 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 versions ultérieures, certaines infrastructures telles que Google C++ Testing Framework sont déjà incluses. Pour plus d’informations, consultez Écrire des tests unitaires pour C/C++ dans Visual Studio.

Pour ajouter un projet de test unitaire :

1. Ouvrez la solution qui contient le code que vous souhaitez tester.

2. Cliquez avec le bouton droit sur la solution dans l’Explorateur de solutions et choisissez Ajouter>un nouveau projet.

3. Sélectionnez un modèle de projet de test unitaire.

   Dans cet exemple, sélectionnez NUnit

   

   Le modèle de projet inclut des références NuGet à NUnit et NUnit3TestAdapter.

   

4. Ajoutez une référence du projet de test au projet qui contient le code que vous souhaitez tester.

   Cliquez avec le bouton droit sur le projet dans l’Explorateur de solutions, puis sélectionnez Ajouter une>référence. (Vous pouvez également ajouter une référence dans le menu contextuel du nœud Références ou Dépendances .)

5. Ajoutez du code à votre méthode de test.

   

6. Exécutez le test à partir de l’Explorateur de tests ou en cliquant avec le bouton droit sur le code de test et en choisissant Exécuter des tests (ou Ctrl + R, T).

Étapes suivantes

Principes de base des tests unitaires

Créer et exécuter des tests unitaires pour le code managé

Écrire des tests unitaires pour le code C/C++