Microsoft Visual Studio Débutant : Tests unitaires

Name: Microsoft Visual Studio Débutant : Tests unitaires
Author: Gerald Eckert

Améliorer la qualité du code en écrivant des tests unitaires efficaces

Preview the first lesson free — get full access to all 4 lessons.

Cours : à la demande

Bonjour, je m'appelle Gérald. Dans ces leçons, vous apprendrez à effectuer des tests unitaires dans Visual Studio, nous utiliserons le test MS framework inclus par défaut avec Visual Studio. Dans cette leçon, je vais vous montrer comment ajouter un projet de test unitaire et écrivez votre premier test unitaire. Jetons d'abord un coup d'œil à notre code. Avant d'ajouter quelques tests unitaires. Ici, dans Visual Studio, j'ai une bibliothèque de classes ouverte avec quelques méthodes d'extension pour C#. Nous allons tester la classe des extensions entières et plus précisément la fonction is even. Il s'agit d'une méthode d'extension C# qui teste la régularité d'un entier, et il retournera un vrai ou fausse valeur selon que l'entier est pair ou non. Alors maintenant, nous avons appris le code, ajoutons un projet de test unitaire. Pour ajouter un projet de test unitaire, passez à votre explorateur de solutions, faites un clic droit sur votre nœud de solution puis sélectionnez ajouter, nouveau projet. Nous avons donc maintenant le nouvel écran Project Wizard. Nous allons rechercher des modèles de tests unitaires. Voici ce que vous pouvez voir différents types de tests unitaires. Nous pouvons voir un projet de test unitaire X utilisant le framework d'unité X. Nous avons un projet MS Test pour .Net Core et le projet de test unitaire pour .Net Framework. Nous allons sélectionner le projet de test unitaire pour le .Net Framework. Nous allons maintenant donner un nom à notre projet de test unitaire, J'appellerai cela des tests unitaires. Et puis je cliquerai sur créer pour l'ajouter à notre solution. Vous pouvez voir ici Visual Studio a ouvert le premier fichier par défaut. Je vais fermer tout ça, nous pouvons regarder l'explorateur de solutions. Vous pouvez voir dans notre explorateur de solutions ici, nous avons maintenant deux projets. Nous avons notre bibliothèque de classes originale, et un nouveau projet de test unitaire. Donc, avant de pouvoir écrire des tests unitaires, nous avons besoin pour référencer le code que nous allons tester. Nous devons donc ajouter une référence au projet de test unitaire par un clic droit sur le nœud des références et en sélectionnant ajouter une référence. Cela ouvrira le gestionnaire de références et nous allons référencer un projet au sein de notre solution. Ici, c'est la bibliothèque d'extensions. Je vais donc vérifier cela et cliquer sur OK. Cela ajoutera une référence à nos tests unitaires pour le projet de bibliothèque d'extension. Nous pouvons donc utiliser ce code. Alors maintenant, nous avons une référence ajoutée et nous sommes prêts à écrire des tests unitaires. Par défaut, Visual Studio ajoute un exemple de classe de test unitaire. Ouvrons ça. Je vais d'abord renommer notre classe et notre méthode de test donc il s'aligne avec la classe et la méthode de test que nous allons faire des tests unitaires qui est la classe des extensions entières et la fonction est paire. Je vais donc les renommer tous les deux pour qu'ils s'alignent correctement. J'ai donc renommé la classe de test et la méthode de test pour s'aligner sur le code que nous testons. La prochaine chose importante à prendre en compte sont ces attributs sur notre classe et leur méthode. Ces attributs indiquent à Visual Studio que ce ne sont pas du code régulier mais ce sont des cours de test et ils seront repris dans le testeur et exécutés en tant que tests unitaires. Ainsi, chaque test unitaire que nous écrivons sera décoré avec cet attribut de méthode de test. Maintenant, écrivons notre premier test unitaire pour tester c'est même fonction. Pour ce faire, nous allons utiliser des assertions. Nous allons déclarer une variable de test puis utilisez l'instruction assert pour tester notre variable de test. Je vais donc écrire notre première variable de test appelée test un et donnez-lui une valeur entière. Alors maintenant, nous avons une variable de test et on lui attribue une valeur de deux. Maintenant, je vais utiliser l'instruction assert et appelez la fonction is even pour tester la fonction. Alors maintenant, j'ai écrit la déclaration assert et j'appelle qui est même fonction. J'ai besoin d'inclure l'espace de nom, c'est pourquoi il y a une erreur. Et ce que cela va faire, c'est dire affirmer que cette déclaration à l'intérieur de la parenthèse est vrai. Et à l'intérieur d'ici, nous appelons ou est même une fonction, c'est la fonction que nous testons. Alors maintenant, le test unitaire est complètement écrit et nous sommes prêts à l'exécuter, pour exécuter vos tests unitaires passer à l'explorateur de solutions, faites un clic droit sur votre projet de test unitaire et sélectionnez exécuter les tests. Ce que cela fera, c'est ouvrir l'explorateur de tests et lancez vos tests unitaires. Vous voyez ici une arborescence organisée par projets, espace de noms, la classe et ensuite nous pouvons voir nos tests unitaires individuels. Et toutes ces coches vertes signifient que le test unitaire a réussi et ici dans le volet de droite nous pouvons voir des informations sur ce test unitaire spécifique. On peut voir la source et combien de temps ce test unitaire a pris pour s'exécuter. Allons ajouter un autre test unitaire afin que nous puissions voir à quoi ressemble un test unitaire raté. Je vais donc ajouter une nouvelle méthode de test ici et le faire volontairement échouer. Alors maintenant, j'ai ajouté un deuxième test unitaire appelé is even test two et j'ai mis la variable à trois. Et cela entraînera l'échec de cette déclaration parce que trois n'est certainement pas pair. Et nous affirmons qu'une déclaration sera vraie. Je vais donc passer à notre onglet Test Explorer et je vais sélectionner l'exécution de tous les tests en vue. Cela exécutera à nouveau tous nos tests unitaires et nous pouvons voir l'un d'eux échouer. Donc, ici, nos tests ont été exécutés et nous pouvons voir que même le test deux a échoué et nous voyons un message d'erreur. Voilà donc le cadre de base pour écrire des tests unitaires et les tester à l'aide du lanceur de tests. Alors maintenant, vous savez comment ajouter un projet de test unitaire à votre solution, écrire des tests unitaires, et utilisez l'explorateur de tests pour exécuter vos tests unitaires. Restez à l'écoute pour la prochaine leçon où nous couvrirons l'utilisation du framework MS Test pour mettre en place vos projets de tests unitaires.

