Si vous êtes persuadés de l’intérêt des tests unitaires pour vos développements PHP mais que vous n’avez jamais osé franchir le pas, ce tutoriel est fait pour vous. Afin de migrer en douceur vers les préceptes sacrés de l’eXtreme Programming je vous propose un exemple concret de mise en place des tests unitaires sous l’environnement Zend Studio.

Pour ce faire, nous allons implémenter une bonne vieille pile LIFO en PHP.

Après avoir crée un projet avec Zend Studio et une classe Unit_Stack, on commence par écrire le squelette de cette classe :

/**
* A LIFO Stack
*/

class Unit_Stack
{
/**
* Push an item.
*
* @param mixed $item
*
* @return void
*/

public function push($item)
{}/**
* Pop an item.
*
* @return mixed
* @throws Exception if stack is empty.
*/

public function pop()
{}/**
* Count items of stack.
*
* @return int
*/

public function count()
{}/**
* Tells if stack is empty.
*
* @return boolean
*/

public function isEmpty()
{}

/**
* Removes all items of stack.
*
* @return void
*/

public function reset()
{}
}

Les commentaires devraient suffire à expliquer ce qu’est sensée faire cette classe.

L’étape suivante consiste à créer la classe de tests unitaires ou Test Case. Dans l’arborescence tests/unit/Unit/, faire click droit puis new -> PHPUnit Test Case.

Il suffit alors de choisir la classe à tester via le bouton Browse en face de ‘Element to Test’, puis de corriger le nom de la classe de Test générée dans le champ ‘Test File Name’ en virant le préfixe Unit_’. Cela devrait ressembler à ça :

Création d'un Test Case

Création d’un Test Case

Le Test Case généré devrait comprendre :

  • une méthode setUp : lancée avant chaque test.
  • une méthode tearDown : lancée après chaque test.
  • un constructeur : pas vraiment utile.
  • une méthode de test par méthode publique de la classe à tester.

Dans le cadre de cet exemple, je vous invite à supprimer le constructeur ainsi que les méthodes setUp et tearDown.

Nous rentrons maintenant dans le vif du sujet, il s’agit :

  1. d’écrire un test
  2. de lancer le Test Case afin de vérifier (oh surprise) qu’il échoue
  3. d’implémenter la fonctionnalité
  4. de relancer le test et éventuellement corriger jusqu’à ce que le test passe !

Écriture du test

Nous proposons pour la méthode isEmpty l’écriture du test suivant :

public function testIsEmpty ()
{
$stack = new Unit_Stack();// a new stack is empty !
$this->assertTrue($stack->isEmpty());
}

Lancer le Test Case

Il suffit d’un click droit sur le fichier du Test Case puis de choisir Run as -> PHPUnit Test

Si tout se passe bien, le test devrait apparaître en erreur et les autres en non implémentés.

 

Résultats test case

Implémenter la fonctionnalité

public function isEmpty()
{
return empty($this->_array);
}

Trop facile …

Relancer le test et corriger

Même procédure que le lancement précédent, cette fois le test devrait apparaître comme réussi.

Ensuite….

Il suffit de refaire la même procédure itérativement pour chaque fonctionnalité. A mesure que les nouvelles fonctionnalités sont implémentées, de nouveaux tests peuvent être écrits en plus de ceux générés par Zend Studio. Il suffit de créer une méthode publique dont le nom commence par test.

Si votre application contient plusieurs classes et donc plusieurs Test Case (ce qui est souvent le cas !), il peut être fastidieux de lancer les tests cases un par un, il est alors intéressant d’utiliser les Tests Suites. Il suffit de faire un click droit dans Zend studio sur le répertoire test/unit/ puis New -> PHPUnit Test Suite.

On sélectionne alors les Tests Case à lancer puis finish. Une Suite se lance alors de le même façon qu’un Test Case.

Liens :

  • Les sources de l’exemple
  • Le site de PhpUnit