Comment : créer et exécuter un test unitaire

Article
08/10/2011

Les tests unitaires offrent aux développeurs et aux testeurs une méthode rapide pour rechercher des erreurs de logique dans les méthodes des classes des projets en C#, Visual Basic .NET et C++. Un test unitaire peut être créé une fois et exécuté à chaque modification du code source pour s'assurer qu'aucun bogue n'a été introduit.

Cette rubrique couvre l'utilisation des outils de test unitaire Microsoft Visual Studio 2010 pour générer automatiquement le squelette d'un test unitaire à partir de code existant, ajouter la validation pour remplir ce squelette, créer une catégorie de test, créer une liste de tests, effectuer un test et lire les résultats de la couverture du code.

Pour obtenir la description des parties d'un test unitaire, consultez la propriété Anatomie d'un test unitaire.

Exemple de test unitaire

Cet exemple repose sur la rubrique Procédure pas à pas : création et exécution de tests unitaires.

L'illustration suivante présente la boîte de dialogue Créer des tests unitaires. Elle apparaît lorsque vous cliquez avec le bouton droit dans un fichier de code qui contient des méthodes, puis sur Créer des tests unitaires. Les tests unitaires sont générés pour toutes les méthodes que vous sélectionnez dans la liste Types de la boîte de dialogue.

L'illustration suivante montre que dans cet exemple, les tests unitaires seront générés pour les méthodes Credit et Debit.

Boîte de dialogue Créer des tests unitaires

Après que vous avez généré vos tests unitaires, un fichier de code est créé et les modifications sont affichées dans votre explorateur de solutions.

L'illustration suivante montre les résultats de la création des tests unitaires.

Propriétaire du titre requis par l'état de l'image

Un test unitaire séparé est créé pour chaque méthode que vous sélectionnez dans la boîte de dialogue Créer des tests unitaires. Dans cet exemple, nous avons généré des tests unitaires pour les méthodes Credit et Debit.
Chaque test unitaire qui est généré a des variables vides et une instruction Assert d'espace réservé. L'instruction Assert d'espace réservé par défaut est habituellement l'instruction Assert.Inconclusive.
Pour rendre le test explicite, vous devez initialiser les variables et remplacer l'espace réservé par une instruction Assert appropriée. Dans cet exemple, nous avons laissé le test unitaire Credit comme il a été généré, mais nous avons initialisé les variables et avons remplacé l'instruction Assert dans la méthode de test Debit.
La première fois que vous générez des tests unitaires, un projet de test est créé dans votre solution.
Pour chaque classe que vous testez, un fichier de test unitaire séparé est créé dans le projet de test. Dans cet exemple, les deux méthodes que nous testons appartiennent à la même classe. Par conséquent, il y a un seul fichier de test unitaire, BankAccountTest.cs.
Après avoir effectué vos tests, les résultats s'affichent dans la fenêtre Résultats des tests.

Création d'un test unitaire

La création d'un test unitaire comporte deux phases.

La première phase consiste à générer un fichier de test unitaire contenant une version squelette d'une méthode de test pour chaque méthode du code que vous testez. Chaque méthode de test squelette est générée avec des variables vides et une instruction Assert d'espace réservé.

La deuxième phase consiste à initialiser les variables et à remplacer l'instruction Assert d'espace réservé par une valeur appropriée.

Générer les squelettes de vos tests unitaires

Vous utilisez la boîte de dialogue Créer des tests unitaires pour générer des tests unitaires pour une ou plusieurs méthodes dans le code que vous testez.

Notes

Bien que, en général, les méthodes marquées avec des attributs privés, internes et friend ne sont pas visibles de l'extérieur de la classe de ces méthodes, les outils Microsoft Visual Studio 2010 autorisent l'accès des tests unitaires à ces méthodes. Pour plus d'informations sur la façon dont cela fonctionne, consultez Tests unitaires pour les méthodes privée, interne et friend.

Pour générer le squelette de votre test unitaire

