exoa labs

La plus part du temps les développeurs pour tester un code vont utiliser des traces temporaires dans l'application pour espérer que le code retourne bien la bonne valeur ou effectue le bon comportement. Sachant que c'est lui qui effectue le test de manière manuelle :
> je clic un peu par la,(clic) voila pour voir ce qui se passe… ouf! j'ai eu chaud, ca marche!.

Les developpeurs sont très motivés en début de projet et ils en mettent partout, mais quand la date de livraison approche ces tests diminuent voir même disparaissent pour faire vite… au profit de bien faire.

Le gros inconvenant concernant l'utilisation des traces temporaires sont leurs limites d'utilisation, et ne peuvent empêcher une régression.

Il existe une solution que nous propose l'extreme Programming sous la forme de tests unitaires ou tests de regression.

Cette pratique ou cette philosophie de travail consiste à écrire un test avant même d'écrire le code qui pourra le passer. Cela permet surtout au développeur de travailler par étape parce que je sais très bien que ce dernier aime se lancer corps et âme dans le code en voulant faire tout en même temps.

Cette pratique va l'obliger a découper son travail et ainsi procéder par étape.

Pour résumer, les tests unitaires apportent un feedback beaucoup plus rapidement que l'utilisation des traces temporaires et permet une division du travail à effectuer.

Un point qui m'est important et qui doit l'être pour vous aussi si les tests unitaires vous intéressent : faites le code le plus simple qui soit. Les optimisations se feront après.

Alors attention, la mise en pratique des tests unitaires n'est pas chose facile, puisque la première chose à apprendre c'est l'utilisation d'un framework de tests mais surtout à rendre son code testable.

Nous allons voir à travers l'utilisation du framework ACTUce la mise en place de tests unitaires.

Les tests unitaires sont organisés dans des classes de tests et une classe de test par classe à tester. ASTUce tourne autour de trois classes qui ont pour rôle :

* MiniRunner : le lanceur de tests.
* TestCase : la classe de test qui implémente l'interface ITest
* TestSuite: qui gère une collection de classes de tests (Design pattern Composite) :

Un exemple de test unitaire

Prenons l'exemple de la création d'un carnet d'adresses mais plus précisement l'ajout et le retrait d'un contact (Nom, Prenom, Email, Téléphone) existant du carnet.

- L'ajout d'un contact :

 
var carnet:Carnet = new Carnet();
var contact:Contact = new Contact("Dubreuil","Henry","h.dubreuil@free.fr","01.75.34.24.10");
carnet.addContact(contact);
 
assertEquals(1,carnet.count);
 

ici la classe Contact n'est qu'une structure d'informations, elle n'a pas de comportements, il n'est pas utile de la tester.

La stucture d'un test est toujours la même, déclaration des objets utiles aux tests et une liste d'assertions.

Le test unitaire nous permet implicitement d'obtenir l'interface de nos classes:

 
class AddressBook {
	function AddressBook() {
 
	}
 
	function addContact(c:Contact) {
		// Code ...
	}
}
 
class Contact {
	var last:String;
	var first:String;
	var email:String;
	var phone:String;
 
	function Contact(last:String, first:String, email:String, phone:String) {
		this.last = last;
		this.first = first;
		this.email = email;
		this.phone = phone;
	}
 
	function toString():String {
		return "Fiche contact: " + fisrt + " " + last + "\n" + phone + " <" + email + ">";
	}
}
 

Nous allons maintenant écrire une classe de test qui doit hériter de la classe TestCase :

 
import buRRRn.ACTUce.TestCase;
 
class TestAddressBook extends TestCase {
	function TestAddressBook(name:String) {
		super(name);
	}
 
	function testAddContact() {
		var carnet:Carnet = new Carnet();
		var contact:Contact = new Contact("Dubreuil","Henry","h.dubreuil@free.fr","01.75.34.24.10");
		carnet.addContact(contact);
 
		assertEquals(1,carnet.count);
	}
 
