Accéder au contenu principal

Les Tests d'Acceptation sous Fitnesse


Introduction

Fitnesse est un outil de test d’acceptation automatisé pour réparer les problèmes liés aux processus d’exigences très tôt. Les tests d’acceptation automatisés de Fitnesse présentent plusieurs avantages tels que :
  • Avoir un retour très tôt sur chaque item du projet.
  • Avoir un retour très fréquent sur chaque item du projet.
  • Ces tests sont déterministes dans la mesure où ils sont soient verts soient rouges.
  • Permettent d’emprunter de plus en plus de chemins par rapport à la logique métier.
A l’inverse des tests unitaires tels que jUnit ou autres, les tests d’acceptation sous Fitnesse permettent de tester le métier et se concentrent beaucoup plus pour découler sur le bon code (the right code), le code ayant le plus de valeur métier.

Atelier

Dans cet atelier, nous allons mettre en pratique un projet de test d’acceptation sous Fitnesse. Pour ce faire, nous allons utiliser l’IDE Eclipse avec Maven. Nous commençons par créer un projet Maven sous Eclipse. Au niveau du fichier pom.xml, nous allons ajouter la dépendance de l’outil Fitnesse. Une classe mathématique classique va être créée et va faire ensuite l’objet du test. La classe se compose de deux attributs “numerateur” et “denominateur”, et d’une méthode “quotient” qui retourne la division du numérateur sur le dénominateur. La méthode “quotient “ fera l’objet de notre test. Ci après nous décrivons les étapes nécessaires pour créer un test d’acceptation sous le contrôle de Fitnesse.

Sous Eclipse

On crée le projet Maven appelé “Fitnesse” sous Eclipse. Après on ouvre le fichier “pom.xml” et on y insère le code suivant.
pom.xml :
<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>org.nafil</groupId>
   <artifactId>Fitness</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>Fitness</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>   
      <dependency>
          <groupId>org.fitnesse</groupId>
          <artifactId>fitnesse</artifactId>
          <version>20161106</version>
      </dependency>
   </dependencies>
</project>

Après on crée la classe Division dans le paquet org.cours.fitnesse comme suit :
Classe Division :
package org.cours.fitnesse;
public class Division {
   private double numerateur, denominateur;  
     public void setNumerateur(double numerateur) {
       this.numerateur = numerateur;
     }
     public void setDenominateur(double denominateur) {
       this.denominateur = denominateur;
     }      
     public double quotient() {
       return numerateur/denominateur;
     }
}

Configuration

Sous Eclipse, nous créons une nouvelle configuration appelée “Fitnesse” qui va nous permettre d’exécuter notre projet sous Fitnesse et dans laquelle nous allons redéfinir en cas de besoin le nouveau port d’exécution de Fitnesse.


Exécution
Sous Eclipse, nous allons lancer l’exécution de la nouvelle configuration “Fitnesse”. Si tout marche bien, le serveur démarre sur le port en question (par défaut c’est le port 80). Nous allons ensuite ouvrir le navigateur sur l’adresse http://localhost:80.
Nous allons à ce niveau là créer notre page de test en appuyant sur le menu Edit en haut de page. La page suivante s’affiche.


En haut de page, inscrivez le nom de votre page de test, on va saisir par exemple “TestDivision” et après vous cliquez sur le bouton “Save” en bas de page. La fenêtre va ressembler après à ça.


Le nom de la page qu’on vient de créer s’ajout en haut de page avec un point d’interrogation (?) à la fin du nom. Nous cliquons sur le point d’interrogation pour configurer notre test. Nous allons importer le path de la target du projet ainsi que le package contenant la classe à tester, en plus de la classe de test qui est dans ce cas “Division”. Le tout doit être disposé comme suit.


Au niveau de cet éditeur nous allons créer la classe de test qui va ressembler à cette écriture:
TestDivision :
!contents -R2 -g -p -f -h
!define TEST_SYSTEM {slim}
!path /Users/khalidnafil/eclipse-workspace/Fitness/target/classes
!|Import|
|org.nafil.Fitness|
!|DivisionLook           |
|numerateur|denominateur|quotient?|
|16         |2         |8.0       |
|12         |4         |3.0       |


Après nous allons appuyer sur le bouton “save”. La fenêtre suivante va apparaître.


Dans cette page on voit le nom de la classe, des deux attributs “numerateur” et “denominateur” ainsi que la méthode à tester “quotient” suivie du point ?. Juste en bas, apparaissent les deux lignes d’entrée pour ces deux attributs ainsi que le résultat attendu au niveau du quotient. En haut de cette page, on observe le bouton “Test”. C’est sur ce bouton que l’on va appuyer pour déclencher le test d’acceptation sous Fitnesse. C’est ainsi que la fenêtre suivante s’ouvrira.













 Sur cette page, nous voyons que pour ce test les messages sont en vert ce qui veut dire que le test est passé avec succès comme attendu.
Maintenant que le test marche et que Fitnesse est opérationnel vous pouvez revenir sur le site http://fitnesse.org/FitNesse.UserGuide pour de plus amples détails et descriptions sur les différentes autres fonctionnalités de cet outil pertinent.

  

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…