L'intégration continue avec CruiseControl.NET

Créez un sous-répertoire nommé C:\ArticleCC\Sources\EasyCalcLib

Placez dans ce répertoire, un fichier Calc.cs qui contient le code suivant :

using System;

namespace EasyCalcLib
{
        public class Calc
        {
                string[] args;

                public Calc(string[] args)
                {
                         this.args = args;
                }

                public double Calculer()
                {
                        if(args == null || args.Length != 3)
                                throw new Exception("Le nombre d'arguments est invalide");

                        try
                        {
                                double resultat;
                                switch(args[2])
                                {
                                        case "+":
                                                resultat = addition(Int32.Parse(args[0]),Int32.Parse(args[1]));
                                                break;
                                        case "-":
                                                resultat = soustraction(Int32.Parse(args[0]),Int32.Parse(args[1]));
                                                break;
                                        case "*":
                                                resultat = multiplication(Int32.Parse(args[0]),Int32.Parse(args[1]));
                                                break;
                                        case "/":
                                                resultat = division(Int32.Parse(args[0]),Int32.Parse(args[1]));
                                                break;
                                        default:
                                                throw new Exception("Opérateur inconnu");
                                }
                                return resultat;
                        }
                        catch(Exception ex)
                        {
                                throw new Exception("Erreur pendant le calcul : " + ex.Message);
                        }
                }

                private int addition(int nb1,int nb2)
                {
                        return nb1 + nb2;
                }

                private int soustraction(int nb1,int nb2)
                {
                        return nb1 - nb2;
                }

                private int multiplication(int nb1,int nb2)
                {
                        return nb1 * nb2;
                }

                private double division(int nb1,int nb2)
                {
                        return Math.Round((double)nb1 / nb2,2); // arrondis à 2 décimales
                }
        }
}

Créez un sous-répertoire nommé C:\ArticleCC\Sources\EasyCalc

Placez dans ce répertoire, un fichier MainClass.cs qui contient le code suivant :

using System;
using EasyCalcLib;

namespace EasyCalc
{
        class MainClass
        {
                [STAThread]
                static void Main(string[] args)
                {
                        Calc calc = new Calc(args);
                        Console.WriteLine(
                                String.Format("Le résultat de l'opération est : {0}",
                                calc.Calculer())
                        );

                        Console.ReadLine();
                }
        }
}

Il s'agit de la librairie de tests unitaires. Elle utilise les classes du framework NUnit qui est inclus dans l'installation de NAnt. Il est donc inutile de l'installer sauf si vous désirez profiter des différents outils fournis avec l'installateur de Nunit.

Pour en savoir plus sur NUnit, vous pouvez consulter l'article suivant :

Les tests unitaires avec NUnit : https://jab.developpez.com/tutoriels/dotnet/nunit/

Les tests unitaires font partie intégrante des systèmes d'intégration continue, car ils permettent de valider la bonne qualité d'une application, si vous ne connaissez pas ces principes, mieux vaut consulter l'article cité avant de continuer.

Créez un sous-répertoire nommé C:\ArticleCC\Sources\TestCalc

Placez dans ce répertoire, un fichier TestClass.cs qui contient le code suivant :

using System;
using NUnit.Framework;
using EasyCalcLib;

namespace TestCalc
{
        [TestFixture]
        public class TestClass
        {
                [Test]
                public void Addition()
                {
                        Calc calc = new Calc(new string[] {"3","5","+"});
                        Assert.AreEqual(8,calc.Calculer());
                }

                [Test]
                public void Soustraction()
                {
                        Calc calc = new Calc(new string[] {"4","1","-"});
                        Assert.AreEqual(3,calc.Calculer());
                }

                [Test]
                public void Multiplication()
                {
                        Calc calc = new Calc(new string[] {"3","3","*"});
                        Assert.AreEqual(9,calc.Calculer());
                }

