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

<!-- EN-Revision: 13910 -->
<sect2 id="zend.test.phpunit.examples">
    <title>Exemples</title>

    <para>Savoir comment configurer votre infrastructure de tests et comment faire des assertions est seulement la
    moitié du travail ; maintenant il est temps de commencer à regarder quelques scénarios réels de test pour voir
    comment vous pouvez les étendre. </para>

    <example id="zend.test.phpunit.examples.userController">
        <title>Test d'un contrôleur "UserController"</title>

        <para>Considérons une tâche habituelle d'un site Web : l'authentification et l'enregistrement d'utilisateurs.
        Dans notre exemple, nous avons défini un contrôleur "<code>UserController</code>" pour gérer ceci, il requiert
        le conditions suivantes :</para>

        <itemizedlist>
            <listitem>
                <para>Si un utilisateur n'est pas authentifié, il sera toujours redirigé vers la page de login, sans se
                soucier de l'action demandée.</para>
            </listitem>

            <listitem>
                <para>La page avec le formulaire de login présente à la fois le formulaire de login et le formulaire
                d'enregistrement.</para>
            </listitem>

            <listitem>
                <para>Fournir une identification invalide entraîne un retour au formulaire de login.</para>
            </listitem>

            <listitem>
                <para>Une identification valide entraîne une redirection vers la page avec le profil de
                l'utilisateur.</para>
            </listitem>

            <listitem>
                <para>La page de profil peut être personnalisée pour contenir le nom d'utilisateur.</para>
            </listitem>

            <listitem>
                <para>Les utilisateurs déjà authentifiés qui accèdent à la page de login sont redirigés vers leur page
                de profil.</para>
            </listitem>

            <listitem>
                <para>En cas de déconnexion, un utilisateur est redirigé vers la page de login.</para>
            </listitem>

            <listitem>
                <para>Avec des données invalides, l'enregistrement doit entraîner un échec.</para>
            </listitem>
        </itemizedlist>

        <para>Nous pourrions, et devrions définir d'autres tests, mais ceux-ci suffiront pour l'instant.</para>

        <para>Pour notre application, nous définirons un plugin "<code>Initialize</code>", qui fonctionne en
        <code>routeStartup()</code>. Ceci nous permet d'encapsuler notre fichier d'amorçage dans une interface POO, et
        qui nous permet aussi de fournir par une solution simple une fonction de rappel ("callback"). Regardons d'abord
        les bases de cette classe :</para>

        <programlisting role="php"><![CDATA[
class Bugapp_Plugin_Initialize extends Zend_Controller_Plugin_Abstract
{
    /**
     * @var Zend_Config
     */
    protected static $_config;

    /**
     * @var string Current environment
     */
    protected $_env;

    /**
     * @var Zend_Controller_Front
     */
    protected $_front;

    /**
     * @var string Path to application root
     */
    protected $_root;

    /**
     * Constructor
     *
     * Initialize environment, root path, and configuration.
     *
     * @param  string $env
     * @param  string|null $root
     * @return void
     */
    public function __construct($env, $root = null)
    {
        $this->_setEnv($env);
        if (null === $root) {
            $root = realpath(dirname(__FILE__) . '/../../../');
        }
        $this->_root = $root;

        $this->initPhpConfig();

        $this->_front = Zend_Controller_Front::getInstance();
    }

    /**
     * Route startup
     *
     * @return void
     */
    public function routeStartup(Zend_Controller_Request_Abstract $request)
    {
        $this->initDb();
        $this->initHelpers();
        $this->initView();
        $this->initPlugins();
        $this->initRoutes();
        $this->initControllers();
    }

    // definition of methods would follow...
}
]]></programlisting>

        <para>Ceci nous permet de créer un callback d'amorçage comme ce qui suit :</para>

        <programlisting role="php"><![CDATA[
class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
    public function appBootstrap()
    {
        $controller = $this->getFrontController();
        $controller->registerPlugin(
            new Bugapp_Plugin_Initialize('development')
        );
    }

    public function setUp()
    {
        $this->bootstrap = array($this, 'appBootstrap');
        parent::setUp();
    }

    // ...
}
]]></programlisting>

        <para>Une fois ceci en place, nous pouvons écrire nos tests. Cependant, combien de ces tests nécessiteront qu'un
        utilisateur soit connecté ? La solution la plus simple est d'utiliser la logique de votre application pour faire
        ceci... et d'esquiver un peu par l'utilisation des méthodes <code>resetResponse()</code> et
        <code>resetResponse()</code>, qui vous permettront de distribuer une nouvelle requête.</para>

        <programlisting role="php"><![CDATA[
class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
    // ...

    public function loginUser($user, $password)
    {
        $this->request->setMethod('POST')
                      ->setPost(array(
                          'username' => $user,
                          'password' => $password,
                      ));
        $this->dispatch('/user/login');
        $this->assertRedirectTo('/user/view');

        $this->resetRequest()
             ->resetResponse();

        $this->request->setPost(array());

        // ...
    }

    // ...
}
]]></programlisting>

        <para>Écrivons maintenant les tests :</para>

        <programlisting role="php"><![CDATA[
class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
    // ...

    public function testCallWithoutActionShouldPullFromIndexAction()
    {
        $this->dispatch('/user');
        $this->assertController('user');
        $this->assertAction('index');
    }

    public function testLoginFormShouldContainLoginAndRegistrationForms()
    {
        $this->dispatch('/user');
        $this->assertQueryCount('form', 2);
    }

    public function testInvalidCredentialsShouldResultInRedisplayOfLoginForm()
    {
        $request = $this->getRequest();
        $request->setMethod('POST')
                ->setPost(array(
                    'username' => 'bogus',
                    'password' => 'reallyReallyBogus',
                ));
        $this->dispatch('/user/login');
        $this->assertNotRedirect();
        $this->assertQuery('form');
    }

    public function testValidLoginShouldRedirectToProfilePage()
    {
        $this->loginUser('foobar', 'foobar');
    }

    public function testAuthenticatedUserShouldHaveCustomizedProfilePage()
    {
        $this->loginUser('foobar', 'foobar');
        $this->request->setMethod('GET');
        $this->dispatch('/user/view');
        $this->assertNotRedirect();
        $this->assertQueryContentContains('h2', 'foobar');
    }

    public function testAuthenticatedUsersShouldBeRedirectedToProfilePageWhenVisitingLoginPage()
    {
        $this->loginUser('foobar', 'foobar');
        $this->request->setMethod('GET');
        $this->dispatch('/user');
        $this->assertRedirectTo('/user/view');
    }

    public function testUserShouldRedirectToLoginPageOnLogout()
    {
        $this->loginUser('foobar', 'foobar');
        $this->request->setMethod('GET');
        $this->dispatch('/user/logout');
        $this->assertRedirectTo('/user');
    }

    public function testRegistrationShouldFailWithInvalidData()
    {
        $data = array(
            'username' => 'This will not work',
            'email'    => 'this is an invalid email',
            'password' => 'Th1s!s!nv@l1d',
            'passwordVerification' => 'wrong!',
        );
        $request = $this->getRequest();
        $request->setMethod('POST')
                ->setPost($data);
        $this->dispatch('/user/register');
        $this->assertNotRedirect();
        $this->assertQuery('form .errors');
    }
}
]]></programlisting>

        <para>Notez que ces tests sont laconiques, et, pour la plupart, ne recherchent pas le contenu réel. Au lieu de
        cela, ils recherchent des objets construits dans la réponse - codes et en-têtes de réponse, et noeuds DOM. Ceci
        vous permet de vérifier que la structure est comme prévue - sans entraîner un échec dans vos tests à chaque fois
        qu'un contenu est ajouté au site. </para>

        <para>Notez également que nous utilisons la structure du document dans nos essais. Par exemple, dans le test
        final, nous recherchons un formulaire qui a un noeud avec la classe "errors" ; ceci nous permet de déterminer
        simplement la présence des erreurs de validation de formulaire, et sans nous inquiéter de quelles erreurs
        spécifiques pourraient avoir été levées. </para>

        <para>Cette application <emphasis>peut</emphasis> utiliser une base de données. Si oui, vous aurez besoin
        probablement d'un certain échafaudage pour s'assurer que la base de données est dans une configuration initiale
        et testable au début de chaque essai. PHPUnit fournit déjà une fonctionnalité pour faire ceci ; <ulink
        url="http://www.phpunit.de/pocket_guide/3.3/en/database.html">lisez ceci dans la documentation PHPUnit</ulink>.
        Nous recommandons d'utiliser une base de données séparée pour les tests et pour la production, et recommandons
        en particulier d'employer un fichier SQLite ou une base de données en mémoire, d'autant que les deux options
        s'exécutent très bien, sans nécessité d'un serveur séparé, et peuvent utiliser la plupart de la syntaxe
        SQL</para>
    </example>
</sect2>
<!--
vim:se ts=4 sw=4 et:
-->