documentation/manual/fr/module_specs/Zend_Test-PHPUnit-Examples.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <!-- EN-Revision: 22236 -->
   3 <!-- Reviewed: no -->
   4 <sect2 id="zend.test.phpunit.examples">
   5     <title>Exemples</title>
   6
   7     <para>
   8         Savoir comment configurer votre infrastructure de tests et comment faire des
   9         assertions est seulement la moitié du travail ; maintenant il est temps de commencer à
  10         regarder quelques scénarios réels de test pour voir comment vous pouvez les étendre.
  11     </para>
  12
  13     <example id="zend.test.phpunit.examples.userController">
  14         <title>Test d'un contrôleur "UserController"</title>
  15
  16         <para>
  17             Considérons une tâche habituelle d'un site Web : l'authentification et
  18             l'enregistrement d'utilisateurs. Dans notre exemple, nous avons défini un contrôleur
  19             "<code>UserController</code>" pour gérer ceci, il requiert le conditions suivantes
  20             :
  21         </para>
  22
  23         <itemizedlist>
  24             <listitem>
  25                 <para>
  26                     Si un utilisateur n'est pas authentifié, il sera toujours redirigé vers la
  27                     page de login, sans se soucier de l'action demandée.
  28                 </para>
  29             </listitem>
  30
  31             <listitem>
  32                 <para>
  33                     La page avec le formulaire de login présente à la fois le formulaire de
  34                     login et le formulaire d'enregistrement.
  35                 </para>
  36             </listitem>
  37
  38             <listitem>
  39                 <para>
  40                     Fournir une identification invalide entraîne un retour au formulaire de
  41                     login.
  42                 </para>
  43             </listitem>
  44
  45             <listitem>
  46                 <para>
  47                     Une identification valide entraîne une redirection vers la page avec le
  48                     profil de l'utilisateur.
  49                 </para>
  50             </listitem>
  51
  52             <listitem>
  53                 <para>
  54                     La page de profil peut être personnalisée pour contenir le nom
  55                     d'utilisateur.
  56                 </para>
  57             </listitem>
  58
  59             <listitem>
  60                 <para>
  61                     Les utilisateurs déjà authentifiés qui accèdent à la page de login sont
  62                     redirigés vers leur page de profil.
  63                 </para>
  64             </listitem>
  65
  66             <listitem>
  67                 <para>
  68                     En cas de déconnexion, un utilisateur est redirigé vers la page de
  69                     login.
  70                 </para>
  71             </listitem>
  72
  73             <listitem>
  74                 <para>
  75                     Avec des données invalides, l'enregistrement doit entraîner un
  76                     échec.
  77                 </para>
  78             </listitem>
  79         </itemizedlist>
  80
  81         <para>
  82             Nous pourrions, et devrions définir d'autres tests, mais ceux-ci suffiront pour
  83             l'instant.
  84         </para>
  85
  86         <para>
  87             Pour notre application, nous définirons un plugin "<code>Initialize</code>", qui
  88             fonctionne en <methodname>routeStartup()</methodname>. Ceci nous permet d'encapsuler notre fichier
  89             d'amorçage dans une interface POO, et qui nous permet aussi de fournir par une solution
  90             simple une fonction de rappel ("callback"). Regardons d'abord les bases de cette classe
  91             :
  92         </para>
  93
  94         <programlisting language="php"><![CDATA[
  95 class Bugapp_Plugin_Initialize extends Zend_Controller_Plugin_Abstract
  96 {
  97     /**
  98      * @var Zend_Config
  99      */
 100     protected static $_config;
 101
 102     /**
 103      * @var string Current environment
 104      */
 105     protected $_env;
 106
 107     /**
 108      * @var Zend_Controller_Front
 109      */
 110     protected $_front;
 111
 112     /**
 113      * @var string Path to application root
 114      */
 115     protected $_root;
 116
 117     /**
 118      * Constructor
 119      *
 120      * Initialize environment, root path, and configuration.
 121      *
 122      * @param  string $env
 123      * @param  string|null $root
 124      * @return void
 125      */
 126     public function __construct($env, $root = null)
 127     {
 128         $this->_setEnv($env);
 129         if (null === $root) {
 130             $root = realpath(dirname(__FILE__) . '/../../../');
 131         }
 132         $this->_root = $root;
 133
 134         $this->initPhpConfig();
 135
 136         $this->_front = Zend_Controller_Front::getInstance();
 137     }
 138
 139     /**
 140      * Route startup
 141      *
 142      * @return void
 143      */
 144     public function routeStartup(Zend_Controller_Request_Abstract $request)
 145     {
 146         $this->initDb();
 147         $this->initHelpers();
 148         $this->initView();
 149         $this->initPlugins();
 150         $this->initRoutes();
 151         $this->initControllers();
 152     }
 153
 154     // definition of methods would follow...
 155 }
 156 ]]></programlisting>
 157
 158         <para>Ceci nous permet de créer un callback d'amorçage comme ce qui suit :</para>
 159
 160         <programlisting language="php"><![CDATA[
 161 class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
 162 {
 163     public function appBootstrap()
 164     {
 165         $controller = $this->getFrontController();
 166         $controller->registerPlugin(
 167             new Bugapp_Plugin_Initialize('development')
 168         );
 169     }
 170
 171     public function setUp()
 172     {
 173         $this->bootstrap = array($this, 'appBootstrap');
 174         parent::setUp();
 175     }
 176
 177     // ...
 178 }
 179 ]]></programlisting>
 180
 181         <para>
 182             Une fois ceci en place, nous pouvons écrire nos tests. Cependant, combien de ces
 183             tests nécessiteront qu'un utilisateur soit connecté ? La solution la plus simple est
 184             d'utiliser la logique de votre application pour faire ceci... et d'esquiver un peu par
 185             l'utilisation des méthodes <methodname>resetResponse()</methodname> et <methodname>resetResponse()</methodname>,
 186             qui vous permettront de distribuer une nouvelle requête.
 187         </para>
 188
 189         <programlisting language="php"><![CDATA[
 190 class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
 191 {
 192     // ...
 193
 194     public function loginUser($user, $password)
 195     {
 196         $this->request->setMethod('POST')
 197                       ->setPost(array(
 198                           'username' => $user,
 199                           'password' => $password,
 200                       ));
 201         $this->dispatch('/user/login');
 202         $this->assertRedirectTo('/user/view');
 203
 204         $this->resetRequest()
 205              ->resetResponse();
 206
 207         $this->request->setPost(array());
 208
 209         // ...
 210     }
 211
 212     // ...
 213 }
 214 ]]></programlisting>
 215
 216         <para>Écrivons maintenant les tests :</para>
 217
 218         <programlisting language="php"><![CDATA[
 219 class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
 220 {
 221     // ...
 222
 223     public function testCallWithoutActionShouldPullFromIndexAction()
 224     {
 225         $this->dispatch('/user');
 226         $this->assertController('user');
 227         $this->assertAction('index');
 228     }
 229
 230     public function testLoginFormShouldContainLoginAndRegistrationForms()
 231     {
 232         $this->dispatch('/user');
 233         $this->assertQueryCount('form', 2);
 234     }
 235
 236     public function testInvalidCredentialsShouldResultInRedisplayOfLoginForm()
 237     {
 238         $request = $this->getRequest();
 239         $request->setMethod('POST')
 240                 ->setPost(array(
 241                     'username' => 'bogus',
 242                     'password' => 'reallyReallyBogus',
 243                 ));
 244         $this->dispatch('/user/login');
 245         $this->assertNotRedirect();
 246         $this->assertQuery('form');
 247     }
 248
 249     public function testValidLoginShouldRedirectToProfilePage()
 250     {
 251         $this->loginUser('foobar', 'foobar');
 252     }
 253
 254     public function testAuthenticatedUserShouldHaveCustomizedProfilePage()
 255     {
 256         $this->loginUser('foobar', 'foobar');
 257         $this->request->setMethod('GET');
 258         $this->dispatch('/user/view');
 259         $this->assertNotRedirect();
 260         $this->assertQueryContentContains('h2', 'foobar');
 261     }
 262
 263     public function testAuthenticatedUsersShouldBeRedirectedToProfilePageWhenVisitingLoginPage()
 264     {
 265         $this->loginUser('foobar', 'foobar');
 266         $this->request->setMethod('GET');
 267         $this->dispatch('/user');
 268         $this->assertRedirectTo('/user/view');
 269     }
 270
 271     public function testUserShouldRedirectToLoginPageOnLogout()
 272     {
 273         $this->loginUser('foobar', 'foobar');
 274         $this->request->setMethod('GET');
 275         $this->dispatch('/user/logout');
 276         $this->assertRedirectTo('/user');
 277     }
 278
 279     public function testRegistrationShouldFailWithInvalidData()
 280     {
 281         $data = array(
 282             'username' => 'This will not work',
 283             'email'    => 'this is an invalid email',
 284             'password' => 'Th1s!s!nv@l1d',
 285             'passwordVerification' => 'wrong!',
 286         );
 287         $request = $this->getRequest();
 288         $request->setMethod('POST')
 289                 ->setPost($data);
 290         $this->dispatch('/user/register');
 291         $this->assertNotRedirect();
 292         $this->assertQuery('form .errors');
 293     }
 294 }
 295 ]]></programlisting>
 296
 297         <para>
 298             Notez que ces tests sont laconiques, et, pour la plupart, ne recherchent pas le
 299             contenu réel. Au lieu de cela, ils recherchent des objets construits dans la réponse -
 300             codes et en-têtes de réponse, et noeuds DOM. Ceci vous permet de vérifier que la
 301             structure est comme prévue - sans entraîner un échec dans vos tests à chaque fois qu'un
 302             contenu est ajouté au site.
 303         </para>
 304
 305         <para>
 306             Notez également que nous utilisons la structure du document dans nos essais. Par
 307             exemple, dans le test final, nous recherchons un formulaire qui a un noeud avec la
 308             classe "errors" ; ceci nous permet de déterminer simplement la présence des erreurs de
 309             validation de formulaire, et sans nous inquiéter de quelles erreurs spécifiques
 310             pourraient avoir été levées.
 311         </para>
 312
 313         <para>
 314             Cette application <emphasis>peut</emphasis> utiliser une base de données. Si oui,
 315             vous aurez besoin probablement d'un certain échafaudage pour s'assurer que la base de
 316             données est dans une configuration initiale et testable au début de chaque essai.
 317             PHPUnit fournit déjà une fonctionnalité pour faire ceci ; <ulink
 318             url="http://www.phpunit.de/manual/3.4/en/database.html">lisez ceci dans la
 319             documentation PHPUnit</ulink>. Nous recommandons d'utiliser une base de données séparée
 320             pour les tests et pour la production, et recommandons en particulier d'employer un
 321             fichier SQLite ou une base de données en mémoire, d'autant que les deux options
 322             s'exécutent très bien, sans nécessité d'un serveur séparé, et peuvent utiliser la
 323             plupart de la syntaxe <acronym>SQL</acronym>
 324         </para>
 325     </example>
 326 </sect2>
 327 <!--
 328 vim:se ts=4 sw=4 et:
 329 -->