Procédure pas à pas : Créer et exécuter des tests unitaires pour des applications UWP

Cet article explique comment exécuter des tests unitaires des applications plateforme Windows universelle (UWP) dans Visual Studio. Visual Studio Ceci propose des modèles de projet de tests unitaires pour C#, Visual Basic et C++. Pour plus d’informations sur le développement d’applications UWP, consultez Démarrer avec les applications UWP.

L’article décrit un exemple de création et de test unitaire d’une classe C# dans une application UWP. L’exemple utilise le développement piloté par les tests pour écrire des tests qui vérifient des comportements spécifiques, puis écrire du code qui réussit les tests.

Créer et exécuter un projet de test unitaire

Les procédures suivantes décrivent comment créer et exécuter des projets de test unitaire pour les applications UWP.

Créer un projet de test unitaire UWP

1. Dans la fenêtre Démarrer de Visual Studio, choisissez Créer un projet.

2. Sur la page Créer un projet, entrez test unitaire dans la zone de recherche. La liste de modèles filtre les projets de test unitaire.

3. Sélectionnez le modèle Application de test unitaire (Windows universel) pour C# ou Visual Basic, puis sélectionnez Suivant.

   

4. Modifiez éventuellement le nom et l’emplacement du projet ou de la solution, puis sélectionnez Créer.

5. Modifiez éventuellement les versions cibles et minimales de la plateforme, puis sélectionnez OK.

Visual Studio crée alors le projet et l’ouvre dans l’Explorateur de solutions de Visual Studio.

Modifier le manifeste d’application du projet

1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le fichier Package.appxmanifest et sélectionnez Ouvrir.

2. Dans le Concepteur de manifeste, sélectionnez l’onglet Fonctionnalités.

3. Dans la liste Fonctionnalités, sélectionnez les fonctionnalités dont vous avez besoin pour le code et le test unitaire. Par exemple, si votre code et son test unitaire doivent accéder à Internet, cochez la case Internet.

Sélectionnez uniquement les fonctionnalités dont vous avez besoin pour que le test unitaire fonctionne correctement.

Ajouter du code pour exécuter le test unitaire de l’application UWP

Dans l’éditeur de code Visual Studio, modifiez le fichier de code de test unitaire pour ajouter les assertions et la logique dont vos tests ont besoin. Pour obtenir des exemples, consultez Test unitaire d’une classe C# plus loin dans cet article.

Exécuter des tests unitaires avec l’Explorateur de tests

Générer la solution et exécuter le test unitaire à l'aide de l'Explorateur de tests.

1. Dans le menu Test de Visual Studio, sélectionnez l’Explorateur de tests. La fenêtre Explorateur de tests s’ouvre.

2. Dans l’Explorateur de tests, sélectionnez l’icône Exécuter tout. Vous devez utiliser Exécuter tout pour découvrir les tests dans les projets UWP.

   

La solution est générée, et le test unitaire s’exécute. Une fois le test exécuté, le test s’affiche dans la liste des tests de l’Explorateur de tests, avec des informations sur le résultat et la durée.

En outre, dans l’Explorateur de tests, vous pouvez également sélectionner des tests individuels et cliquer avec le bouton droit pour Exécuter ou Déboguer les tests, ou Accéder au test pour ouvrir le code de test. Dans le menu supérieur, vous pouvez regrouper des tests, ajouter des tests à des playlists ou ouvrir des options de test.

Test unitaire d’une classe C#

Un ensemble stable de tests unitaires corrects est l'assurance que vous n'avez pas créé de bogues lors de la modification du code. L’exemple suivant décrit une méthode permettant de créer des tests unitaires pour une classe C# dans une application UWP. L’exemple utilise le développement piloté par les tests pour écrire des tests qui vérifient de comportements spécifiques, puis écrire du code qui réussit les tests.

Dans l’exemple de projet de code Maths, la classe Rooter implémente une fonction qui calcule la racine carrée estimée d’un nombre. Le projet RooterTests exécute le test unitaire de la classe Rooter .

Créer des solutions et des projets

Créer le projet d’application UWP :