                [Test]
                public void DivisionEntiere()
                {
                        Calc calc = new Calc(new string[] {"12","3","/"});
                        Assert.AreEqual(4,calc.Calculer());
                }

                [Test]
                public void Division2Decimales()
                {
                        Calc calc = new Calc(new string[] {"9","8","/"});
                        Assert.AreEqual(1.12,calc.Calculer());
                }

                [Test]
                public void DivisionParZero()
                {
                        Calc calc = new Calc(new string[] {"4","0","/"});
                        Assert.AreEqual(Double.PositiveInfinity,calc.Calculer());
                }
        }
}

Les tests définis ici passent tous avec succès si les sources données précédemment sont respectées. Nous le vérifierons dans la suite de l'article.

• workingDir : le répertoire principal contenant tous les fichiers de notre projet.
• sourcesDir : le répertoire contenant les sources de EasyCalc.
• outputDir : le répertoire qui contiendra les nouveaux fichiers binaires (il sera unique pour chaque compilation et permettra d'historiser les données).
• testsResultDir : le répertoire qui recevra le log Nunit.

La compilation (« build »)

Trois compilations pour trois projets sont effectuées :

• EasyCalcLib dont dépendent les deux autres projets ;
• EasyCalc, l'application console ;
• La dll de tests, TestCalc.dll qui dépend du framework NUnit. Ici la référence est faite vers le NUnit inclus dans Nant.

Les tests unitaires (« tests »)

La tâche <nunit2> est appelée en spécifiant d'écrire un fichier de log des tests au format xml. Ainsi CruiseControl pourra le récupérer et afficher les informations. On veille aussi bien à spécifier la dll contenant la série de tests.

Cette task est dépendante de « build » et ne se fera pas si cette dernière échoue.

CruiseControl.NET contient trois éléments principaux :

• le serveur qui est le centre du système et qui se charge de gérer l'ensemble du processus d'intégration continue ;
• le webdashboard, une interface web permettant de consulter les différents projets répartis sur un ou plusieurs serveurs. Dans notre cas, nous aurons un projet branché sur un serveur ;
• le cctray, un outil de monitoring symbolisé par une petite icône dans la traybar indiquant le statut du ou des projets en cours (rouge, jaune ou vert pour signifier : échec, compilation en cours ou succès).

Téléchargez l'installateur principal sur le site du projet (version 1.0 RC2 au moment d'écrire cet article) : http://ccnet.thoughtworks.com/.

Vérifiez que IIS est installé sur votre machine avec le support d'ASP.NET.

