344 lines
18 KiB
HTML
344 lines
18 KiB
HTML
|
<html>
|
||
|
|
<head>
|
||
|
|
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
|
||
|
|
<title>
|
||
|
|
Télécharger le framework de tests Simple Test - Tests unitaire et objets fantaisie pour PHP
|
||
|
|
</title>
|
||
|
|
<link rel="stylesheet" type="text/css" href="docs.css" title="Styles">
|
||
|
|
</head>
|
||
|
|
<body>
|
||
|
|
<div class="menu_back">
|
||
|
|
<div class="menu">
|
||
|
|
<h2>
|
||
|
|
<span class="chosen">SimpleTest</span>
|
||
|
|
</h2>
|
||
|
|
<ul>
|
||
|
|
<li>
|
||
|
|
<a href="overview.html">Overview</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="unit_test_documentation.html">Unit tester</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="group_test_documentation.html">Group tests</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="server_stubs_documentation.html">Server stubs</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="mock_objects_documentation.html">Mock objects</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="partial_mocks_documentation.html">Partial mocks</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="reporter_documentation.html">Reporting</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="expectation_documentation.html">Expectations</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="web_tester_documentation.html">Web tester</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="form_testing_documentation.html">Testing forms</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="authentication_documentation.html">Authentication</a>
|
||
|
|
</li>
|
||
|
|
<li>
|
||
|
|
<a href="browser_documentation.html">Scriptable browser</a>
|
||
|
|
</li>
|
||
|
|
</ul>
|
||
|
|
</div>
|
||
|
|
</div>
|
||
|
|
<h1>Simple Test pour PHP</h1>
|
||
|
|
<div class="content">
|
||
|
|
|
||
|
|
<p>
|
||
|
|
Le présent article présuppose que vous soyez familier avec le concept de tests unitaires ainsi que celui de développement web avec le langage PHP. Il s'agit d'un guide pour le nouvel et impatient utilisateur de <a href="https://sourceforge.net/project/showfiles.php?group_id=76550">SimpleTest</a>. Pour une documentation plus complète, particulièrement si vous découvrez les tests unitaires, consultez la <a href="http://www.lastcraft.com/unit_test_documentation.php">documentation en cours</a>, et pour des exemples de scénarios de test, consultez le <a href="http://www.lastcraft.com/first_test_tutorial.php">tutorial sur les tests unitaires</a>.
|
||
|
|
</p>
|
||
|
|
|
||
|
|
<p>
|
||
|
|
<a class="target" name="unit">
|
||
|
|
<h2>Utiliser le testeur rapidement</h2>
|
||
|
|
</a>
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Parmi les outils de test pour logiciel, le testeur unitaire est le plus proche du développeur. Dans un contexte de développement agile, le code de test se place juste à côté du code source étant donné que tous les deux sont écrits simultanément. Dans ce contexte, SimpleTest aspire à être une solution complète de test pour un développeur PHP et s'appelle "Simple" parce qu'elle devrait être simple à utiliser et à étendre. Ce nom n'était pas vraiment un bon choix. Non seulement cette solution inclut toutes les fonctions classiques qu'on est en droit d'attendre de la part des portages de <a href="http://www.junit.org/">JUnit</a> et des <a href="http://sourceforge.net/projects/phpunit/">PHPUnit</a>, mais elle inclut aussi les <a href="http://www.mockobjects.com/">objets fantaisie ou "mock objects"</a>. Sans compter quelques fonctionnalités de <a href="http://sourceforge.net/projects/jwebunit/">JWebUnit</a> : parmi celles-ci la navigation sur des pages web, les tests sur les cookies et l'envoi de formulaire.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
La démonstration la plus rapide : l'exemple
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Supposons que nous sommes en train de tester une simple classe de log dans un fichier : elle s'appelle <span class="new_code">Log</span> dans <em>classes/Log.php</em>. Commençons par créer un script de test, appelé <em>tests/log_test.php</em>. Son contenu est le suivant...
|
||
|
|
<pre>
|
||
|
|
<strong><?php
|
||
|
|
require_once('simpletest/unit_tester.php');
|
||
|
|
require_once('simpletest/reporter.php');
|
||
|
|
require_once('../classes/log.php');
|
||
|
|
?></strong>
|
||
|
|
</pre>
|
||
|
|
Ici le répertoire <em>simpletest</em> est soit dans le dossier courant, soit dans les dossiers pour fichiers inclus. Vous auriez à éditer ces arborescences suivant l'endroit où vous avez installé SimpleTest. Ensuite créons un scénario de test...
|
||
|
|
<pre>
|
||
|
|
<?php
|
||
|
|
require_once('simpletest/unit_tester.php');
|
||
|
|
require_once('simpletest/reporter.php');
|
||
|
|
require_once('../classes/log.php');
|
||
|
|
<strong>
|
||
|
|
class TestOfLogging extends UnitTestCase {
|
||
|
|
}</strong>
|
||
|
|
?>
|
||
|
|
</pre>
|
||
|
|
A présent il y a 5 lignes de code d'échafaudage et toujours pas de test. Cependant à partir de cet instant le retour sur investissement arrive très rapidement. Supposons que la classe <span class="new_code">Log</span> prenne le nom du fichier à écrire dans le constructeur et que nous ayons un répertoire temporaire dans lequel placer ce fichier...
|
||
|
|
<pre>
|
||
|
|
<?php
|
||
|
|
require_once('simpletest/unit_tester.php');
|
||
|
|
require_once('simpletest/reporter.php');
|
||
|
|
require_once('../classes/log.php');
|
||
|
|
|
||
|
|
class TestOfLogging extends UnitTestCase {
|
||
|
|
<strong>
|
||
|
|
function testCreatingNewFile() {
|
||
|
|
@unlink('/temp/test.log');
|
||
|
|
$log = new Log('/temp/test.log');
|
||
|
|
$this->assertFalse(file_exists('/temp/test.log'));
|
||
|
|
$log->message('Should write this to a file');
|
||
|
|
$this->assertTrue(file_exists('/temp/test.log'));
|
||
|
|
}</strong>
|
||
|
|
}
|
||
|
|
?>
|
||
|
|
</pre>
|
||
|
|
Au lancement du scénario de test, toutes les méthodes qui commencent avec la chaîne <span class="new_code">test</span> sont identifiées puis exécutées. D'ordinaire nous avons bien plusieurs méthodes de tests. Les assertions dans les méthodes de test envoient des messages vers le framework de test qui affiche immédiatement le résultat. Cette réponse immédiate est importante, non seulement lors d'un crash causé par le code, mais aussi de manière à rapprocher l'affichage de l'erreur au plus près du scénario de test concerné.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Pour voir ces résultats lançons effectivement les tests. S'il s'agit de l'unique scénario de test à lancer, on peut y arriver avec...
|
||
|
|
<pre>
|
||
|
|
<?php
|
||
|
|
require_once('simpletest/unit_tester.php');
|
||
|
|
require_once('simpletest/reporter.php');
|
||
|
|
require_once('../classes/log.php');
|
||
|
|
|
||
|
|
class TestOfLogging extends UnitTestCase {
|
||
|
|
|
||
|
|
function testCreatingNewFile() {
|
||
|
|
@unlink('/temp/test.log');
|
||
|
|
$log = new Log('/temp/test.log');
|
||
|
|
$this->assertFalse(file_exists('/temp/test.log'));
|
||
|
|
$log->message('Should write this to a file');
|
||
|
|
$this->assertTrue(file_exists('/temp/test.log'));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
<strong>
|
||
|
|
$test = &new TestOfLogging();
|
||
|
|
$test->run(new HtmlReporter());</strong>
|
||
|
|
?>
|
||
|
|
</pre>
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
En cas échec, l'affichage ressemble à...
|
||
|
|
<div class="demo">
|
||
|
|
<h1>testoflogging</h1>
|
||
|
|
<span class="fail">Fail</span>: testcreatingnewfile->True assertion failed.<br>
|
||
|
|
<div style="padding: 8px; margin-top: 1em; background-color: red; color: white;">1/1 test cases complete.
|
||
|
|
<strong>1</strong> passes and <strong>1</strong> fails.</div>
|
||
|
|
</div>
|
||
|
|
...et si ça passe, on obtient...
|
||
|
|
<div class="demo">
|
||
|
|
<h1>testoflogging</h1>
|
||
|
|
<div style="padding: 8px; margin-top: 1em; background-color: green; color: white;">1/1 test cases complete.
|
||
|
|
<strong>2</strong> passes and <strong>0</strong> fails.</div>
|
||
|
|
</div>
|
||
|
|
Et si vous obtenez ça...
|
||
|
|
<div class="demo">
|
||
|
|
<b>Fatal error</b>: Failed opening required '../classes/log.php' (include_path='') in <b>/home/marcus/projects/lastcraft/tutorial_tests/Log/tests/log_test.php</b> on line <b>7</b>
|
||
|
|
</div>
|
||
|
|
c'est qu'il vous manque le fichier <em>classes/Log.php</em> qui pourrait ressembler à :
|
||
|
|
<pre>
|
||
|
|
<?php
|
||
|
|
class Log {
|
||
|
|
|
||
|
|
function Log($file_path) {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
?>;
|
||
|
|
</pre>
|
||
|
|
</p>
|
||
|
|
|
||
|
|
<p>
|
||
|
|
<a class="target" name="group">
|
||
|
|
<h2>Construire des groupes de tests</h2>
|
||
|
|
</a>
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Il est peu probable que dans une véritable application on ait uniquement besoin de passer un seul scénario de test. Cela veut dire que nous avons besoin de grouper les scénarios dans un script de test qui peut, si nécessaire, lancer tous les tests de l'application.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Notre première étape est de supprimer les includes et de défaire notre hack précédent...
|
||
|
|
<pre>
|
||
|
|
<?php<strong>
|
||
|
|
require_once('../classes/log.php');</strong>
|
||
|
|
|
||
|
|
class TestOfLogging extends UnitTestCase {
|
||
|
|
|
||
|
|
function testCreatingNewFile() {
|
||
|
|
@unlink('/temp/test.log');
|
||
|
|
$log = new Log('/temp/test.log');
|
||
|
|
$this->assertFalse(file_exists('/temp/test.log'));
|
||
|
|
$log->message('Should write this to a file');
|
||
|
|
$this->assertTrue(file_exists('/temp/test.log'));<strong>
|
||
|
|
}
|
||
|
|
}
|
||
|
|
?></strong>
|
||
|
|
</pre>
|
||
|
|
Ensuite nous créons un nouveau fichier appelé <em>tests/all_tests.php</em>. On y insert le code suivant...
|
||
|
|
<pre>
|
||
|
|
<strong><?php
|
||
|
|
require_once('simpletest/unit_tester.php');
|
||
|
|
require_once('simpletest/reporter.php');
|
||
|
|
|
||
|
|
$test = &new GroupTest('All tests');
|
||
|
|
$test->addTestFile('log_test.php');
|
||
|
|
$test->run(new HtmlReporter());
|
||
|
|
?></strong>
|
||
|
|
</pre>
|
||
|
|
Cette méthode <span class="new_code">GroupTest::addTestFile()</span> va inclure le fichier de scénarios de test et lire parmi toutes les nouvelles classes créées celles qui sont issues de <span class="new_code">TestCase</span>. Dans un premier temps, seuls les noms sont stockés, de la sorte le lanceur de test peut instancier la classe au fur et à mesure qu'il exécute votre suite de tests.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Pour que ça puisse marcher proprement le fichier de suite de tests ne devrait pas inclure aveuglement d'autres extensions de scénarios de test qui n'exécuteraient pas effectivement de test. Le résultat pourrait être que des tests supplémentaires soient alors être comptabilisés pendant l'exécution des tests. Ce n'est pas un problème grave mais pour éviter ce désagrément, il suffit d'ajouter la commande <span class="new_code">SimpleTestOptions::ignore()</span> quelque part dans le fichier de scénario de test. Par ailleurs le scénario de test ne devrait pas avoir été inclus ailleurs ou alors aucun scénario ne sera ajouté aux groupes de test. Il s'agirait là d'une erreur autrement sérieuse : si tous les classes de scénario de test sont chargées par PHP, alors la méthode <span class="new_code">GroupTest::addTestFile()</span> ne pourra pas les détecter.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Pour afficher les résultats, il est seulement nécessaire d'invoquer <em>tests/all_tests.php</em> à partir du serveur web.
|
||
|
|
</p>
|
||
|
|
|
||
|
|
<p>
|
||
|
|
<a class="target" name="mock">
|
||
|
|
<h2>Utiliser les objets fantaisie</h2>
|
||
|
|
</a>
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Avançons un peu plus dans le futur.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Supposons que notre class logging soit testée et terminée. Supposons aussi que nous testons une autre classe qui ait besoin d'écrire des messages de log, disons <span class="new_code">SessionPool</span>. Nous voulons tester une méthode qui ressemblera probablement à quelque chose comme...
|
||
|
|
<pre>
|
||
|
|
<strong>
|
||
|
|
class SessionPool {
|
||
|
|
...
|
||
|
|
function logIn($username) {
|
||
|
|
...
|
||
|
|
$this->_log->message('User $username logged in.');
|
||
|
|
...
|
||
|
|
}
|
||
|
|
...
|
||
|
|
}
|
||
|
|
</strong>
|
||
|
|
</pre>
|
||
|
|
Avec le concept de "réutilisation de code" comme fil conducteur, nous utilisons notre class <span class="new_code">Log</span>. Un scénario de test classique ressemblera peut-être à...
|
||
|
|
<pre>
|
||
|
|
<strong>
|
||
|
|
<?php
|
||
|
|
require_once('../classes/log.php');
|
||
|
|
require_once('../classes/session_pool.php');
|
||
|
|
|
||
|
|
class TestOfSessionLogging extends UnitTestCase {
|
||
|
|
|
||
|
|
function setUp() {
|
||
|
|
@unlink('/temp/test.log');
|
||
|
|
}
|
||
|
|
|
||
|
|
function tearDown() {
|
||
|
|
@unlink('/temp/test.log');
|
||
|
|
}
|
||
|
|
|
||
|
|
function testLogInIsLogged() {
|
||
|
|
$log = new Log('/temp/test.log');
|
||
|
|
$session_pool = &new SessionPool($log);
|
||
|
|
$session_pool->logIn('fred');
|
||
|
|
$messages = file('/temp/test.log');
|
||
|
|
$this->assertEqual($messages[0], "User fred logged in.\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
?></strong>
|
||
|
|
</pre>
|
||
|
|
Le design de ce scénario de test n'est pas complètement mauvais, mais on peut l'améliorer. Nous passons du temps à tripoter les fichiers de log qui ne font pas partie de notre test. Pire, nous avons créé des liens de proximité entre la classe <span class="new_code">Log</span> et ce test. Que se passerait-il si nous n'utilisions plus de fichiers, mais la bibliothèque <em>syslog</em> à la place ? Avez-vous remarqué le retour chariot supplémentaire à la fin du message ? A-t-il été ajouté par le loggueur ? Et si il ajoutait aussi un timestamp ou d'autres données ?
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
L'unique partie à tester réellement est l'envoi d'un message précis au loggueur. Nous réduisons le couplage en créant une fausse classe de logging : elle ne fait qu'enregistrer le message pour le test, mais ne produit aucun résultat. Sauf qu'elle doit ressembler exactement à l'original.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Si l'objet fantaisie n'écrit pas dans un fichier alors nous nous épargnons la suppression du fichier avant et après le test. Nous pourrions même nous épargner quelques lignes de code supplémentaires si l'objet fantaisie pouvait exécuter l'assertion.
|
||
|
|
<p>
|
||
|
|
</p>
|
||
|
|
Trop beau pour être vrai ? Par chance on peut créer un tel objet très facilement...
|
||
|
|
<pre>
|
||
|
|
<?php
|
||
|
|
require_once('../classes/log.php');
|
||
|
|
require_once('../classes/session_pool.php');<strong>
|
||
|
|
Mock::generate('Log');</strong>
|
||
|
|
|
||
|
|
class TestOfSessionLogging extends UnitTestCase {
|
||
|
|
|
||
|
|
function testLogInIsLogged() {<strong>
|
||
|
|
$log = &new MockLog($this);
|
||
|
|
$log->expectOnce('message', array('User fred logged in.'));</strong>
|
||
|
|
$session_pool = &new SessionPool($log);
|
||
|
|
$session_pool->logIn('fred');<strong>
|
||
|
|
$log->tally();</strong>
|
||
|
|
}
|
||
|
|
}
|
||
|
|
?>
|
||
|
|
</pre>
|
||
|
|
L'appel <span class="new_code">tally()</span> est nécessaire pour annoncer à l'objet fantaisie qu'il n'y aura plus d'appels ultérieurs. Sans ça l'objet fantaisie pourrait attendre pendant une éternité l'appel de la méthode sans jamais prévenir le scénario de test. Les autres tests sont déclenchés automatiquement quand l'appel à <span class="new_code">message()</span> est invoqué sur l'objet <span class="new_code">MockLog</span>. L'appel <span class="new_code">mock</span> va déclencher une comparaison des paramètres et ensuite envoyer le message "pass" ou "fail" au test pour l'affichage. Des jokers peuvent être inclus ici aussi afin d'empêcher que les tests ne deviennent trop spécifiques.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Les objets fantaisie dans la suite SimpleTest peuvent avoir un ensemble de valeurs de sortie arbitraires, des séquences de sorties, des valeurs de sortie sélectionnées à partir des arguments d'entrée, des séquences de paramètres attendus et des limites sur le nombre de fois qu'une méthode peut être invoquée.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Pour que ce test fonctionne la librairie avec les objets fantaisie doit être incluse dans la suite de tests, par exemple dans <em>all_tests.php</em>.
|
||
|
|
</p>
|
||
|
|
|
||
|
|
<p>
|
||
|
|
<a class="target" name="web">
|
||
|
|
<h2>Tester une page web</h2>
|
||
|
|
</a>
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Une des exigences des sites web, c'est qu'ils produisent des pages web. Si vous construisez un projet de A à Z et que vous voulez intégrer des tests au fur et à mesure alors vous voulez un outil qui puisse effectuer une navigation automatique et en examiner le résultat. C'est le boulot d'un testeur web.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
Effectuer un test web via SimpleTest reste assez primitif : il n'y a pas de javascript par exemple. Pour vous donner une idée, voici un exemple assez trivial : aller chercher une page web, à partir de là naviguer vers la page "about" et finalement tester un contenu déterminé par le client.
|
||
|
|
<pre>
|
||
|
|
<?php<strong>
|
||
|
|
require_once('simpletest/web_tester.php');</strong>
|
||
|
|
require_once('simpletest/reporter.php');
|
||
|
|
<strong>
|
||
|
|
class TestOfAbout extends WebTestCase {
|
||
|
|
|
||
|
|
function setUp() {
|
||
|
|
$this->get('http://test-server/index.php');
|
||
|
|
$this->clickLink('About');
|
||
|
|
}
|
||
|
|
|
||
|
|
function testSearchEngineOptimisations() {
|
||
|
|
$this->assertTitle('A long title about us for search engines');
|
||
|
|
$this->assertWantedPattern('/a popular keyphrase/i');
|
||
|
|
}
|
||
|
|
}</strong>
|
||
|
|
$test = &new TestOfAbout();
|
||
|
|
$test->run(new HtmlReporter());
|
||
|
|
?>
|
||
|
|
</pre>
|
||
|
|
Avec ce code comme test de recette, vous pouvez vous assurer que le contenu corresponde toujours aux spécifications à la fois des développeurs et des autres parties prenantes au projet.
|
||
|
|
</p>
|
||
|
|
<p>
|
||
|
|
<a href="http://sourceforge.net/projects/simpletest/"><img src="http://sourceforge.net/sflogo.php?group_id=76550&type=5" width="210" height="62" border="0" alt="SourceForge.net Logo"></a>
|
||
|
|
</p>
|
||
|
|
|
||
|
|
</div>
|
||
|
|
<div class="copyright">
|
||
|
|
Copyright<br>Marcus Baker, Jason Sweat, Perrick Penet 2004
|
||
|
|
</div>
|
||
|
|
</body>
|
||
|
|
</html>
|