NUnit et l’intégration continue

L’utilité des tests unitaires et de l’intégration continue n’est plus à prouver. En revanche, l’association des deux peut demander un peu de gymnastique. En l’occurrence, il m’a fallu mettre les mains dans le cambouis pour lancer un projet de test via Jenkins (ex-Hudson), puis pour qu’il soit reconnu par Sonar.

Nous allons donc voir ici comment créer un projet de test, puis comment l’exécuter sous Jenkins.

Création d’un projet de test NUnit sous Visual Studio

Tout d’abord, après avoir ouvert la solution du projet concerné par les tests – on admettra que le projet s’appelle « CoucheServices » – créez un projet de type « Bibliothèque de classes » (clic-droit sur la solution, « Ajouter », « Nouveau projet… »). On l’appellera « CoucheServices.Tests ».

Puis, faites un clic-droit sur ce nouveau projet et choisissez « Gérer les packages NuGet ». cf. https://www.sodifrance.fr/blog/index.php/post/2011/06/28/NuGet%2C-le-gestionnaire-de-packages-.NET et http://nuget.org/

Une nouvelle fenêtre s’ouvre. Elle dispose d’un champ de recherche en ligne, situé en haut à droite de l’écran. Cherchez « nunit », puis cliquez sur « Installer ». Un fichier « packages.config » sera ajouté à la racine du projet de tests. Pensez à ajouter tous ces nouveaux fichiers et répertories au système de gestion de version (SVN ou GIT).

S’il s’agit de la première utilisation de NuGet, un dossier « packages » sera ajouté à la racine de la solution. Sauf restrictions particulières, il est conseillé d’ajouter ce répertoire au système de gestion de version.

De retour sur Visual Studio, faites un clic-droit sur les « Références » du projet, et ajoutez le projet que vous souhaitez tester. Dans notre cas, il s’agit de « CoucheServices ».

Enfin, vérifiez le contenu du fichier « App.config ». Logiquement, vous aurez besoin d’une chaîne de connexion. C’est celle qui est utilisée par votre projet à tester, et ce, directement, ou via un projet de couche d’accès aux données.

Ajoutez ensuite une nouvelle classe, par exemple : « UtilisateursServiceTests.cs ». Ajouter la dépendance à NUnit (using NUnit.Framework;), puis le code des tests. Voici un exemple :

   [TestFixture]
   public class UtilisateursServiceTests
   {
       [TestFixtureSetUp]
       public void SetUpFixture()
       {
           // executé une fois avant tous les tests
       }
       [TestFixtureTearDown]
       public void TearDownFixture()
       {
           // executé une fois après tous les tests
       }
       [SetUp]
       public void SetUp()
       {
           // executé avant chaque test
       }
       [TearDown]
       public void TearDown()
       {
           // executé après chaque test
       }
       [Test]
       public void TestFonctionQuiRetourneTousLesUtilisateurs()
       {
           var list = UtilisateursService.FonctionQuiRetourneTousLesUtilisateurs();
           Assert.IsNotNull(list);
           Assert.IsNotEmpty(list);
           Assert.True(list.Count > 0);
           Assert.True(list.Exists(u => u.Name == "Compte technique"));
       }
       [Test]
       public void TestFonctionQuiUnUtilisateur()
       {
           var user = UtilisateursService.FonctionQuiUnUtilisateur(1);
           Assert.IsNotNull(user);
           Assert.True(user.Name == "Compte technique");
       }

Compilez votre projet, puis exécutez les tests avec l’interface graphique de NUnit (http://nunit.org/index.php?p=download ; C:\Program Files (x86)\NUnit 2.6.2\bin\nunit.exe).

Pour ce faire, choisissez « File », « Open Project », puis la DLL du projet (par exemple : « C:\MonProjet\CoucheServices.Tests\bin\Debug\CoucheServices.Tests.dll »). Puis cliquer sur « Run ». Si tout s’est bien passé, vos tests devraient être « au vert ». En cas d’erreurs, pensez à vérifier le fichier de configuration issu de la compilation (« bin\Debug\CoucheServices.Tests.dll.config »).

Configuration pour Jenkins et Sonar

Pour ces deux outils, on admettra bien sûr qu’ils sont déjà en place et bien configurés pour le reste du projet. A noter tout de même que NUnit doit être également installé sur le serveur hébergeant Jenkins (on doit avoir accès au programme « nunit-console.exe »).

Il y a trois choses à respecter :

  • La configuration du fichier .nunit ;
  • Une commande pour compiler le projet sous Jenkins;
  • Une commande pour l’appel des tests sous Jenkins.

Il faut donc tout d’abord ajouter un fichier .nunit à la racine du projet de test. Par exemple : CoucheServices.Tests.nunit.

Voici un exemple de son contenu (en mode Debug) :

<NUnitProject>
 <Settings activeconfig="Debug" processModel="Default"
  domainUsage="Default" appbase="" />
 <Config name="Debug" binpathtype="Auto"
  configfile="CoucheServices.Tests.dll.config" appbase="bin\Debug">
   <assembly path="CoucheServices.Tests.dll" />
 </Config>
 <Config name="Release" binpathtype="Auto" />
</NUnitProject>

Veillez à bien vérifier les valeurs des attributs « configfile » et « appbase ». On indique ici que le fichier de configuration à lire est celui situé dans le répertoire « bin\Debug ».

Pensez également à bien livrer ce fichier .nunit sur votre système de gestion de version.

On peut également générer le fichier .nunit via l’interface graphique de NUnit (« Project », « Edit », « File », « Save as... »), mais on perd ici facilement le fil de « qu’est-ce qui fait appel à quoi ». Donc à manipuler avec précaution.

Enfin, sous Jenkins, il faut ajouter une étape pour compiler le projet de test (« Build a Visual Studio project or solution using MSBuild »). Par exemple :

  • MSBuild Version : MSBuild 4.0
  • MSBuild Build File : CoucheServices.Tests\CoucheServices.Tests.csproj
  • Command Line Arguments : /property:Configuration=Debug /t:clean /t:build

Puis ajouter une étape de type batch (« Exécuter une ligne de commande batch Windows »), avec la commande suivante, composée du chemin d’accès aux exécutables de NUnit, du chemin relatif du fichier .nunit, et de l’emplacement d’un XML contenant les résultats des tests :

"C:\Program Files\NUnit 2.6.1\bin\nunit-console.exe" CoucheServices.Tests\CoucheServices.Tests.nunit /xml=nunit-result.xml

Encore une fois, n’oubliez pas que c’est le fichier « bin\Debug\CoucheServices.Tests.dll.config » qui sera utilisé. La chaîne de connexion indiquée dans ce fichier doit pointer vers un serveur de base de données accessible depuis le serveur hébergeant Jenkins.

Pour Sonar, il n’y a rien de spécial à ajouter. Pensez bien à compiler le projet de test, comme pour l’exécution des tests, dans le cas où l’analyse Sonar et l’exécution des tests seraient dans un job séparé.

A noter que Sonar reconnait normalement le projet comme projet de test. Les logs indiquent en effet : The project 'CoucheServices.Tests' has been qualified as a test project.

Liens

Créer un projet NUnit : http://blog.quentinpauzat.fr/tutoriels/nunit-et-sa-mise-en-place/

NUnit : http://www.nunit.org/

Jenkins : http://jenkins-ci.org//

Sonar : http://www.sonarsource.org/

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.