Vamos ahora a escribir algunas pruebas de base de datos para el ejemplo de la base de datos de errores (Bug Database) de la documentación de Zend_Db_Table. Primero empezamos comprobando que al insertar un nuevo bug este se guarda correctamente en la base de datos. Primero tenemos que configurar una clase de prueba que extienda Zend_Test_PHPUnit_DatabaseTestCase. Esta clase extiende la extensión Database de PHPUnit, la cual a su vez extiende la clase básica PHPUnit_Framework_TestCase. Un testcase de base de datos contiene dos métodos abstractos que deben implementarse, uno para la conexión a la base de datos y otro para el dataset inicial que debe usarse como semilla o fixture.

	Nota
	Debería estar familiarizado con la extensión Database de PHPUnit para seguir este inicio rápido con facilidad. Aunque todos los conceptos se explican en esta documentación, puede resultar útil leer primero la documentación de PHPUnit.

class BugsTest extends Zend_Test_PHPUnit_DatabaseTestCase
{
    private $_connectionMock;

    /**
     * Returns the test database connection.
     *
     * @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'
        );
    }
}

Aquí creamos la conexión a la base de datos e insertamos algunos datos semilla en la base de datos. Es importante prestar atención a algunos detalles de este código:

En la configuración anterior del testcase de base de datos hemos especificado un archivo semilla para el fixture de base de datos. Ahora creamos este archivo especificado en formato Flat 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>

Trabajaremos con estas cuatro entradas en la tabla de base de datos "zfbugs" en los siguientes ejemplos. El esquema MySQL necesario para este ejemplo es:

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 ;

Ahora que hemos implementado los dos métodos abstractos requeridos por Zend_Test_PHPUnit_DatabaseTestCase y especificado el contenido de la base de datos semilla, que se volverá a crear para cada nueva prueba, podemos pasar a hacer nuestra primera aserción. Esta será una prueba para insertar un nuevo 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
        );
    }
}

Hasta $bugsTable->insert($data); todo resulta familiar. Las líneas siguientes contienen el nombre del método de aserción. Queremos verificar que, después de insertar el nuevo bug, la base de datos se ha actualizado correctamente con los datos indicados. Para ello creamos una instancia de Zend_Test_PHPUnit_Db_DataSet_QueryDataSet y le proporcionamos una conexión a la base de datos. A continuación le indicaremos a este dataset que contiene una tabla "zfbugs" que viene dada por una sentencia SQL. Este estado actual/real de la base de datos se compara con el estado esperado de la base de datos, contenido en otro archivo XML "bugsInsertIntoAssertions.xml". Este archivo XML es una ligera variación del mostrado anteriormente y contiene otra fila con los datos esperados:

<?xml version="1.0" encoding="UTF-8" ?>
<dataset>
    <!-- previous 4 rows -->
    <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>

Existen otras formas de comprobar que el estado actual de la base de datos es igual a un estado esperado. La tabla "Bugs" del ejemplo ya conoce mucho sobre su estado interno, así que ¿por qué no aprovecharlo? El siguiente ejemplo comprobará que es posible eliminar de la base de datos:

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
        );
    }
}

Aquí hemos creado un dataset Zend_Test_PHPUnit_Db_DataSet_DbTableDataSet, que toma cualquier instancia de Zend_Db_Table_Abstract y la añade al dataset con su nombre de tabla, en este ejemplo "zfbugs". Podría añadir varias tablas más si quisiera usando el método addTable(), en caso de querer comprobar el estado esperado de la base de datos en más de una tabla.

Aquí solo tenemos una tabla y comprobamos frente a un estado esperado de la base de datos en "bugsDeleteAssertion.xml", que es el dataset semilla original sin la fila con id 4.

Dado que en los ejemplos anteriores solo hemos comprobado que dos tablas específicas (no datasets) son iguales, también deberíamos ver cómo afirmar que dos tablas son iguales. Por ello, añadiremos otra prueba a nuestro TestCase que verifique el comportamiento de actualización de un dataset.

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
        );
    }
}

Aquí creamos el estado actual de la base de datos a partir de una instancia de Zend_Db_Table_Rowset_Abstract junto con la instancia Zend_Test_PHPUnit_Db_DataSet_DbRowset($rowset), que crea una representación interna de datos del rowset. Esto se puede comparar de nuevo con otra tabla de datos usando la aserción $this->assertTablesEqual().

La clase Zend_Test_PHPUnit_DatabaseTestCase deriva de PHPUnit_Extensions_Database_TestCase, que permite configurar pruebas con un fixture de base de datos nuevo en cada ejecución de forma sencilla. La implementación de Zend ofrece algunas funciones adicionales de conveniencia respecto a la extensión Database de PHPUnit a la hora de usar recursos de Zend_Db dentro de las pruebas. El flujo de trabajo de un testcase de base de datos puede describirse de la siguiente manera.

	Nota
	El Database TestCase espera que el esquema de la base de datos y las tablas estén configurados correctamente para ejecutar las pruebas. No existe ningún mecanismo para crear ni eliminar tablas de base de datos.

La clase Zend_Test_PHPUnit_DatabaseTestCase dispone de algunas funciones de conveniencia que pueden ayudar a escribir pruebas que interactúan con la base de datos y con la extensión de pruebas de base de datos.

La siguiente tabla enumera únicamente los métodos nuevos en comparación con PHPUnit_Extensions_Database_TestCase, cuya API está documentada en la documentación de PHPUnit.

Dado que PHP no admite herencia múltiple, no es posible usar los testcases de Controller y de Database de forma conjunta. Sin embargo, puede usar el database tester Zend_Test_PHPUnit_Db_SimpleTester en su testcase de controlador para configurar un fixture del entorno de base de datos en cada nueva prueba de controlador. El Database TestCase en general no es más que un conjunto de funciones de conveniencia a las que también se puede acceder y utilizar sin el testcase.

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);
    }
}