Les tests unitaires
Définition
Les tests unitaires sont des tests programmés, qui vérifient le fonctionnement correct d'une classe.
Ce sont des tests de bas niveau. On ne teste pas ici des fonctionnalités, On ne teste pas des cas
d'utilisation, on teste une par une les méthodes importantes d'une classe.
Utilité
L'avantage majeur des tests unitaires est qu'ils sont automatisables, et que leur exécution régulière
garanti la qualité des méthodes testées.
On dit qu'ils sont automatisables, parce qu'ils sont lancés par un programme autonome, différent de
celui que le programmeur conçoit. Lors de l’exécution des tests unitaires, l'utilisateur n'interagit pas.
Le programme qui lance les tests peut générer des rapports, à destination des développeurs ou du
chef de projet, pour que ces derniers puissent suivre l'évolution de la qualité du code.
Quand les développer?
On les développe le plus tôt possible pendant le développement des applications. Dans certaines
philosophies de développement, comme Agile, Extreme Programming, Test Driven Developpement,
on préconise même que les tests soient conçus avant l'application.
C'est aussi très utile d'en développer quand un bug apparaît. Voici un scénario qui se produit
souvent chez les éditeurs de logiciels :
• Un utilisateur trouve un bug, et appelle le support technique
• Le support technique vérifie que l'utilisateur ne dit pas n'importe quoi
• Le bug est répertorié dans un outil de suivi
• Le développeur est prévenu
• Le développeur écrit immédiatement un test unitaire qui échoue en reproduisant le bug
• Le développeur répare son code
• Le développeur relance le test unitaire qu'il a codé pour ce bug, cette fois il réussit
• Le test unitaire est précieusement ajouté a la suite de tests unitaires qui accompagne le code,
et sera lancé automatiquement avec tous les autres lors de chaque test complet.
L'objectif d'accumuler des tests lors du développement et de l'apparition de bugs et de garantir la
non régression du logiciel.
Pendant le cycle de développement d'une application, si un utilisateur, ou n'importe qui d'autre
trouve un bug, il est courant qu'après avoir été prévenu, le développeur rédige immédiatement un
test unitaire qui échoue, en reproduisant le bug.
Réaliser des tests unitaires sous Android était autrefois une tâche délicate, aujourd’hui le travail à
été grandement simplifié. Lorsque vous créez un projet, un projet symétrique de tests est créé
Vous développez les classes de votre application principale dans le projet principal et vous réalisez
le test dans le projet de test
Structure d'un test Junit
Junit est une bibliothèque java qui facilite la rédaction de tests unitaires. Elle est intégrée a
AndroidStudio, InteeliJ, NetBeans et Eclipse. Nous allons voir comment créer des tests unitaires
pour une classe donnée, au travers d'un exemple.
On considère une classe Rectangle avec les méthodes surface() et estCarre(). Voici son code
public class Rectangle {
private double c1;
private double c2;
public Rectangle(double cote1,double cote2){
c1=cote1;
c2=cote2;
}
/**
* @return la surface du rectangle
*/
public double surface(){
return c1*c2;
}
/**
* @return vrai si le rectangle est carre, faux sinon
*/
public boolean estCarre(){
return (c1==c2);
}
}
On veut tester cette classe (celle ci est très simple, c'est pour l'exemple). Pour ce faire, dans le projet
de test, on va créer une classe RectangleTest, qui servira a tester Rectangle (l'usage veut qu'on
utilise le même nom en ajoutant Test pour la fin).
Pour chaque méthode qu'on veut tester, on créera une méthode dans notre classe de test. Par
exemple, pour tester la méthode surface, on créera une méthode testSurface.
public class RectangleTest {
public RectangleTest() {
}
/**
* Test of surface method, of class Rectangle.
*/
@Test
public void testSurface() {
//code a rédiger
}
/**
* Test of estCarre method, of class Rectangle.
*/
@Test
public void testEstCarre() {
//code a rédiger
}
}
Quand vous aurez codé le contenu des méthodes, l'ide, couplée au framework de test Junit, vous
permettront ensuite facilement de lancer vos tests unitaires automatiquement et d'observer leur
résultats.
Comment écrire le code d'une méthode de test ?
Pour coder une méthode de test, voici une démarche générale :
• créer une instance de la classe a tester
• créer le jeu de données nécessaire à l'appel de la méthode à tester, si elle a des paramètres
• prévoir le résultat de la méthode a tester
• appeler la méthode a tester
• comparer le résultat réel avec le résultat escompté, et utiliser les méthodes du framework
Junit pour faire échouer ou réussir le test.
On peut tout à fait tester plusieurs appels avec des valeurs et des instances différentes dans la même
méthode de test, c'est même vivement conseillé.
Voici une façon d'écrire la méthode testSurface()
public void testSurface() {
//on cree l'instance de rectangle a tester
Rectangle r=new Rectangle(4,8);
//on prévoit un resultat
double airePrevue=32;
//on appelle la vraie méthode
double aireRetournee=[Link]();
//on s'assure que le resultat est conforme
//assertTrue fera echouer le test si airePrevue != aireRetournee
assertTrue(airePrevue == aireRetournee);
}
Faire réussir ou échouer un test
Les tests réussissent par défaut, pour les faire échouer, on utilise des méthodes du framework
comme assertTrue. On en donne d'autres a la fin de ce cours.
ON PEUT, DANS LA VRAIE VIE, VOIR DOIT, FAIRE PLUSIEURS ASSERTIONS PAR
TEST
Une fois le code des tests écrit, il n'y a plus qu'à les lancer. Sous Android Studio, on peut lancer tous
les tests en faisant run → test project ou alt + f6. On obtient :
Méthodes utiles du framework de test d’android studio
fail() Fait échouer un test. Peut s'utiliser dans un if par
exemple.
assertTrue(bool expBooleene) Échoue si l'expression est fausse
assertFalse(bool expBooleene) Échoue si l'expression est vraie
assertTrue(String msg, bool expBooleene) Échoue si l'expression est fausse Ces 2 versions permettent
assertFalse(String msg, bool expBooleene) Échoue si l'expression est vraie de décrire ce qui est
testé
