Accéder au contenu principal

Les Tests unitaires avec TestNG

Introduction

TestNG est un framework de test unitaire qui s’est inspiré des frameworks de test unitaires Junit
et Nunit et qui a ajouté de nouvelles fonctionnalités par rapport à ces frameworks. TestNG devient  
de plus en plus populaire et gagne du terrain par rapport à ses concurrents. Dans cet atelier nous 
allons présenter la démarche nécessaire pour installer TestNG sur Eclipse et lancer par après un 
projet Maven simple pour l’initiation. Pour réaliser cet atelier, on aura besoin de l’IDE Eclipse.

Installation TestNG sur Eclipse

Pour installer TestNG sur Eclipse, on va utiliser le Marketplace. Pour ce faire, nous allons choisir
dans le menu “Help” de Eclipse le sous-menu “Eclipse Marketplace” et nous cherchons avec le 
mot “TestNG”, après on valide l’installation et on redémarre Eclipse pour que les changements 
puissent avoir lieu. Maintenant que TestNG est ajouté à Eclipse, nous pouvons dans ce cas 
démarrer des projets de test sous contrôle de cet outil. Pour l’exemple que nous allons présenter, 
nous créons un projet maven sous Eclipse comme détaillé dans la section suivante.

Projet TestNG

Nous commençons, sous Eclipse, par créer un nouveau projet Maven. Le fichier “pom.xml” se 
présentera comme suit :
<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>TestNG</groupId>
 <artifactId>knafil.testng</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>
 <name>knafil.testng</name>
 <url>http://maven.apache.org</url>
 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>
 <dependencies>
    <dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>3.8.1</version>
<scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.testng/testng -->
<dependency>
    <groupId>org.testng</groupId>
    <artifactId>testng</artifactId>
    <version>6.11</version>
    <scope>test</scope>
</dependency>
 </dependencies>
</project>
La dépendance de TestNG est à récupérer au niveau du site https://mvnrepository.com 
 

Maintenant que la dépendance est ajoutée au fichier pom et que le plugin de TestNG est installé 
sur Eclipse, on procède à la création de notre classe Java appelée “Calculette.java” ayant pour 
code :
package org.knafil.testng;
public class Calculette {
public double add(double n1, double n2) {
      double c;
      c= n1+n2;
      return c;
   }    
}
Cette classe “Calculette.java” contient une seule méthode “add” qui permet de retourner l’addition 
de deux nombres passés en paramètre. Ensuite, nous créons la classe de test de la classe 
“Calculette.java” appelée “CalculetteTest.java” de la manière suivante. Nous cliquons avec le 
bouton droit sur le nom de projet, nous choisissons “Autre ou Other”, dans wizard nous 
écrivons “TestNG” que l’on va sélectionner et on appuie sur “Next”.
 
















Après avoir appuyer sur “Next” la fenêtre suivante apparaît et nous propose de choisir les méthodes 
à tester, nous cochons alors la méthode “add” et on appuie sur “Finish”.

Le code de la classe “CalculetteTest.java” est comme suit :
package org.knafil.testng;
import org.testng.Assert;
import org.testng.annotations.Test;
public class CalculetteTest {
 @Test
 public void add() {
     Calculette calc = new Calculette();
    Assert.assertEquals(calc.add(12, 8), 20.0);
 }
}
Au niveau de la classe CalculetteTest, nous insérons l’annotation @Test juste avant la méthode
“add” à tester. Dans le code, nous instantions un objet “calc” de type Calculette et nous faisons 
appel à la méthode de test “Assert.assertEquals” qui permet de comparer si ses deux paramètres 
sont identiques. Ici nous passons en paramètre les deux nombres “doubles” 12 et 8, pour le 
deuxième paramètre nous passons le résultat attendu qui est le nombre double 20.0.
Le code étant créé, on fait bouton droit sur la classe de test “Caclcultte.java” et on choisit
“Run as > TestNG Test”
 
 
Après validation le résultat de test s’affiche comme suit :
 

Une fois le test passé avec succès, le message apparaît en vert avec le temps d’exécution du test.

Groupe de test sous TestNG