1. Dans Visual Studio, dans le menu Fichier, sélectionnez Nouveau projet.
2. Sur la page Créer un projet, entrez application vide dans la zone Recherche, puis sélectionnez le modèle de projet Application vide C# (Windows universel).
3. Sur la page Configurer votre nouveau projet, nommez le projet Maths et sélectionnez Créer.
4. Modifiez éventuellement les versions cibles et minimales de la plateforme, puis sélectionnez OK. Visual Studio crée le projet et l’ouvre dans l’Explorateur de solutions.

Créer le projet de test unitaire :

1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution Maths et choisissez Ajouter>Nouveau projet.
2. Sur la page Ajouter un projet, entrez test unitaire dans la zone Recherche, puis sélectionnez le modèle de projet Application de test unitaire C# (Windows universel).
3. Nommez le projet de test RooterTests, puis sélectionnez Créer.
4. Modifiez éventuellement les versions cibles et minimales de la plateforme, puis sélectionnez OK. Le projet RooterTests apparaît sous la solution Maths dans l’Explorateur de solutions.

Vérifier l'exécution des tests dans l'explorateur de tests

La classe Assert fournit plusieurs méthodes statiques que vous pouvez utiliser pour vérifier les résultats dans les méthodes de test.

1. Dans l’Explorateur de solutions, sélectionnez le fichier UnitTest1.cs dans le projet RooterTests.

2. Insérez le code suivant dans TestMethod1 :

   [TestMethod]
   public void TestMethod1()
   {
       Assert.AreEqual(0, 0);
   }
   

3. Dans l’Explorateur de tests, sélectionnez Exécuter tous les tests.

4. Le projet de test est généré et exécuté, et le test s’affiche sous Tests réussis. Le volet Résumé du groupe à droite fournit des détails sur le test.

Ajoutez une classe au projet d’application

1. Dans l’Explorateur de solutions, faites un clic droit sur le projet Maths, puis sélectionnez Ajouter>Classe.

2. Nommez le fichier de classe Rooter.cs, puis sélectionnez Ajouter.

3. Dans l'éditeur de code, ajoutez le code suivant à la classe Rooter dans le fichier Rooter.cs :

   public Rooter()
   {
   }
   
   // estimate the square root of a number
   public double SquareRoot(double x)
   {
       return 0.0;
   }
   

   La classe Rooter déclare un constructeur et la méthode d'estimation SquareRoot. La méthode SquareRoot est une implémentation minimale pour tester la configuration de test de base.

4. Remplacez le mot clé internal par public dans la déclaration de classe Rooter, afin que le code de test puisse y accéder.

   public class Rooter
   

Ajouter une référence du projet de test au projet d’application

1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet RooterTests, puis sélectionnez Ajouter une>référence.

2. Dans la boîte de dialogue Gestionnaire de références - RooterTests, développez Projets, puis sélectionnez le projet Maths.

   

3. Cliquez sur OK.

4. Ajoutez l’instruction suivante using à UnitTest.cs, après la ligne using Microsoft.VisualStudio.TestTools.UnitTesting; :

   using Maths;
   

Ajoutez un test qui utilise la fonction d’application

1. Ajoutez la méthode de test suivante à UnitTest.cs :

   [TestMethod]
   public void BasicTest()
   {
       Maths.Rooter rooter = new Rooter();
       double expected = 0.0;
       double actual = rooter.SquareRoot(expected * expected);
       double tolerance = .001;
       Assert.AreEqual(expected, actual, tolerance);
   }
   

   Le nouveau test s’affiche dans l’Explorateur de solutions et dans le nœud Ne pas exécuter les tests de l’Explorateur de tests.

2. Pour éviter une erreur « La charge utile contient deux fichiers ou plus avec le même chemin de destination », dans l’Explorateur de solutions, développez le nœud Propriétés sous le projet Maths et supprimez le fichier Default.rd.xml.

3. Enregistrez tous les fichiers.

Exécuter les tests

Dans l’Explorateur de tests, sélectionnez l’icône Exécuter tous les tests. La solution se génère et les tests s'exécutent et réussissent.

