ASP.NET Core : apprendre l'exécution de tests unitaires dans une application MVC avec MsTest V2,
Un tutoriel de Hinault Romaric

Le , par Hinault Romaric, Responsable .NET
ASP.NET Core apporte une refonte complète de la solution de développement Web de Microsoft. Le recours à un nouvel environnement d'exécution (DNX) et son architecture entraînent une incompatibilité avec de nombreux outils.

En effet, si vous développez un projet ASP.NET Core qui utilise uniquement le CoreCLR, vous ne devez qu’utiliser les dépendances qui offrent une prise en charge du CoreCLR.


Depuis l’annonce de .NET Core, de nombreux éditeurs de librairies se sont activés pour offrir une prise en charge de cette version, c’est notamment le cas des outils de tests, dont MSTest.

Microsoft a publié il y a quelques semaines une préversion de la V2 de MsTest, qui introduit une architecture unifiée et apporte une prise en charge de .NET Core. Dans le cadre de ce billet de blog, nous verrons comment mettre en place des tests unitaires dans un projet ASP.NEt MVC Core avec MSTest V2.

Nous allons dans un premier temps créer une application ASP.NET Core en utilisant le modèle Web Application.


Ceci fait, vous allez ajouter un nouveau projet de type bibliothèque de classe à votre projet. Pour l’instant, il n’existe pas de modèle de projet pour la nouvelle version du framework de test de Microsoft. Cette prise en charge sera effective dans la version stable de l’outil, avec la sortie de Visual Studio 15.


Ajoutez les dépendances suivantes à votre projet en utilisant la console Nuget :

  • MSTest.TestFramework
  • MSTest.TestAdapter
  • dotnet-test-mstest


Le package MSTest.TestFramework permet d’installer le framework MSTest V2. Pour l’installer, cliquez sur Tools dans la barre de menu de Visual Studio, puis Nuget Package Manager, ensuite sur Package Manager Console. Rassurez-vous que dans la zone Default Project, vous avez sélectionné votre projet de test :


Dans la console NuGet, tapez la commande suivante :

Code : Sélectionner tout
Install-Package MSTest.TestFramework -Pre
MSTest.TestAdapter est utilisé pour trouver et exécuter le framework de test sur lequel votre projet de test est basé. Pour l’installer, vous devez exécuter la commande suivante dans la console NuGet :

Code : Sélectionner tout
Install-Package MSTest.TestAdapter -Pre:

Enfin, vous allez exécuter la commande suivante pour installer le dernier package NuGet :

Code : Sélectionner tout
Install-Package dotnet-test-mstest -Pre
Vous allez probablement obtenir un message d’erreur d’incompatibilité lors de la restauration des packages par NuGet. Ouvrez le fichier Project.json et remplacez :

Code json : Sélectionner tout
1
2
3
4
5
"frameworks": { 
   "netstandard1.6": { 
     "imports": "dnxcore50" 
   } 
}

Par

Code json : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"frameworks": { 
   "netcoreapp1.0": { 
     "imports": [ 
       "dnxcore50", 
       "portable-net45+win8" 
     ], 
  
     "dependencies": { 
       "Microsoft.NETCore.App": { 
         "version": "1.0.0", 
         "type": "platform" 
       } 
     } 
   } 
 }

Vous remarquerez sans doute que nous avons marqué notre bibliothèque de classes comme une application (netcoreapp1.0). Cela est dû au fait que notre projet de test utilise le .NET CLI. Sa méthode Main sera fournie par le runner de mstest.

Vous devez par la suite ajouter au fichier Project.json la ligne suivante, pour spécifier que votre projet de test unitaire repose sur mstest :

Code : Sélectionner tout
"testRunner": "mstest",
Ajoutez une référence au projet ASP.NET Core. Votre fichier Project.json devrait ressembler à ceci :

Code json : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
{ 
 "version": "1.0.0-*", 
  
 "testRunner": "mstest", 
  
 "dependencies": { 
   "dotnet-test-mstest": "1.1.1-preview", 
   "MSTest.TestAdapter": "1.0.3-preview", 
   "MSTest.TestFramework": "1.0.1-preview", 
   "NETStandard.Library": "1.6.0", 
   "SampleApp": "1.0.0-*" 
 }, 
  
 "frameworks": { 
   "netcoreapp1.0": { 
     "imports": [ 
       "dnxcore50", 
       "portable-net45+win8" 
     ], 
  
     "dependencies": { 
       "Microsoft.NETCore.App": { 
         "version": "1.0.0", 
         "type": "platform" 
       } 
     } 
   } 
 } 
  
}

Ajoutez un nouveau fichier HomeControllerTest.cs à votre projet de test. Ajoutez un appel à l’espace de nom Microsoft.VisualStudio.TestTools.UnitTesting :

