# Quickstart

## Configurer un cas de tests Database

Nous allons à présent écrire des tests pour la base de données Bug de la documentation sur `Zend_Db_Table`. D'abord, nous testons qu'insérer un nouveau bug est bien sauvegardé en base. Nous devons créer un cas de tests sous forme de classe étendant `Zend_Test_PHPUnit_DatabaseTestCase`. Cette classe étend elle- même PHPUnit Database Extension, qui étend alors `PHPUnit_Framework_TestCase`. Un cas de test pour base de données contient deux méthodes abstraites à définir, une concernant la connexion à la base et l'autre concernant les données à utiliser comme source pour les tests.

Il est recommandé de se familiariser à l'extension PHPUnit Database afin de suivre nos exemples sereinnement. Bien que nous expliquions tous les concepts dans cette documentation, il peut être intéressant de lire la documentation de PHPUnit avant de suivre nos exemples.

    class BugsTest extends Zend_Test_PHPUnit_DatabaseTestCase
    {
        private $_connectionMock;

        /**
         * Retourne la connexion de test
         *
         * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection
         */
        protected function getConnection()
        {
            if($this->_connectionMock == null) {
                $connection = Zend_Db::factory(...);
                $this->_connectionMock = $this->createZendDbConnection(
                    $connection, 'zfunittests'
                );
                Zend_Db_Table_Abstract::setDefaultAdapter($connection);
            }
            return $this->_connectionMock;
        }

        /**
         * @return PHPUnit_Extensions_Database_DataSet_IDataSet
         */
        protected function getDataSet()
        {
            return $this->createFlatXmlDataSet(
                dirname(__FILE__) . '/_files/bugsSeed.xml'
            );
        }
    }

Ici, nous créons la connexion à la base et nous y injectons des données fictives de test. Les éléments suivants sont importants à noter :

- Vous ne pouvez retourner directement un objet `Zend_Db_Adapter_Abstract` depuis `getConnection()`, mais un objet spécifique à PHPUnit qui est généré grâce à la méthode `createZendDbConnection()`.

- Le schéma de la base (tables et bases de données) n'est pas recrée entre chaque test. Les bases de données et les tables doivent être créees à la main avant de lancer les tests.

- Les tests vident la base durant `setUp()` et y insèrent les données en provenance de `getDataSet()`.

- Les jeux de données (DataSets) doivent implémenter `PHPUnit_Extensions_Database_DataSet_IDataSet`. Il en existe quelques uns, basés sur XML ou YAML et ils sont inclus dans PHPUnit et permettent de décrire les données fictives pour les tests. Vous devriez vous reporter à la documentation de PHPUnit pour des informations complémentaires ou plus à jour concernant les DataSets.

## Spécifier un jeu de données (DataSet)

Dans l'exemple précédent, nous avons préciser un fichier de jeu de données. Nous allons maintenant le créer, au format XML :

    <?xml version="1.0" encoding="UTF-8" ?>
    <dataset>
        <zfbugs bug_id="1" bug_description="system needs electricity to run"
            bug_status="NEW" created_on="2007-04-01 00:00:00"
            updated_on="2007-04-01 00:00:00" reported_by="goofy"
            assigned_to="mmouse" verified_by="dduck" />
        <zfbugs bug_id="2" bug_description="Implement Do What I Mean function"
            bug_status="VERIFIED" created_on="2007-04-02 00:00:00"
            updated_on="2007-04-02 00:00:00" reported_by="goofy"
            assigned_to="mmouse" verified_by="dduck" />
        <zfbugs bug_id="3" bug_description="Where are my keys?" bug_status="FIXED"
            created_on="2007-04-03 00:00:00" updated_on="2007-04-03 00:00:00"
            reported_by="dduck" assigned_to="mmouse" verified_by="dduck" />
        <zfbugs bug_id="4" bug_description="Bug no product" bug_status="INCOMPLETE"
            created_on="2007-04-04 00:00:00" updated_on="2007-04-04 00:00:00"
            reported_by="mmouse" assigned_to="goofy" verified_by="dduck" />
    </dataset>