Ouvrez le code que vous souhaitez tester dans la fenêtre Éditeur de code Visual Studio.
(Pour les services ASP.NET uniquement) Si vous testez un service Web ASP.NET, assurez-vous que le projet contient une page .aspx. Si vous créez un test unitaire pour un service Web dans un projet qui ne contient pas de page .aspx, vous obtiendrez une erreur en essayant d'effectuer le test. Pour plus d'informations, consultez Tests unitaires pour les services Web ASP.NET.
Cliquez avec le bouton droit sur l'espace de noms, la classe ou la méthode à tester, puis cliquez sur Créer des tests unitaires.
Dans la boîte de dialogue Créer des tests unitaires, activez les cases à cocher pour toutes les méthodes que vous souhaitez ajouter au fichier de test unitaire.
(Facultatif) Cliquez sur Paramètres pour modifier les paramètres par défaut pour les tests unitaires que vous créez. Ce sont des paramètres Visual Studio et ces derniers s'appliquent à tous les tests unitaires que vous créez jusqu'à ce que vous modifiiez à nouveau les paramètres.
- Paramètres d'affectation des noms : ces options vous permettent de personnaliser la façon dont vos classes de test, méthodes de test et fichiers de test sont nommés lorsque vous générez des tests unitaires.
- Marquer tous les résultats de test Non concluant par défaut : activez la case à cocher pour fournir à chaque méthode de test une instruction Assert.Inconclusive () comme Assert d'espace réservé. Désactivez la case à cocher pour éliminer les Asserts d'espace réservé.
- Activer les commentaires sur la documentation : activez la case à cocher pour fournir à chaque méthode de test des commentaires d'espace réservé. Désactivez la case à cocher pour éliminer les commentaires d'espace réservé.
- Honorer l'attribut InternalsVisibleTo : activez la case à cocher pour permettre à des méthodes marquées comme Fonction friend ou Interne d'être traitées comme si elles étaient des méthodes publiques (recommandé). Désactivez la case à cocher pour les faire tester à l'aide d'un accesseur private. Pour plus d'informations sur les accesseurs private, consultez Tests unitaires pour les méthodes privée, interne et friend.
(Facultatif) Pour ajouter des tests pour les méthodes dans les assemblys pour lesquels vous n'avez pas le code source, cliquez sur Ajouter un assembly. Pour plus d'informations, consultez Comment : créer un test unitaire sans code source.
Dans la zone Projet de sortie, procédez de l'une des manières suivantes :
- Pour créer un nouveau projet de test, sélectionnez un langage pour le nouveau projet, puis cliquez sur OK. La boîte de dialogue Nouveau projet de test s'affiche. Vous pouvez nommer le projet ou accepter le nom par défaut, puis cliquer sur Créer.
- Pour ajouter les méthodes sélectionnées dans la boîte de dialogue Créer des tests unitaires aux fichiers de test unitaire dans un projet de test existant, sélectionnez le projet dans la liste déroulante, puis cliquez sur OK.

Ajout de validation à vos tests unitaires

Chaque méthode de test dans un fichier de test unitaire est générée avec des variables vides et une instruction Assert d'espace réservé. Vous pouvez effectuer un test de ce type, mais étant donné qu'il n'y a pas de données réelles, vous ne pouvez pas voir si la méthode se comporte comme attendu. Pour rendre le test explicite, vous devez initialiser les variables et remplacer l'instruction Assert d'espace réservé par une instruction qui soit appropriée pour cette méthode, laquelle est souvent l'instruction Assert.AreEqual.

Pour ajouter la validation à votre test unitaire

Ouvrez le fichier de test unitaire, puis localisez le test unitaire pour lequel vous souhaitez initialiser des variables.
Recherchez les assignations de variables dans le test unitaire.

Dans les tests générés récemment, les assignations de variables sont marquées par des instructions « TODO » qui vous rappellent que vous devez les personnaliser. Voici un exemple d'assignation qui doit être modifiée :

string target.owner = null; // TODO: Initialize to an appropriate value
Assignez une valeur appropriée à chaque variable. Pour obtenir un exemple d'assignation de variables appropriées, consultez la procédure « Exécution et modification d'un test unitaire » dans Procédure pas à pas : création et exécution de tests unitaires.

Notes

Vous pouvez exécuter vos tests unitaires à l'aide d'une série de valeurs différentes en créant un test unitaire piloté par les données. Un test unitaire piloté par des données est un test unitaire qui est exécuté à plusieurs reprises pour chaque ligne dans une source de données. Pour plus d'informations, consultez Comment : créer un test unitaire piloté par des données.
Recherchez et modifiez l'instruction Assert dans le test unitaire. Pour plus d'informations sur les instructions Assert disponibles, consultez Utilisation des classes Assert.
(Facultatif) Ajoutez du code de configuration et de nettoyage pour vos tests unitaires à l'aide des méthodes [TestInitialize()] et [TestCleanup()] de l'espace de noms Microsoft.VisualStudio.TestTools.UnitTesting. Lorsque vous générez un test unitaire, une section « Attributs de test supplémentaires » est ajoutée à votre fichier de test unitaire. Développez cette section pour afficher les méthodes commentées que vous pouvez utiliser pour inclure l'initialisation et le nettoyage.

(Facultatif) Création d'une catégorie de test

Vous pouvez gérer vos tests automatisés en les catégorisant à l'aide de catégories de test. Pour plus d'informations, consultez Définition de catégories de test pour regrouper vos tests.

Notes

Les catégories de test sont recommandées par rapport aux listes de tests. Les catégories de test vous permettent d'exécuter des groupes de tests selon leurs catégories assignées sans devoir maintenir des listes de tests.

Pour créer une nouvelle catégorie de test