Si vous obtenez une erreur d’entité dupliquée lorsque vous exécutez le test, supprimez le fichier de directive d’exécution, Properties\Default.rd.xml du projet de test, puis réessayez.

Vous avez configuré le test et les projets d’application et vérifié que vous pouviez exécuter des tests appelant les fonctions dans le projet de l’application. Maintenant, vous pouvez écrire le code et les tests réels.

Ajouter des tests et les faire réussir

Il est préférable de ne pas modifier les tests qui ont réussi. Au lieu de cela, ajoutez de nouveaux tests. Développez du code en ajoutant des tests un par un et assurez-vous que tous les tests réussissent après chaque itération.

1. Ajoutez un nouveau test appelé RangeTest à UnitTest.cs :

   [TestMethod]
   public void RangeTest()
   {
       Rooter rooter = new Rooter();
       for (double v = 1e-6; v < 1e6; v = v * 3.2)
       {
           double expected = v;
           double actual = rooter.SquareRoot(v*v);
           double tolerance = expected/1000;
           Assert.AreEqual(expected, actual, tolerance);
       }
   }
   

2. Exécutez le test RangeTest et vérifiez qu’il échoue.

   

   Astuce

   Dans le développement piloté par les tests, vous exécutez un test immédiatement après l’avoir écrit. Cette pratique vous permet d’éviter de commettre l'erreur d'écrire un test qui n'échoue jamais.

3. Corrigez le code de votre application afin que le nouveau test réussisse. Dans Rooter.cs, modifiez la SquareRoot fonction comme suit :

   public double SquareRoot(double x)
   {
       double estimate = x;
       double diff = x;
       while (diff > estimate / 1000)
       {
           double previousEstimate = estimate;
           estimate = estimate - (estimate * estimate - x) / (2 * estimate);
           diff = Math.Abs(previousEstimate - estimate);
       }
       return estimate;
   }
   

4. Dans l’Explorateur de tests, sélectionnez l’icône Exécuter tous les tests. Les trois tests réussissent maintenant.

Refactoriser le code

Dans cette section, vous refactorisez l’application et le code de test, puis réexécutez les tests pour vous assurer qu’ils réussissent toujours.

Simplifier l’estimation de la racine carrée

1. Dans Rooter.cs, simplifiez le calcul central dans la fonction SquareRoot en modifiant la ligne suivante :

   estimate = estimate - (estimate * estimate - x) / (2 * estimate);

   À

   estimate = (estimate + x/estimate) / 2.0;

2. Exécutez tous les tests pour vous assurer que vous n’avez pas introduit de régression. Tous les tests devraient réussir.

Supprimer le code de test dupliqué

La méthode RangeTest code en dur le dénominateur de la variable tolerance transférée dans la méthode Assert. Si vous envisagez d’ajouter d’autres tests qui utilisent le même calcul de tolérance, l’utilisation d’une valeur codée en dur dans plusieurs emplacements rend le code plus difficile à gérer. À la place, ajoutez une méthode d’assistance privée à la classe UnitTest1 pour calculer la valeur de tolérance, puis appelez cette méthode à partir de RangeTest.

Pour ajouter la méthode d’assistance, dans UnitTest.cs :

1. Ajoutez la méthode suivante à la classe UnitTest1 :

   private double ToleranceHelper(double expected)
   {
       return expected / 1000;
   }
   

2. Dans RangeTest, modifiez la ligne suivante :

   double tolerance = expected/1000;

   À

   double tolerance = ToleranceHelper(expected);

3. Exécutez le test RangeTest pour vous assurer qu’il réussit toujours.

Conseil

Si vous ajoutez une méthode d’assistance à une classe de test que vous ne souhaitez pas voir apparaître dans la liste dans l’Explorateur de tests, n’ajoutez pas l’attribut TestMethodAttribute à la méthode.

Étapes suivantes

• Tâches et outils de test unitaire
• Procédure pas à pas : Créer et exécuter des tests unitaires pour le code managé
• Procédure pas à pas : développement piloté par les tests avec l’Explorateur de tests