Nous allons travailler sur ces quatre entrées dans la table "zfbugs" après. Le script MySQL suivant est nécessaire pour l'exemple:

    CREATE TABLE IF NOT EXISTS `zfbugs` (
        `bug_id` int(11) NOT NULL auto_increment,
        `bug_description` varchar(100) default NULL,
        `bug_status` varchar(20) default NULL,
        `created_on` datetime default NULL,
        `updated_on` datetime default NULL,
        `reported_by` varchar(100) default NULL,
        `assigned_to` varchar(100) default NULL,
        `verified_by` varchar(100) default NULL,
    PRIMARY KEY  (`bug_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 ;

## Quelques tests initiaux

Maintenant que nous avons écrits les deux méthodes obligatoires pour `Zend_Test_PHPUnit_DatabaseTestCase` et que nous avons préciser avec quoi remplir la base et ses tables, nous pouvons commencer à écrire des tests afin d'effectuer des assertions. Voyons un test pour l'insertion d'un nouveau bug

    class BugsTest extends Zend_Test_PHPUnit_DatabaseTestCase
    {
        public function testBugInsertedIntoDatabase()
        {
            $bugsTable = new Bugs();

            $data = array(
                'created_on'      => '2007-03-22 00:00:00',
                'updated_on'      => '2007-03-22 00:00:00',
                'bug_description' => 'Something wrong',
                'bug_status'      => 'NEW',
                'reported_by'     => 'garfield',
                'verified_by'     => 'garfield',
                'assigned_to'     => 'mmouse',
            );

            $bugsTable->insert($data);

            $ds = new Zend_Test_PHPUnit_Db_DataSet_QueryDataSet(
                $this->getConnection()
            );
            $ds->addTable('zfbugs', 'SELECT * FROM zfbugs');

            $this->assertDataSetsEqual(
                $this->createFlatXmlDataSet(dirname(__FILE__)
                                          . "/_files/bugsInsertIntoAssertion.xml"),
                $ds
            );
        }
    }

Au dessus de la ligne `$bugsTable->insert($data);`, tout devrait vous être familier. La ligne d'après contient le nom de la méthode d'assertion. Nous souhaitons vérifier qu'après l'insertion d'un bug, la base a été correctement mise à jour avec les données. Ainsi, nous utilisons un objet de requête de jeu de données, instance de `Zend_Test_PHPUnit_Db_DataSet_QueryDataSet` et nous lui fournissons notre connexion à la base de données. Puis nous indiquons à notre objet de requête qu'il contient une table "zfbugs" contenant les données d'une requête SQL statement. Cet état actuel est alors comparé à un état contenu dans un fichier XML "bugsInsertIntoAssertions.xml". Ce fichier XML est le même que celui des données d'origine, à l'exception qu'il contient lui les données supplémentaires attendues:

    <?xml version="1.0" encoding="UTF-8" ?>
    <dataset>
        <!-- Les 4 enregistrement précédents, puis: -->
        <zfbugs bug_id="5" bug_description="Something wrong" bug_status="NEW"
            created_on="2007-03-22 00:00:00" updated_on="2007-03-22 00:00:00"
            reported_by="garfield" assigned_to="mmouse" verified_by="garfield" />
    </dataset>

Il existe d'autres manière de vérifier que l'état actuel de la base est équivalent à un état attendu. La table "Bugs" de l'exemple connait déja sont état interne, utilisons ceci à notre avantage. L'exemple suivant teste que la suppression de données dans la table est possible:

    class BugsTest extends Zend_Test_PHPUnit_DatabaseTestCase
    {
        public function testBugDelete()
        {
            $bugsTable = new Bugs();

            $bugsTable->delete(
                $bugsTable->getAdapter()->quoteInto("bug_id = ?", 4)
            );

            $ds = new Zend_Test_PHPUnit_Db_DataSet_DbTableDataSet();
            $ds->addTable($bugsTable);

            $this->assertDataSetsEqual(
                $this->createFlatXmlDataSet(dirname(__FILE__)
                                          . "/_files/bugsDeleteAssertion.xml"),
                $ds
            );
        }
    }

Ici nous créons un objet représentant un jeu de données pour une table, instance de `Zend_Test_PHPUnit_Db_DataSet_DbTableDataSet`. Il prend en paramètre un objet `Zend_Db_Table_Abstract` et l'ajoute au jeu de données avec le nom de la table, dans notre exemple : "zfbugs". Vous pourriez ajouter plus de données dans le jeu de données en utilisant `addTable()` plusieurs fois.

Ici nous ne possédons qu'une seule table et nous la comparons à un état défini dans "bugsDeleteAssertion.xml" qui est en fait le jeu de données original moins la données supprimée : celle ayant l'id 4.

Voyons maintenant comment vérifier que deux tables soient identiques (et non deux jeux de données correspondants à de telles tables). Ajoutons un test à notre scénario qui va vérifier la mise à jour de données.

    class BugsTest extends Zend_Test_PHPUnit_DatabaseTestCase
    {
        public function testBugUpdate()
        {
            $bugsTable = new Bugs();

            $data = array(
                'updated_on'      => '2007-05-23',
                'bug_status'      => 'FIXED'
            );

            $where = $bugsTable->getAdapter()->quoteInto('bug_id = ?', 1);

            $bugsTable->update($data, $where);

            $rowset = $bugsTable->fetchAll();

            $ds        = new Zend_Test_PHPUnit_Db_DataSet_DbRowset($rowset);
            $assertion = $this->createFlatXmlDataSet(
                dirname(__FILE__) . '/_files/bugsUpdateAssertion.xml'
            );
            $expectedRowsets = $assertion->getTable('zfbugs');

            $this->assertTablesEqual(
                $expectedRowsets, $ds
            );
        }
    }

Ici, nous récupérons l'état de la table depuis un objet `Zend_Db_Table_Rowset_Abstract` au moyen de `Zend_Test_PHPUnit_Db_DataSet_DbRowset($rowset)` qui crée une représentation de l'état interne des données du rowset. Nous comparons enfin cet état grâce à l'assertion `$this->assertTablesEqual()`