Ouvrez la fenêtre Affichage des tests.
Sélectionnez un test.
Dans le volet de propriétés, cliquez sur Catégories de test, puis sur le bouton de sélection (...) dans la colonne la plus à droite.
Dans la fenêtre Catégorie de test, dans la zone Ajouter une nouvelle catégorie, tapez un nom pour votre nouvelle catégorie de test.
Cliquez sur Ajouter, puis sur OK.

La nouvelle catégorie de test sera assignée à votre test et sera disponible pour les autres tests via leurs propriétés.

(Facultatif) Création d'une liste de tests

Les listes de tests sont une méthode pour collecter des tests unitaires dans des groupes logiques. Les avantages principaux de l'ajout de tests unitaires à une liste de tests sont les suivants : vous pouvez exécuter des tests à partir de plusieurs fichiers de test unitaire, vous pouvez les exécuter dans le cadre d'une build, et vous pouvez utiliser les listes pour mettre en vigueur une stratégie d'archivage. Pour plus d'informations sur les listes de tests, consultez Définition de listes de tests pour regrouper des tests.

Notes

Les catégories de test sont recommandées par rapport aux listes de tests. Les catégories de test vous permettent d'exécuter des groupes de test selon leurs catégories assignées sans devoir maintenir des listes de tests.

Pour créer une liste de tests

Dans le menu Test, cliquez sur Créer une nouvelle liste de tests.
Dans la boîte de dialogue Créer une nouvelle liste de tests, tapez un nom pour la liste, ajoutez une description, sélectionnez l'endroit où la liste de tests doit résider, puis cliquez sur OK.
Pour afficher les tests disponibles, dans la fenêtre Explorateur de tests, cliquez sur Tous les tests chargés.
Faites glisser chaque test unitaire que vous souhaitez ajouter de la fenêtre principale sur votre liste de tests.

Exécuter un test unitaire

Après avoir créé vos tests unitaires, vous pouvez les exécuter à tout moment. Cette procédure offre un moyen d'exécuter des tests unitaires, mais pour plus d'informations sur d'autres méthodes, telles que l'utilisation des raccourcis clavier ou de la ligne de commande, consultez Comment : exécuter des tests automatisés à partir de Microsoft Visual Studio.

Pour exécuter un test unitaire

Dans le menu Test, pointez sur Fenêtres, puis cliquez sur Affichage des tests.
(Facultatif) Si vous souhaitez collecter les informations de couverture du code, procédez comme suit :
1. Dans le menu Test, pointez sur Modifier les paramètres de test, puis cliquez sur les paramètres de test pour votre série de tests actuelle.
2. Dans la boîte de dialogue Paramètres de test, cliquez sur Données et diagnostics.
3. Sous Rôle, sélectionnez le rôle à utiliser pour exécuter vos tests.
4. Activez la case à cocher Couverture du code, puis cliquez sur Configurer.
5. Sélectionnez la case à cocher ou les zones permettant de sélectionner des éléments pour lesquels collecter les informations de couverture du code.
6. Dans la boîte de dialogue Couverture du code, cliquez sur OK.
7. Dans la boîte de dialogue Paramètres de test, cliquez sur Appliquer, puis sur Fermer.
Dans la fenêtre Affichage des tests, sélectionnez un ou plusieurs tests. Pour sélectionner plusieurs tests, maintenez la touche CTRL enfoncée en cliquant sur les tests.
Dans la barre d'outils de la fenêtre Affichage des tests, cliquez sur le bouton Exécuter la sélection. Les tests sont exécutés et la fenêtre Résultats des tests s'ouvre.
(Facultatif) Pour voir les détails d'un test, cliquez dessus avec le bouton droit dans la fenêtre Résultats des tests, puis cliquez sur Afficher les détails des résultats des tests.
(Facultatif) Pour localiser la zone de votre fichier de test unitaire qui contient une erreur, dans la fenêtre de détails, sous Trace de la pile d'erreur, cliquez sur le lien de l'erreur.

Pour plus d'informations sur la compréhension des résultats de tests, consultez Examen des résultats des tests.

(Facultatif) Affichage des données de couverture du code

Si vous avez choisi de collecter des informations de couverture du code, vous pouvez ouvrir la fenêtre Couverture du code pour consulter le pourcentage des méthodes dans le code que vous testez qui a été couvert par vos tests unitaires. Pour plus d'informations sur la vérification de la couverture du code des tests qui ont déjà été effectués, et pour plus d'informations sur la gestion des résultats de couverture du code, consultez Vue d'ensemble des données de couverture du code.

Pour consulter la couverture du code pour les tests unitaires

Dans la fenêtre Résultats des tests, sur la barre d'outils, cliquez sur Afficher les résultats de la couverture du code. Vous devrez peut-être agrandir la fenêtre pour apercevoir le bouton.
La fenêtre Résultats de la couverture du code s'ouvre.

Cette fenêtre affiche l'étendue sur laquelle la méthode a été testée.