	function testInstancied() {
		var carnet:Carnet = new Carnet();
 
		assertNotNull(carnet);
	}
}
 

Le constructeur doit avoir un parametre de type String que nous passons au constructeur de la classe TestCase. Les tests sont implémentés dans la classe sous la forme de méthodes.

Tout à l'heure nous avons parlé d'une liste d'assertions, des méthodes nous permettant d'effectuer des tests, dans notre cas nous en avons utilisé une seule mais il en existe plusieurs, à savoir :

* assertTrue(condition:Boolean) : verifie si la condition est vraie.
* assertFalse(condition:Boolean) : l'opposé de assertTrue.
* assertNotNull(obj:Object) : verifie si l'objet existe.
* assertNull(obj:Object) : l'opposé de assertNotNull.
* fail(message:String) : permet d'échouer un test et d'afficher un message.

la liste n'est pas complète bien entendu…

A chaque méthode de test correspond à une instance de la classe test, voici un exemple faux mais utile pour comprendre le cycle de vie d'un test :

 
var test1:TestAddressBook = new TestAddressBook();
test1.testAddContact();
 
var test2:TestAddressBook = new TestAddressBook();
test2.testInstancied();
 

Nous sommes amenés dans les tests à vouloir initialiser des variables, objets etc… Il nous suffit pour cela de redéfinir deux méthodes, une qui initialise le test l'autre qui le nettoie : setUp et tearDown. Dans le cas de notre test nous devons instancier à chaque fois une classe Carnet, nous pouvons donc factoriser le tout dans la méthode d'initialisation setUp :

 
import buRRRn.ACTUce.TestCase;
 
class TestAddressBook extends TestCase {
	private var carnet:Carnet;
 
	function TestAddressBook(name:String) {
		super(name);
	}
 
	// Initialise le test
	function setUp() {
		carnet = new Carnet();
	}
 
	function testAddContact() {
		var contact:Contact = new Contact("Dubreuil","Henry","h.dubreuil@free.fr","01.75.34.24.10");
		carnet.addContact(contact);
 
		assertEquals(1,carnet.count);
	}
 
	function testInstancied() {
		assertNotNull(carnet);
	}
}
 

Maintenant que nous disposons d'un test, il suffit de le lancer mais pour cela nous allons créer une classe Application qui s'en chargera. Cette classe n'est qu'un point d'entrée pour lancer les tests dont voici la structure :

 
import buRRRn.ACTUce.TestSuite;
 
class Application {
	public static function suite():TestSuite {
		var suite:TestSuite = new TestSuite();
		suite.addTest( new TestSuite( TestAddressBook ) );
		return suite;
	}
 
	public static function main() {
		buRRRn.ACTUce.Application.run( suite() );
	}
}
 

Cette classe possède une méthode statique suite qui construit une TestSuite contenant les suites de toute les classes tests à executer. Cette suite de tests est passée au framework ACTUce pour les executer.

Pour conclure, les tests unitaires sont des outils puissant permettant une autre approche de la programmation en divisant le travail en petits problèmes qui peut être résolu par étapes. Le fait de poser le probleme avant de coder sa solution permet de mieux réfléchir sur sa résolution.

Ils ont surtout un avantage considérable sur le remaniement de votre application en évitant une régression de votre code si vous y apportez une modification. Les erreurs corrigés ne pourront plus se produire puisqu'elles seront validées par un test.

Les tests unitaires n'empêcheront pas les erreurs puisque nous sommes des êtres humains et non des machines mais ils vous permettront d'avoir des applications ayant très peu d'erreurs.

Pour utiliser ASTUce vous devez d'abord installer Core2 que vous pouvez télécharger ici sous la forme d'une extension pour Flash : Core2.mxp

Vous trouverez ici aussi un gabarit de projet flash incluant ASTUce : Template.zip

Pour en savoir plus sur Core2 voir : La librairie Core2.

Par ITERATIF - BUGALOTTO Olivier (2006)