Intégrer les test unitaires à un projet Xamarin

wamarin-nunit

Les tests unitaires sont souvent délaissés dans les applications, mais font pourtant partis des briques les plus importantes à mettre en place.
Le temps passé à les mettre en place sera gagné par la suite par les bugs qu’il n’y aura pas besoin de corriger.

Pour les projets .NET, il existe 2 solutions de tests automatisés :

  • Utiliser MS Test (solution Microsoft)
  • Utiliser le framework de test unitaires Nunit ou Touch.Unit, la version plus allégée du premier.

Nous allons ici présenter l’utilisation de NUnit.

Nunit ?

Nunit est un framework de tests unitaires pour le langage .Net.

Le projet a été initialement porté depuis la JUnit, mais propose aujourd’hui sa version 3.0 qui a été entièrement réécrite pour y ajouter de nouvelles fonctionnalités.

Installation

Pour commencer, créer un nouveau projet dans votre solution “<project>.Tests” (avec <project> le nom de votre projet).

Il est également possible de créer les tests directement dans votre projet existant, mais ça sera plus propre de les concentrer à un seul endroit.

Pour ma part, j’ai créé un projet de type “Unit Test Project” qui est en fait un projet “MS Test” mais une fois la référence au framework MS Test c’est un projet simple qui à l’avantage d’avoir un icône remarquable facilement.

nunit-create-project

Dans ce nouveau projet, il est nécessaire d’installer ensuite le package “NUnit 3” et “NUnit3TestAdapter”.

Pour cela ouvrir “Le gestionnaire de package NuGet” (clic droit projet / Manage NuGet packages), puis rechercher “NUnit” et “NUnit test adapter”.

nunit-nuget

NUnit test adapter permet d’inclure NUnit à Visual Studio sans avoir à installer de package VSIX Adapter et pouvoir ainsi executer les tests depuis l’interface Visual Studio.

Note : L’installation nécessite ensuite un redémarrage de Visual Studio.

Mise en place

On se retrouve donc avec un projet Xamarin et un projet “Tests Unitaires” qui peut ressembler à l’organisation suivante :

Project Solution
...Project (Portable ou Shared, contient le code partagé)
...Project.iOS
...Project.Droid
...Project.WinPhone (Windows Phone 8.1)
...Project.Tests (Contient les tests unitaires)

Pour un bon découpage de l’application, le code à tester devrait se trouver uniquement dans le projet “Project” contenant le code partagé.
Les autres projets contenant normalement uniquement le code d’interface propre à chaque plateforme.
Pour tester le code des interfaces, il existe des tests d’UI, mais qui sont différents des tests unitaires traités dans cet article.

Il est ensuite nécessaire d’indiquer au projet de Test les projets contenant les classes testées.
Pour cela, ajouter une référence au projet “Project.Tests” du projet “Project”.

Les conventions de nommage des tests indiquent le plus souvent les règles suivantes à respecter :

  • La classe de test doit se nommer de la même façon que la classe testée suffixée de “Test”
    • Exemple : La classe de tests de “Calculator.cs” doit s’appeler “CalculatorTest.cs”
  • La hiérarchie du projet testé doit se retrouver dans le projet de tests

Rédaction des tests

Prenons l’exemple d’une classe “Calculette” contenue dans le projet “Project” permettant d’effectuer des additions et multiplications :

namespace Calculator
{
    public class Calculette
    {
        public int Addition(int num1, int num2)
        {
            int resultat = num1 + num2;
            return resultat;
        }

        public int Multiplication(int num1, int num2)
        {
            int resultat = num1 + num2;
            return resultat;
        }
    }
}

Afin de tester cette classe, créons un fichier “CalculetteTest” dans le projet “Project.Tests” :

namespace Calculator.Tests
{
    [TestFixture]
    public class CalculetteTest
    {
        #region Init

        private Calculette calculette = new Calculette();

        #endregion

        #region Tests

        [Test]
        public void TestAddition()
        {
            int resultat = calculette.Addition(7, 8);
            Assert.That(resultat, Is.EqualTo(15));
        }

        [Test]
        public void TestMultiplication()
        {
            int resultat = calculette.Multiplication(7, 8);
            Assert.That(resultat, Is.EqualTo(56));
        }

        #endregion
    }
}

Pour les tests, il est nécessaire d’utiliser les tags clés suivants :

  • L’attribut TestFixture pour créer la classe de test
  • L’attribut Test pour créer la méthode de test

Et c’est là qu’intervient “NUnit Test adapter”.
Cet outils va permettre à Visual Studio de trouver tous les tests unitaires qui ont été créés dans la solution.

Pour ouvrir la liste de test, ouvrir le Menu “Test > Windows > test Explorer” :

vs-test-explorer

Les tests ne vont pas apparaître tout de suite, il est d’abord nécessaire de builder la solution.
Une fois que c’est fait, les tests unitaires vont apparaître, il suffira alors de cliquer sur “Run All” pour tous les exécuter :

vs-test-explorer-result

Et là…si vous aviez bien suivi l’article vous auriez remarqué que dans la méthode de multiplication on a effectué une addition “+” à la place d’une multiplication “*”, c’est donc normal que le test soit en échec pour cette méthode.

Vous avez ici vos premiers tests unitaires !

Ressources supplémentaires

La documentation de NUnit est très complète et facilement lisible, je vous conseille d’aller y jeter un œil pour y trouver les informations qu’il vous manque :

Documentation NUnit : https://github.com/nunit/docs/wiki/NUnit-Documentation

Comment rédiger ses tests : https://github.com/nunit/docs/wiki/Attributes

Et si vous trouvez l’écriture des tests difficile et pas très compréhensibles, une solution existe : fluent assertions.
Cette librairie permet de créer des tests d’assertion plus lisibles et plus facile à débugguer.

Laisser un commentaire

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

Prouve moi que tu es bien humain ->