TESTS UNITAIRES dans Asp.Net : didacticiel complet
Jacob Lee
⚡ Résumé intelligent
Les tests unitaires d'une application ASP.NET dans Visual Studio commencent par un projet de test unitaire, établissent une référence au projet cible, ajoutent les attributs MSTest [TestClass] et [TestMethod] et appellent les méthodes Assert pour prouver que les classes se comportent comme prévu.
Les tests sont un aspect essentiel de tout langage de programmation. Tests Cela est possible pour les applications ASP.NET grâce à Visual Studio.
Visual Studio sert à créer du code de test. Il permet également d'exécuter ce code pour une application ASP.NET. Ainsi, il devient facile de détecter les erreurs dans une application ASP.NET. Le module de test de Visual Studio est prêt à l'emploi. On peut donc exécuter immédiatement un test pour un projet ASP.NET.
Introduction aux tests pour ASP.NET
Le premier niveau de test d'un projet ASP.NET consiste en des tests unitaires. Ces tests vérifient la fonctionnalité de l'application et s'assurent qu'elle se comporte comme prévu. En ASP.NET, la première étape est de créer un projet de test dans Visual Studio. Ce projet contiendra le code nécessaire aux tests.
Prenons l'exemple de la page web ci-dessous. Sur cette page, on trouve le message « GuruLe message « 99 – ASP.NET » s’affiche. Comment vérifier que le message correct est affiché lors de l’exécution d’un projet ASP.NET ? Pour cela, il faut ajouter un projet de test à la solution ASP.NET (utilisée pour développer des applications web). Ce projet de test permettra de s’assurer que le bon message est affiché à l’utilisateur.
Examinons maintenant plus en détail comment nous pouvons travailler sur les tests dans ASP.NET.
Création d'un projet de tests unitaires .NET
Avant de créer un projet de test, nous devons effectuer les étapes de haut niveau ci-dessous.
- Utilisez notre « DemoApplication » utilisée dans les sections précédentes. Ce sera notre application qui doit être testée.
- Nous allons ajouter une nouvelle classe à l'application de démonstration. Cette classe contiendra une chaîne de caractères appelée 'Guru99 – ASP.NET. Cette chaîne sera testée dans notre projet de test.
- Enfin, nous allons créer un projet de test. Celui-ci servira à tester l'application ASP.NET.
Suivons donc les étapes générales décrites ci-dessus et voyons comment mettre en œuvre les tests.
Étape 1) Assurez-vous que DemoApplication est ouvert dans Visual Studio.
Étape 2) Ajoutons maintenant une nouvelle classe à DemoApplication. Cette classe contiendra une chaîne de caractères appelée 'Guru99 – ASP.NET. Cette chaîne sera testée dans notre projet de test.
Suivez l'étape ci-dessous pour ajouter une nouvelle classe.
- Dans Visual Studio, cliquez avec le bouton droit sur « DemoApplication » dans l’Explorateur de solutions.
- Choisissez l'option Ajouter->Classe dans le menu contextuel.
Étape 3) Dans cette étape,
- Donnez un nom 'Tutorial.cs' pour la nouvelle classe.
- Cliquez sur le bouton « Ajouter » pour ajouter le fichier à l'application de démonstration.
Maintenant, une nouvelle classe est ajoutée au fichier « DemoApplication ».
Étape 4) Ouvrez le nouveau fichier Tutorial.cs depuis « DemoApplication ». Ajoutez la chaîne « Guru99 – ASP.NET.
Pour ouvrir le fichier, double-cliquez sur le fichier Tutorial.cs dans l'Explorateur de solutions.
Le fichier aura du code par défaut déjà écrit. Ne vous souciez pas de ce code, ajoutez simplement la ligne de code ci-dessous.
namespace DemoApplication { public class Tutorial { public String Name; public Tutorial() { Name = "Guru99 - ASP.Net"; } } }
Code Explication:-
- La variable Nom est de type chaîne.
- Enfin, dans le constructeur de la classe Tutorial, assignez la valeur de la variable Name. La valeur est assignée à «Guru99 – ASP.NET”
Étape 5) Maintenant, ouvrez le fichier demo.aspx et ajoutez les lignes de code permettant d'afficher le texte « Guru99 – ASP.NET.
<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head runat="server"> <title></title> </head> <body> <form id="form1" runat="server"> <div> <% DemoApplication.Tutorial tp=new DemoApplication.Tutorial();%> <%=tp.Name%> </div> </form> </body> </html>
Code Explication:-
- La première ligne crée un objet de la classe « Tutorial ». C'est la première étape lorsqu'on travaille avec des classes et des objets. Cet objet est nommé « tp ».
- Enfin, nous appelons « tutorial.cs » à partir du fichier demo.aspx. Il affiche la valeur de la variable Nom.
Lorsque vous exécutez le programme ci-dessus dans Visual Studio, vous obtiendrez le résultat suivant.
Production:-
Le résultat affiche le message «Guru99 – ASP.NET” affiché.
Étape 6) Ajoutons maintenant notre projet de test à l'application de démonstration. Pour ce faire, nous utiliserons Visual Studio.
- Cliquez avec le bouton droit sur la solution – DemoApplication.
- Dans le menu contextuel, choisissez l'option 'Nouveau projet'.
Étape 7) L'étape implique l'ajout du projet Unit Test à l'application de démonstration.
- Cliquez sur le type d'élément « Test » dans le panneau de gauche.
- Choisissez l'élément « Projet de test unitaire » dans la liste qui apparaît dans la partie centrale de la boîte de dialogue.
- Donnez un nom au projet de test. Dans notre cas, le nom donné est « DemoTest ».
- Enfin, cliquez sur le bouton « OK ».
Vous verrez éventuellement le projet DemoTest ajouté à l'explorateur de solutions. Avec cela, vous pouvez également voir d'autres fichiers comme UnitTest1.cs, les propriétés, etc. sont générés par défaut.
Exécution du projet de test
Le projet de test créé précédemment sert à tester notre application ASP.NET. Nous allons maintenant voir comment exécuter ce projet.
- La première étape consiste à ajouter une référence au projet ASP.NET. Cette étape permet au projet de test d'accéder au projet ASP.NET.
- Ensuite, nous écrirons notre code de test.
- Enfin, nous exécuterons le test à l'aide de Visual Studio.
Étape 1) Pour tester notre application de démonstration, le premier projet de test doit faire référence à l'application de démonstration. Ajoutez une référence à la solution Demo.aspx.
- Cliquez avec le bouton droit sur le projet Demo Test
- Dans le menu, choisissez l’option Ajouter->Référence.
Étape 2) L'étape suivante consiste à ajouter une référence à DemoApplication.
- Sélectionnez l'option Projets dans la partie gauche de la boîte de dialogue
- Cliquez sur la case à côté de DemoApplication
- Cliquez sur le bouton « OK ».
Cela permettra à un projet de démotest de tester notre DemoApplication.
Étape 3) Il est maintenant temps d'ajouter le code de test à notre projet de test.
- Pour cela, double-cliquez d'abord sur le fichier UnitTest1 (le fichier UnitTest1 est automatiquement ajouté par Visual Studio lors de la création du projet Test) dans l'Explorateur de solutions.
- Voici le fichier qui sera exécuté pour tester le projet ASP.NET.
Vous verrez le code ci-dessous ajouté par Visual Studio dans le fichier UnitTest1.cs. Il s'agit du code de base nécessaire à l'exécution du projet de test.
Étape 4) L'étape suivante consiste à ajouter le code qui sert à tester la chaîne «Guru99 – ASP.NET.
using System; using Microsoft.VisualStudio.TestTools.UnitTesting; using DemoApplication; namespace DemoTest { [TestClass] public class UnitTest1 { [TestMethod] public void TestMethod1() { Tutorial tp = new Tutorial(); Assert.AreEqual(tp.Name,"Guru99 - ASP.Net"); } } }
- Créez un nouvel objet appelé 'tp' du type Tutorial
- La méthode Assert.AreEqual est utilisée en .NET pour tester si une valeur est égale à une autre. Dans notre cas, nous comparons donc les valeurs de tp.Name à Guru99 – ASP.NET.
Étape 5) À présent, lançons notre projet de test. Pour cela, il faut aller dans le menu Test -> Exécuter -> Tous les tests.
Production:-
Une fenêtre de l'Explorateur de tests apparaîtra dans Visual Studio. Cela affichera le résultat ci-dessus et indiquera qu'un test réussi a été exécuté dans Visual Studio.
Attributs et assertions MSTest que vous utiliserez
Le MicrosoftL'espace de noms `.VisualStudio.TestTools.UnitTesting` fournit un petit ensemble d'attributs et d'assertions qui couvrent la plupart des tests unitaires ASP.NET. Les maîtriser en premier lieu facilite la lecture et la maintenance des tests suivants.
- [TestClass] – Indique que la classe est un conteneur de tests. MSTest analyse les classes possédant cet attribut lors de la découverte.
- [Méthode de test] – désigne une méthode publique sans paramètre comme un test individuel. La méthode ne renvoie ni void, ni Task, ni ValueTask.
- [Initialiser les tests] / [Nettoyer les tests] – Exécutez-les avant et après chaque méthode de test. Utilisez-les pour créer et supprimer des ressources partagées telles qu'un dépôt factice ou un contexte en mémoire.
- [Initialisation de classe] / [Nettoyage de classe] – à exécuter une seule fois pour toute la classe. Ces scripts sont utiles lorsque la configuration est coûteuse, par exemple pour initialiser une base de données de test.
- [DataRow] et [DataTestMethod] – fournir des entrées paramétrées afin qu'une seule méthode de test couvre plusieurs cas.
Dans chaque méthode de test, la classe Assert vérifie le résultat. Les appels courants incluent Assert.AreEqual pour les comparaisons de valeurs, Assert.IsTrue et Assert.IsFalse pour les booléens, Assert.IsNull et Assert.IsNotNull pour les références, et Assert.ThrowsException pour les exceptions attendues. Structurez chaque test selon le modèle Arrange, Act, Assert afin que la configuration, l'exécution et la vérification restent visuellement séparées. Cette structure facilite le débogage des tests en échec, car la ligne défaillante est presque toujours l'unique assertion située en bas du code.
Comparaison de MSTest, NUnit et xUnit pour ASP.NET
Trois frameworks de test dominent l'écosystème .NET. Chacun s'exécute dans Visual Studio et s'intègre à dotnet test ; la différence réside donc principalement dans le style, le support de la communauté et le comportement par défaut.
- Test MSTest – expédié par Microsoft et est fourni avec le modèle de projet de tests unitaires Visual Studio utilisé précédemment dans ce tutoriel. Il s'agit du choix par défaut le plus sûr pour une équipe qui découvre les tests unitaires sur Visual Studio. Microsoft association.
- Nunit – le plus ancien des trois, initialement porté depuis JUnitIl offre un modèle de contraintes riche, des tests paramétrés via TestCase et TestCaseSource, et une prise en charge mature pour toutes les versions de .NET.
- xUnit.net Utilisé en interne par les équipes ASP.NET Core et Entity Framework Core, ce modèle remplace la méthode SetUp par un constructeur et l'interface IDisposable, préconise une classe de test par comportement et utilise [Fact] et [Theory] au lieu de [TestMethod].
Les trois frameworks détectent les tests via leurs attributs, les exécutent avec la commande dotnet test et produisent des rapports XML trx ou xUnit que les pipelines d'intégration continue tels que Azure DevOps, GitHub Actions et Jenkins Il est possible de l'utiliser directement. Pour un premier projet ASP.NET, l'utilisation de MSTest simplifie la chaîne d'outils. Les équipes qui souhaitent une paramétrisation plus poussée ou qui utilisent déjà ASP.NET Core optent souvent pour xUnit par souci de cohérence avec le framework utilisé lors de son développement.
Meilleures pratiques pour les tests unitaires des applications ASP.NET
Le respect de quelques bonnes habitudes permet de maintenir une suite d'applications rapide, fiable et utile tout au long du cycle de vie d'un projet ASP.NET.
- Tester un comportement par méthode. Un test qui affirme plusieurs choses sans rapport les unes avec les autres échoue pour de nombreuses raisons et prend plus de temps à corriger.
- Nommez les tests en fonction de l'intention. Un modèle tel que MethodUnderTest_Scenario_ExpectedResult permet à l'explorateur de tests de générer une spécification lisible de la classe.
- Isolez l'unité des systèmes externes. Encapsulez les appels de fichiers, de réseau et de base de données derrière des interfaces et remplacez-les par des valeurs factices ou simulées afin que le test n'atteigne pas la dépendance réelle.
- Effectuez les tests rapidement. L'objectif est que l'ensemble des tests unitaires s'exécute en quelques secondes. Les tests lents sont ignorés, et les tests ignorés masquent les régressions.
- Suivez la structure « Préparer, Agir, Affirmer ». Trois petits blocs séparés par des lignes vides signalent l'intention et permettent de repérer facilement les lignes défectueuses.
- Exécutez des tests à chaque commit. Intégrez les tests dotnet dans un pipeline CI afin qu'un test défaillant bloque la fusion au lieu de la déployer.ping à la fabrication.
- TracAugmentez la couverture de code k, mais ne la poursuivez pas à tout prix. La couverture met en évidence les itinéraires non testés, mais un nombre élevé à lui seul ne garantit pas la qualité. RevVoyez à quoi servent réellement les lignes manquantes.
Appliquées conjointement, ces pratiques transforment le projet DemoTest construit ci-dessus en une base pour une suite qui détecte les régressions à chaque mise à jour, documente le comportement pour les futurs développeurs et donne confiance lors de la refactorisation d'une application ASP.NET.
