Fathi Bellahcene

TDD avec Visual Studio 2012 : Part1/3

Je  vous propose de partager avec vous cet article grandement inspiré de l’article publié dans le magazine Programmez et écrit avec Jason De Oliveira. Je tiens également à préciser que le but de cet article est surtout de montrer qu’avec les nouveautés apportés dans Visual Studio 2012, l’application du TDD quelque soit la technologie et le framework de test que l’on souhaite utiliser est grandement facilité.

Je vais donc faire trois posts avec les thèmes suivants:

Part 1: rappel sur le TDD + Nouveautés

Part 2 : (Nouveautés fin) + Améliorations ergonomique

Part 3 : Exemple d’application du TDD

L’objectif de cet article est d’être pragmatique et orienté projet : nous souhaitons montrer que les nouveautés apportées dans la nouvelle version de Visual Studio 2012 permettront aux développeurs de faciliter et de rendre naturel le développement TDD. Il s’agit également de simplifier et limiter l’intégration des différents outils dans un processus d’intégration continue.

Le Test Driven Development (développement piloté par les tests) décrit une technique de développement de logiciel qui consiste à écrire des tests unitaires avant l'écriture du code source.

Voici les différentes étapes du Test Driven Development :

1. Ecriture du premier test pour une nouvelle fonctionnalité puis vérification de l’échec du test (l’implémentation de la nouvelle fonctionnalité n’étant pas encore réalisée)
2. Implémentation du code minimal nécessaire pour passer le test puis vérification du succès du test (l’implémentation fournit alors le comportement attendu)
3. Refactorisation et optimisation du code, les tests assurent la cohérence des fonctionnalités

L’utilisation du Test Driven Development permet ainsi l’obtention d’un code source très fiable, prévisible, robuste et, après refactorisation, hautement optimisé. Les tests assurent un comportement correct de celui-ci indépendamment des situations auxquelles il pourra être exposé. Le code source devient alors valide en toutes circonstances.

Pour créer de bons tests unitaires, il faut d’abord réfléchir à la conception du programme et à la façon dont il va être utilisé. Il faut éviter une précipitation dans l'implémentation avant d'avoir défini les objectifs. Des erreurs de conception peuvent ainsi être identifiées et résolues plus vite. L’implémentation passe seulement après la validation de la conception complète via les tests unitaires. Les tests unitaires deviennent une sorte de spécification générale décrivant les fonctionnalités du programme de manière unitaire.

Quant à la refactorisation, l’optimisation et la restructuration du code peuvent se faire sans risque car ils sont vérifiables ; les tests unitaires assurant alors la non-régression technique et la cohérence du comportement. Le comportement étant exprimé dans les tests unitaires, ils valident que le programme se comporte toujours de la même façon si les tests passent avec succès. De plus, en associant la méthode d’Extreme Programming (XP) et la programmation en binôme, on obtient un code de très bonne qualité.

Contrairement à d’autres méthodes où les tests sont abordés en fin du cycle, le Test Driven Development met donc le focus sur les tests dès les premières étapes du cycle de développement. Aucun développement ne peut commencer avant que les tests soient conçus et implémentés. Cette méthode a donc un large impact sur l’organisation de l’équipe de développement.

Support des frameworks de tests dans Visual Studio 2012

Les versions précédentes de Visual Studio permettent l’utilisation d’autres frameworks de tests, mais cela implique certaines limitations comme par exemple :

· L’utilisation d’une application tierce pour jouer les tests unitaires comme avec Gallio : l’utilisation de l’application Icarus Runner est indispensable pour pouvoir exécuter les tests unitaires.

· La couverture de code native ne fonctionne pas sans l’utilisation d’autres plugins (NCover).

· L’exécution des tests unitaires diffère en fonction des plugins : un test utilisant MSTest ne s’exécute pas de la même manière s’il est lancé depuis Visual Studio 2008 ou depuis Resharper, ceci peut poser problème lors de l’utilisation d’un processus d’intégration continue.

Au final avec l’ancienne version de Visual Studio 2010, on finit par multiplier les plugins et les outils pas toujours compatibles les uns avec les autres, ce qui ne permet pas vraiment de tirer avantage des fonctionnalités avancées des frameworks de tests spécialisés.

­Dans un environnement où le nombre de projets est conséquent, on a besoin de pouvoir utiliser un framework de tests plutôt qu’un autre en fonction des spécificités du projet et des fonctionnalités de celui-ci. Il est donc important de pouvoir proposer aux équipes de développement un large choix de frameworks de tests avec un coût d’intégration limité (dans les outils de développement comme dans les outils d’intégration continue).

L’une des belles surprises de cette nouvelle version de Visual Studio est justement le support de plusieurs frameworks de tests unitaires tels que :

Pour .NET :

• NUnit (http://nunit.org)
• xUnit.net (http://xunit.codeplex.com)
• MBUnit (https://github.com/Gallio/Gallio-VS2011-Integration)

Pour Javascript/HTML :

• QUnit & Jasmine (http://chutzpah.codeplex.com)

Pour C++ :

• MSTest Native (http://aka.ms/mstest-native-vs11)

Prenons, par exemple l’intégration du framework de tests NUnit. Après l’installation de NUnit via NuGet :

L’adaptateur de test est téléchargeable sous la forme d’un plugin via le gestionnaire d’extension :

Disponible dans le menu « Tools/Extensions and Updates… » de Visual Studio 2012 :

Cette fonctionnalité est complètement intégrée à Visual Studio et les adaptateurs de test sont disponibles gratuitement sur internet.

Ensuite, vous pouvez écrire vos tests unitaires en utilisant les fonctionnalités intégrées et les exécuter directement dans Visual Studio 2012. Vous pouvez ainsi obtenir les résultats des tests et d’autres informations comme l’analyse de la couverture du code:

Le support des tests unitaires pour les programmes en C++ est également une nouveauté non négligeable. Les développeurs C++ pourront ainsi se mettre au TDD en utilisant les projets de type “MSTest Native'”:

Voici un exemple d’implémentation des tests unitaires en utilisant C++ et MSTest Native :

Support de « async » et « await » dans les tests

Avec l’arrivée du framework .Net 4.5 et surtout de Windows 8, il est évident que la programmation asynchrone est l’une des nouveautés les plus importantes et incontournables ; Visual Studio 2012 et son framework de test unitaire supportent parfaitement cette nouvelle approche.

Les mots clé async et await introduits par .Net 4.5 peuvent désormais être utilisés pour faire des tests unitaires sur des méthodes asynchrones.

Voici un exemple d’une méthode asynchrone à tester :

   1: public async Task<int> AdditionAsync(int value1, int value2)

   2: {

   3:     // Simulate computing time

   4:     await Task.Delay(3000);

   5:     return  value1 + value2;

   6: }

La méthode de test correspondante, implémentée en utilisant NUnit, pourrait être la suivante :

   1: [Test]

   2: public async void AdditionAsync_PositiveValues()

   3: {

   4:     var calculator = new Calculator();

   5:     var result = await calculator.AdditionAsync(1, 2);

   6:     Assert.AreEqual(3, result);

   7: }