Des fois il semble être nécessaire de lancer un groupe de test choisi parmi plusieurs méthodes 
de la classe à tester, parce que sinon c’est toutes les méthodes qui vont être testées dans ce cas. 
Supposons que nous disposons maintenant de quatre méthodes au niveau de notre classe 
“Calculette.java” qui se présentent comme suit :
package org.knafil.testng;
public class Calculette {  
   public double add(double n1, double n2) {
      double c;
      c= n1+n2;
      return c;
}    
   public double soustraire(double n1, double n2) {
      double c;
      c = n1 - n2;
      return c;
   }
   public double produit(double n1, double n2) {
      double c;
      c= n1 * n2;
      return c;
   }
   public double diviser(double n1, double n2) {
      double c;
      c= n1 / n2;
      return c;
   }
}
Et que la classe de test “CalculetteTest.java”, après avoir annoté le groupe de test, se présente
comme suit :
package org.knafil.testng;
import org.testng.Assert;
import org.testng.annotations.Test;
public class CalculetteTest {
@Test(groups = { "test-group" })
 public void add() {
     Calculette calc = new Calculette();
    Assert.assertEquals(calc.add(12, 8),20.0);
 }
 @Test
 public void produit() {
     Calculette calc = new Calculette();
    Assert.assertEquals(calc.produit(12, 8),96.0);
 }
 @Test(groups = { "test-group" })
 public void soustraire() {
     Calculette calc = new Calculette();
    Assert.assertEquals(calc.soustraire(12, 8),4.0);
 }
  @Test
 public void division() {
     Calculette calc = new Calculette();
    Assert.assertEquals(calc.diviser(16, 8),2.0);
 }
}
Ici on a choisi à titre d’exemple de définir un seul groupe de test au niveau des deux méthodes 
“add” et “soustraire” appelé “test-group”.
Si on lance le test TestNG de manière normale alors c’est toutes les méthodes qui vont être 
testées, or nous voulons passer le test seulement pour les deux méthodes “add” et “soustraire”. 
Pour ce faire nous allons créer une nouvelle configuration sous Eclipse de la manière suivante. 
Tout d’abord, dans le menu “Run” de Eclipse, on choisit “Run Configurations…”. Nous sélectionnons 
“TestNG” à partir de la liste des configurations proposées.
 
 On appuie ensuite sur l’icône en haut à gauche pour créer une nouvelle configuration.  
Nous devons ici donner un nom au niveau du champ “Name”. Pour notre cas,  
on donne par exemple le nom “CalculetteTestGroup”. Dans le champ “Project”, on  
appuie sur le bouton “browse” et on choisit le nom de notre projet en cours qui est dans
 notre cas “knafil.testng”. Après, nous sélectionnons le bouton radio “Groups” et en 
appuyant sur le bouton “Browse” nous choisissons “test-group” et on valide.
 
Dans ce cas, le test s’exécute mais uniquement pour les deux méthodes annotées par le test de 
groupe.

Pour de plus amples détails, veuillez se référer au site officiel http://testng.org .

Posts les plus consultés de ce blog

Les cartes CRC pour l'analyse des classes UML

Les cartes CRC Un système Orienté Objet (OO), est un système constitué par un ensemble d'objets qui collaborent et communiquent par envoi de messages. Lorsqu'un objet envoie un message à un autre objet, c'est que en réalité il demande un service à cet objet, ce dernier doit rendre son service public et faire en sorte de l'offrir à ses collaborateurs. Plusieurs services sont définis et offerts par le système OO.
La collaboration s'avère alors comme un principe fondamental des systèmes OO. UML, étant un langage de modélisation des systèmes OO, offre un outil qui permet la modélisation de la Collaboration. Cet outil portant le nom de Collaboration est représenté pare une ellipse en pointillées.

Lors de l'Analyse d'un Système d'Information, il est important de relever toutes les entités "Classes" potentielles dans un premier temps. On peut dans ce cas utiliser une heuristique très simple qui consiste à identifier les noms communs (Classes) ou les…

Rédaction d'un document Cahier des Charges

Comment rédiger un Cahier des Charges Pour rédiger un document cahier des charges d'un projet logiciel ou autre, nous proposons cette template qui pourrait servir éventuellement comme guide. Il s'agit de définir successivement les points suivants : Contexte et définition du projet, Objectifs, Scope, Parties Prenantes, Description des besoins à répartir entre les besoins fonctionnels et non fonctionnels.
Contexte et définition du problème Dans cette rubrique, vous allez définir le problème pour bien clarifier la finalité du travail.
Il est important de souligner aussi les besoins ainsi que les contraintes et ce de manière
très sommaire. Par exemple, vous pouvez exposer la situation actuelle ou futur de votre
système tout en mettant l’accent sur les problèmes auxquels vous voulez faire face.
Objectifs Après avoir exposé le problème dans la première partie, ici vous allez exprimer quelles
sont les attentes et les résultats escomptés. Normalement ces attentes et résultats
(objectif…

Atelier JSF Facelets et Internationalisation I18n

Introduction
Dans cet atelier nous allons aborder deux thèmes importants du Framework JSF qui sont la technologie des Facelets et celle de l'Internationalisation connu par I18n (entre le caractère 'I' et le caractère 'n' on trouve 18 caractères). Il faut savoir que JSF au niveau de la version 1 utilisait JSP comme technologie de présentation, il se trouve que JSP et JSF ont deux cycles de vie différents, c'est pourquoi on a pensé à produire une nouvelle technologie de présentation qui soit totalement compatible avec JSF, il s'agit bien de la technologie des Facelets et ce depuis la version 2.0. L'internationalisation quant à elle s'avère être très importante aussi surtout lorsque l'objectif d'une application web est de prévoir plusieurs langues différentes pour la clientèle. L'idée est de ne pas produire une page par langue, mais plutôt traiter la chose de manière intelligente, c'est-à-dire le même contenu mais avec des affichages de…