Débutant Fournisseur : Gerald Eckert 4 leçons · 27m en Arabe, Allemand, Anglais, Espagnol, Français, Portugais, Chinese

Description du cours

Les tests unitaires sont essentiels pour vous assurer que vous avez écrit un code de qualité. Si votre code se casse souvent, doit constamment être remanié ou est très ancien, les tests unitaires sont souvent la solution à ces problèmes. Avec les tests unitaires, vous pouvez tester votre code pour de nombreux scénarios qu'il rencontrera. Cela vous permet de trouver rapidement les points de défaillance et les faiblesses, en les corrigeant avant qu'ils ne créent des bogues. Pour cela, nous allons nous intéresser à la mise en place de classes de tests unitaires et à l'écriture de tests unitaires pour tester les fonctions. Nous explorerons l'échec délibéré de nos tests unitaires et examinerons les messages d'erreur. Avec des tests unitaires correctement configurés, vous générerez moins de régressions, moins de rapports de bogues et réduirez la dette technique.

Dans Unit Testing, vous apprendrez à créer votre premier test unitaire et à rationaliser les tests unitaires avec les attributs MS Test. Nous discuterons également des paramètres du projet et apprendrons le développement piloté par les tests dans Visual Studio.

Ce que vous allez apprendre

Créer votre premier test unitaire dans Microsoft Visual Studio
Configurer des classes de test unitaire et des projets de test unitaire à l'aide des attributs MSTest
Écrire des tests unitaires pour tester vos fonctions, y compris faire échouer volontairement des tests et examiner les messages d'erreur
Appliquer le développement piloté par les tests (TDD) à de nouveaux projets dans Visual Studio
Améliorer la qualité du code grâce aux tests unitaires
Optimiser les tests unitaires à l'aide des attributs et de la configuration des procédures d'installation des tests

Points clés à retenir

Les tests unitaires vous aident à trouver les points de défaillance et les faiblesses de votre code afin que vous puissiez les corriger avant qu'ils ne créent des bugs.
Les tests unitaires vous permettent de tester votre code pour de nombreux scénarios qu'il rencontrera.
Lorsque les tests unitaires sont correctement configurés, vous générez moins de régressions, moins de rapports de bugs et vous réduisez la dette technique.
Les attributs MSTest et les procédures de configuration des tests contribuent à rationaliser le processus de test unitaire.
Les tests unitaires sont souvent la solution lorsque le code se casse souvent, a constamment besoin d'être remanié (refactoring) ou est très ancien.

Foire aux questions

Que vais-je apprendre dans ce cours ?

Vous apprendrez à créer votre premier test unitaire, à optimiser les tests unitaires avec les attributs MSTest, à configurer les paramètres du projet et à appliquer le développement piloté par les tests dans Visual Studio.

Comment le cours est-il structuré ?

Le cours comprend quatre leçons : Création de votre premier test unitaire ; Attributs MSTest et configuration de projets de test unitaire - Partie 1 ; Attributs MSTest et configuration de projets de test unitaire - Partie 2 ; et Développement piloté par les tests avec Visual Studio.

Quelles compétences vais-je acquérir avec ce cours ?

Vous développerez des compétences en tests de code, MSTest, tests logiciels, développement piloté par les tests unitaires, tests unitaires et Vstest.

Pourquoi les tests unitaires sont-ils importants ?

Les tests unitaires sont essentiels pour garantir que vous avez écrit un code de qualité ; ils vous permettent de tester votre code pour de nombreux scénarios qu'il rencontrera, de trouver rapidement les points de défaillance et les faiblesses, et de les corriger avant qu'ils ne créent des bugs, ce qui entraîne moins de régressions, moins de rapports de bugs et une réduction de la dette technique.

Le cours couvre-t-il ce qui se passe lorsque les tests échouent ?

Oui. Le cours explore l'échec intentionnel de vos tests unitaires et l'examen des messages d'erreur qui en résultent.