<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 24249 -->
<!-- Reviewed: no -->
<sect2 id="zend.test.phpunit.db.testing">
    <title>Utilisation, API et possibilités d'extension</title>

    <para>
        Le Quickstart permet déja de se rendre compte des capacités de tests d'une base de données avec
        PHPUnit et Zend Framework. Cette section donne un aperçu de l'<acronym>API</acronym> de
        <classname>Zend_Test_PHPUnit_Db</classname> ainsi que de son fonctionnement interne.
    </para>

    <note>
        <title>Remarque sur les tests de bases de données</title>

        <para>
            Tout comme les TestCase de vos contrôleurs, les tests de bases de données sont efféctués
            au niveau intégration. Ils utilisent différentes couches applicatives pour lancer les tests
            et à ce titre devraient être utilisés avec précaution.
        </para>

        <para>
            Notez que tester la logique métier au seul moyen de tests d'intégration comme ceux
            fournis avec Zend_Test de Zend Framework est une mauvaise pratique. Les tests d'intégration
            sont là pour prouver le bon fonctionnement de l'assemblage des composants entre eux, ils ne
            doivent donc pas remplacer des tests unitaires éffectués plus bas dans les couches de votre
            logique métier.
        </para>
    </note>

    <sect3 id="zend.test.phpunit.db.testing.testcase">
        <title>La classe Zend_Test_PHPUnit_DatabaseTestCase</title>

        <para>
            La classe <classname>Zend_Test_PHPUnit_DatabaseTestCase</classname> étend
            <classname>PHPUnit_Extensions_Database_TestCase</classname>, celle-ci permet de configurer
            un jeu de données concernant la base, pour chaque test. L'implementation du Zend Framework
            offre quelques fonctionalités supplémentaires par rapport à l'extension PHPUnit concernant
            les bases de données, ceci dans le but d'utiliser des ressources provenant de
            <classname>Zend_Db</classname>. Voici le scénario classique d'un test de base de données :
        </para>

        <orderedlist>
            <listitem>
                <para>
                    Pour chaque test, PHPUnit crée une instance de la classe de tests (TestCase) et lance
                    la méthode <methodname>setUp()</methodname>.
                </para>
            </listitem>

            <listitem>
                <para>
                    Le scénario de test (TestCase) crée à son tour une instance du testeur de base de données
                    (Database Tester) qui s'occupe de la construction et destruction de la base de données.
                </para>
            </listitem>

            <listitem>
                <para>
                    Le testeur de base de données récupère la connexion à la base et le jeu de données
                    initiales grâce à <methodname>getConnection()</methodname> et
                    <methodname>getDataSet()</methodname> qui sont toutes deux des méthodes abstraites
                    que vous devez implémenter dans votre scénario de test.
                </para>
            </listitem>

            <listitem>
                <para>
                    Par défaut le testeur vide les tables spécifiées dans le jeu de données, puis
                    peuple la base avec le jeu de données.
                </para>
            </listitem>

            <listitem>
                <para>
                    Lorsque le testeur a fini de monter la base, PHPUnit lance votre test.
                </para>
            </listitem>

            <listitem>
                <para>
                    Après que votre test ait fini, <methodname>tearDown()</methodname> est appelée.
                    Cette méthode n'exécute aucune action du la base de données elle-même car les
                    actions à mener sont efféctuées en <methodname>setUp()</methodname> (vider les
                    tables).
                </para>
            </listitem>
        </orderedlist>

        <note>
            <para>
                Le test de la base s'attend à ce que la base de données et les tables soient présentes.
                Il n'existe pas de mécanisme pour créer/détruire des base de données et/ou des tables.
            </para>
        </note>

        <para>
            La classe <classname>Zend_Test_PHPUnit_DatabaseTestCase</classname> permet les tests de base
            de données à l'echelle du Zend Framework.
        </para>

        <para>
            Le tableau suivant liste uniquement les nouvelles méthodes par rapport à la classe
            <classname>PHPUnit_Extensions_Database_TestCase</classname>, dont l'<ulink
                url="http://www.phpunit.de/manual/current/en/database.html">API est documentée dans
                la documentation de PHPUnit</ulink>.
        </para>

        <table id="zend.test.phpunit.db.testing.testcase.api-methods">
            <title>Méthodes de Zend_Test_PHPUnit_DatabaseTestCase</title>

            <tgroup cols="2">
                <thead>
                    <row>
                        <entry>Méthode</entry>
                        <entry>Description</entry>
                    </row>
                </thead>

                <tbody>
                    <row>
                        <entry>
                            <methodname>createZendDbConnection(Zend_Db_Adapter_Abstract $connection,
                                $schema)</methodname>
                        </entry>

                        <entry>
                            Créer une connexion compatible avec l'extension PHPUnit Database depuis une
                            instance de <classname>Zend_Db_Adapter_Abstract</classname>. Cette méthode devrait
                            être utilisée dans la configuration du scénario de tests en implémentant la méthode
                            abstraite <methodname>getConnection()</methodname>.
                        </entry>
                    </row>

                    <row>
                        <entry><methodname>getAdapter()</methodname></entry>

                        <entry>
                            Méthode permettant l'accès à l'instance de
                            <classname>Zend_Db_Adapter_Abstract</classname> qui est encapsulée dans
                            la connexion efféctuée par PHPUnit au moyen de
                            <methodname>getConnection()</methodname>.
                        </entry>
                    </row>

                    <row>
                        <entry>
                            <methodname>createDbRowset(Zend_Db_Table_Rowset_Abstract $rowset,
                                $tableName = null)</methodname>
                        </entry>

                        <entry>
                            Créer un objet représentant les données d'une table depuis une instance de
                            <classname>Zend_Db_Table_Rowset_Abstract</classname> donnée. La table
                            reliée au rowset est choisie lorsque <varname>$tableName</varname>
                            est <constant>NULL</constant>.
                        </entry>
                    </row>

                    <row>
                        <entry>
                            <methodname>createDbTable(Zend_Db_Table_Abstract $table, $where = null,
                                $order = null, $count = null, $offset = null)</methodname>
                        </entry>

                        <entry>
                            Créer un objet qui représente les données contenues dans une instance de
                            <classname>Zend_Db_Table_Abstract</classname> donnée. La récupération des
                            données est faite grâce à <methodname>fetchAll()</methodname>, les paramètres
                            additionnels peuvent servir à limiter les données retournées.
                        </entry>
                    </row>

                    <row>
                        <entry>
                            <methodname>createDbTableDataSet(array $tables=array())</methodname>
                        </entry>

                        <entry>
                            Crée un jeu de données basé sur les tables <varname>$tables</varname>, tableau
                            d'instances de <classname>Zend_Db_Table_Abstract</classname>.
                        </entry>
                    </row>
                </tbody>
            </tgroup>
        </table>
    </sect3>

    <sect3 id="zend.test.phpunit.db.testing.controllerintegration">
        <title>Intégrer les tests de bases de données avec les tests de contrôleurs</title>

        <para>
            <acronym>PHP</acronym> n'autorise pas l'héritage multiple, donc vous ne pouvez utiliser
            les tests de contrôleurs et de bases de données en même temps via héritage. Cependant,
            vous pouvez utiliser <classname>Zend_Test_PHPUnit_Db_SimpleTester</classname> dans vos tests de
            contrôleurs pour configurer un environnement relatif à la base pour chaque test de contrôleur.
        </para>

        <example id="zend.test.phpunit.db.testing.controllerintegration.example">
            <title>Exemple d'intégration d'une base de données</title>

            <para>
                Cet exemple reprend le test de UserController utilisé dans la documentation de
                <classname>Zend_Test_PHPUnit_ControllerTestCase</classname> et y inclut la gestion
                d'une base de données.
            </para>

            <programlisting language="php"><![CDATA[
class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
    public function setUp()
    {
        $this->setupDatabase();
        $this->bootstrap = array($this, 'appBootstrap');
        parent::setUp();
    }

    public function setupDatabase()
    {
        $db = Zend_Db::factory(...);
        $connection = new Zend_Test_PHPUnit_Db_Connection($db,
                                                      'database_schema_name');
        $databaseTester = new Zend_Test_PHPUnit_Db_SimpleTester($connection);

        $databaseFixture =
                    new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(
                        dirname(__FILE__) . '/_files/initialUserFixture.xml'
                    );

        $databaseTester->setupDatabase($databaseFixture);
    }
}
]]></programlisting>

            <para>
                Ici le jeu de données <acronym>XML</acronym> "initialUserFixture.xml" est utilisé pour monter
                des données en base avant chaque test, exactement de la même manière que DatabaseTestCase le
                fait en interne.
            </para>
        </example>
    </sect3>
</sect2>