Code : Sélectionner tout
using Microsoft.VisualStudio.TestTools.UnitTesting;
Jetons maintenant un coup d’œil au fichier HomeController.cs

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
using Microsoft.AspNetCore.Mvc; 
  
namespace SampleApp.Controllers 
{ 
   public class HomeController : Controller 
   { 
       public IActionResult Index() 
       { 
           return View(); 
       } 
  
       public IActionResult About() 
       { 
           ViewData["Message"] = "Your application description page."; 
  
           return View(); 
       } 
  
       public IActionResult Contact() 
       { 
           ViewData["Message"] = "Your contact page."; 
  
           return View(); 
       } 
  
       public IActionResult Error() 
       { 
           return View("~/Views/Shared/Error.cshtml"); 
       } 
   } 
}

Nous allons écrire du code pour tester le ViewResult et une autre pour le ViewData.

Le code que nous allons écrire va permettre de vérifier que la méthode d’action Error() retourne le bon ViewResult. Le code de test est le suivant :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
[TestMethod] 
       public void Error_ReturnsErrorView() 
       { 
           // Arrange 
           var controller = new HomeController(); 
           var errorView = "~/Views/Shared/Error.cshtml"; 
  
           // Act 
           var viewResult = controller.Error() as ViewResult; 
  
           // Assert 
           Assert.AreEqual(errorView, viewResult.ViewName); 
       }

Pour le ViewData, nous allons tester que notre méthode d’action renvoie le bon ViewData. La méthode de test pour effectuer cela est la suivante :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
[TestMethod] 
       public void About_ReturnsViewData() 
       { 
           // Arrange 
           var controller = new HomeController(); 
           var viewData = "Your application description page."; 
  
           // Act 
           var viewResult = controller.About() as ViewResult; 
  
           // Assert 
           Assert.AreEqual(viewData, viewResult.ViewData["Message"]); 
       }

Le code complet est le suivant :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
[TestClass] 
    public class HomeControllerTest 
    { 
  
  
        [TestMethod] 
        public void Error_ReturnsErrorView() 
        { 
            // Arrange 
            var controller = new HomeController(); 
            var errorView = "~/Views/Shared/Error.cshtml"; 
  
            // Act 
            var viewResult = controller.Error() as ViewResult; 
  
            // Assert 
            Assert.AreEqual(errorView, viewResult.ViewName); 
        } 
  
  
        [TestMethod] 
        public void About_ReturnsViewData() 
        { 
            // Arrange 
            var controller = new HomeController(); 
            var viewData = "Your application description page."; 
  
            // Act 
            var viewResult = controller.About() as ViewResult; 
  
            // Assert 
            Assert.AreEqual(viewData, viewResult.ViewData["Message"]); 
        } 
    }

A l’exécution, vous allez obtenir le résultat suivant dans l’explorateur de test :


C’est tout. Dans un prochain billet, nous verrons comment écrire des tests unitaires smockés avec mstest v2 et la preview de Moq, qui prend aussi en charge .NET Core.


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster un commentaire

Avatar de François DORIN François DORIN - Rédacteur/Modérateur https://www.developpez.com
le 27/08/2016 à 18:03
Bonjour,

Merci pour ce billet très intéressant. Il ferait un très bon article sur DVP
Avatar de Hinault Romaric Hinault Romaric - Responsable .NET https://www.developpez.com
le 30/08/2016 à 0:24
Citation Envoyé par dorinf;bt3048
Bonjour,

Merci pour ce billet très intéressant. Il ferait un très bon article sur DVP

Merci pour ton commentaire
Avatar de emilie77 emilie77 - Membre du Club https://www.developpez.com
le 02/09/2016 à 18:55
Merci bcp. Je cherche d'apprendre .net core mais on trouve très peu en francais
Avatar de Jahmass Jahmass - Candidat au Club https://www.developpez.com
le 05/09/2016 à 10:22
Bon article Romaric. Simple et efficace.

Citation Envoyé par emilie77;bt3066
Merci bcp. Je cherche d'apprendre .net core mais on trouve très peu en francais

Bienvenue dans le monde du développement. Le français n'est qu'une langue de seconde zone dans ce monde, je vous conseille fortement de travailler l'anglais technique à minima pour pouvoir profiter de la multitude d'articles anglophone.

De plus, .NET Core n'est pas fondamentalement si différent dans le développement (Il y a quelques API qui ont complètement changé mais ça n'est pas tant déroutant). C'est bien plus la partie paramétrage (project.json) avec le côté modulaire qui change beaucoup.
Offres d'emploi IT
Tourneur Fraiseur CN (H/F)
AGENCE SUPPLAY - Champagne Ardennes - Charleville-Mézières (08090)
Développeur informatique (h/f)
B&B Hôtels - Bretagne - Brest (29200)
Consultant AMOA Assurances (H/F)
Atos Technology Services - Centre - Orléans (45000)

Voir plus d'offres Voir la carte des offres IT
Contacter le responsable de la rubrique Accueil