Installez CruiseControl.NET en décochant la possibilité de lancer le serveur en tant que service (ce n'est pas utile dans le cadre de cet article). Le répertoire d'installation devrait être C:\Program Files\CruiseControl.NET.

Vérifiez que vous avez accès au DashBoard en tapant dans votre navigateur : http://127.0.0.1/ccnet

Si tout va bien, vous devriez voir apparaître cette interface :

Le message d'erreur est normal puisque nous n'avons pas encore démarré le serveur.

Téléchargez le projet CCTray qui est indépendant du projet principal et installez-le.

Ouvrez le fichier C:\Program Files\CruiseControl.NET\server\ccnet.config

Ce fichier contient la définition des projets CruiseControl et la quasi-totalité de la configuration du serveur. Le site de l'éditeur détaille sa structure et ses possibilités, n'hésitez pas à le consulter.

Nous allons créer un nœud <project/> pour y définir notre projet EasyCalc.

Copiez dans ccnet.config, le xml suivant :

<cruisecontrol>
  <project>
   <name>EasyCalc</name> 
    <webURL>http://localhost/ccnet-dashboard/ ?_action_ViewProjectReport=true&amp;server=local&amp;project=EasyCalc</webURL> 
    <triggers>
        <intervalTrigger seconds="60"/>
    </triggers>
    <workingDirectory>.</workingDirectory>
    <modificationDelaySeconds>2</modificationDelaySeconds>
    <sourcecontrol type="filesystem">
      <repositoryRoot>C:\ArticleCC\Sources</repositoryRoot>
    </sourcecontrol>
    <tasks>
        <nant>
            <executable>C:\Program Files\nant\bin\nant.exe</executable>
            <buildFile>C:\ArticleCC\Sources\EasyCalc.build</buildFile>
            <targetList>
                <target>test</target>
            </targetList>
        </nant>
    </tasks>
    <publishers>
        <merge>
                <files>
                        <file>C:\ArticleCC\Binaries\*-results.xml</file>
                </files>
        </merge>
        <xmllogger />
    </publishers>
  </project>
</cruisecontrol>

Les actions effectuées sont les suivantes :

• <triggers/> permet ici de définir un intervalle entre chaque vérification des sources, 60 secondes dans notre cas ;
• <sourcecontrol/> permet de choisir le système de contrôle des modifications (souvent CVS, VSS, ClearCase…). Ici nous nous baserons uniquement sur une lecture du système de fichier grâce aux dates des fichiers. Le répertoire à monitorer est défini dans <repositoryRoot/> ;
• <tasks> décrit les tâches à effectuer quand une modification est détectée. Il s'agit, dans notre exemple, de lancer la tâche « test » du script NAnt qui se chargera ensuite de lancer la compilation et les tests.
• <publishers/> permet de récupérer les logs générés (seul NUnit ici) et ensuite d'appeler le qui créera le log CruiseControl de l'intégration courante.

Ce log sera placé ensuite dans ce répertoire : C:\Program Files\CruiseControl.NET\server\EasyCalc\Artifacts\buildlogs.

Ce répertoire n'existe pas jusqu'à la première intégration effectuée. L'ensemble de ces fichiers de logs seront parsés et mis en page grâce à des feuilles xsl se trouvant dans C:\Program Files\CruiseControl.NET\webdashboard\xsl

Démarrez-le CCTray précédemment installé, il apparaît gris dans la barre des tâches. En effet, aucun serveur n'y est configuré.

Faites un clic droit dessus puis « Settings ».

Dans la partie « BuildServer », cliquez sur « Add » et ajoutez le serveur « 127.0.0.1 » et son projet « EasyCalc ».

Exécutez C:\Program Files\CruiseControl.NET\server\ccnet.exe

Si tout se passe bien, quatre nouveaux fichiers devraient être détectés et une intégration démarrée.

Cette information permet de comprendre que toute la compilation et les tests se sont bien passés.

Si au moins un test échoue, le cctray apparaît en rouge (pour l'éviter, il faudrait modifier le script NAnt avec un failonerror à false pour les tests nunit, nous ne le testerons pas ici).

Pour essayer cela, provoquons un échec du test unitaire « Division2Decimal » :

Dans le fichier C:\ArticleCC\Sources\EasyCalcLib\Calc.cs, modifiez la ligne :

return Math.Round((double)nb1 / nb2,2); // arrondis à 2 décimales

Par :

return Math.Round((double)nb1 / nb2,3); // arrondis à 3 décimales

Enregistrez le fichier. Au bout de quelque temps (60 secondes maximum), le serveur CruiseControl va détecter la modification et lancer l'intégration. À la fin, l'intégration apparaîtra en échec.

Pour analyser, la raison de l'échec précédent, ouvrons-le Dashboard : http://127.0.0.1/ccnet.

Cliquez sur EasyCalc puis sur le dernier résultat en échec dans le menu de gauche. Un écran ressemblant à ceci devrait apparaître :

À gauche, apparaît la liste des derniers builds effectués ainsi qu'un menu permettant d'atteindre les différents sous-rapports.

Au centre, nous trouvons des informations concernant l'intégration. On trouve le nom des fichiers modifiés ainsi que la raison de l'échec : « Tests failed » suivis du détail du test échoué (le test Division2Decimales).

Pour plus d'informations concernant les tests et le log du script NAnt, vous pouvez consulter les parties concernant NAnt et NUnit sur le menu de gauche.