Wir schreiben jetzt einige Datenbank Tests für das Bug Datenbank Beispiel in der Dokumentation von Zend_Db_Table. Zuerst beginnen wir zu Testen ob ein neuer Bug der eingefügt wird, in der Datenbank auch wirklich korrekt abgespeichert wird. Zuerst müssen wir eine Test-Klasse erstellen die Zend_Test_PHPUnit_DatabaseTestCase erweitert. Diese Klasse erweitert die Datenbank Erweiterung von PHPUnit, welche Ihrerseits den standardmäßigen Basis PHPUnit_Framework_TestCase erweitert. Ein Datenbank Testcase enthält zwei abstrakte Methoden die implementiert werden müssen, eine für die Datenbank Verbindung und eine für das initiale Datenset das als Seed oder Fixum verwendet werden soll.

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

Hier erstellen wir die Datenbankverbindung und setzt einige Daten in die Datenbank. Einige wichtige Details über diesen Code sollten notiert werden:

Im vorhergehenden Setup für den Datenbank Testcase haben wir eine Seed Datei für das Datenbank Fixum spezifiziert. Jetzt erstellen wir diese Datei im spezifizierten Flat XML Format:

<?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>

Wir arbeiten mit diesen vier Einträgen, der Datenbank Tabelle "zfbugs", im nächsten Beispiel. Das benötigte MySQL Schema für dieses Beispiel ist:

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 ;

Jetzt, da wie die zwei benötigten Abstrakten Methoden von Zend_Test_PHPUnit_DatabaseTestCase implementiert, und den Datenbank Inhalt des Seeds spezifiziert haben, der für jeden neuen Test wieder erzeugt wird, können wir dazu übergehen unsere erste Annahme zu treffen. Das wird ein Test um einen neuen Fehler einzufügen.

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

Jetzt sieht ab $bugsTable->insert($data); alles wie gewohnt aus. Die Zeilen danach enthalten den Assertion Methodennamen. Wir wollen prüfen ob, nach dem Einfügen des neuen Fehlers, die Datenbank richtig mit den angegebenen Daten aktualisiert wurde. Hierfür erstellen wir eine Instanz von Zend_Test_PHPUnit_Db_DataSet_QueryDataSet und geben Ihr eine Datenbank Verbindung an. Dann sagen wir diesem Datenbank das er eine Tabelle "zfbugs" enthält welche durch ein SQL Statement angegeben wird. Der aktuelle Status der Datenbank wird mit dem erwarteten Datenbank Status vergleichen der in der anderen XML Datei "bugsInsertIntoAssertions.xml" enthalten ist. Diese XML Datei ist eine leichte Abwandlung von der oben angegeben, und enthält eine weitere Zeile mit den erwarteten Daten:

<?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>

Es gibt andere Wege um anzunehmen das der aktuelle Datenbank Status mit dem erwarteten Status gleich ist. Die Tabelle "Bugs" im Beispiel weiss bereits eine Menge über Ihren internen Status, warum dass also nicht zu unserem Vorteil nutzen? Das nächste Beispiel nimmt an dass das Löschen von der Datenbank möglich ist:

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

Wir haben hier ein Datenset Zend_Test_PHPUnit_Db_DataSet_DbTableDataSet erstellt, welches irgendweine Instanz von Zend_Db_Table_Abstract nimmt, und diese im Datenset mit Ihrem Tabellennamen hinzufügt, in diesem Beispiel "zfbugs". Man könnte mehrere Tabellen hinzufügen, indem die Methode addTable() verwendet wird, wenn man auf erwartete Datenbank Stati in mehr als einer Tabelle prüfen will.

Hier haben wir nur eine Tabelle und prüfen auf den erwarteten Datenbank Status in "bugsDeleteAssertion.xml", welcher der originale Seed Datensatz ohne die Zeile mit der Id 4 ist.

Da wir im vorhergehenden Beispiel nur geprüft haben ob die zwei spezifischen Tabellen (nicht Datensätze) identisch sind, sollten wir uns auch anschauen wie man annehmen kann dass zwei Tabellen identisch sind. Hierfür fügen wir einen weiteren Test in unseren TestCase hinzu, der das Verhalten beim Aktualisieren eines Datensets prüft.

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

Hier haben wir den aktuellen Datenbank Status aus der Instanz eines Zend_Db_Table_Rowset_Abstract, in Verbindung mit der Instanz von Zend_Test_PHPUnit_Db_DataSet_DbRowset($rowset) erstellt, welche eine interne Daten-Repräsentation des Datensatzes erstellt. Das kann wiederum gegenüber anderen Daten-Tabellen verglichen werden indem die Annahme $this->assertTablesEqual() verwendet wird.

Die Klasse Zend_Test_PHPUnit_DatabaseTestCase ist von PHPUnit_Extensions_Database_TestCase abgeleitet welche es erlaubt Tests mit einer frischen und fixen Datenbank einfach für jeden Lauf zu erstellen. Die Implementation von Zend bietet einige bequeme zusätzliche Features über die Database Erweiterung von PHPUnit wenn es zur Verwendung von Zend_Db in den eigenen Tests kommt. Der Workflow eines Datenbank TestCases kann wie folgt beschrieben werden.

Die Klasse Zend_Test_PHPUnit_DatabaseTestCase hat einige bequeme Funktionen die dabei helfen können Tests zu schreiben die mit der Datenbank und der Datenbank Testerweiterung zu interagieren.

Die nächste Tabelle listet nur die neuen Methoden verglichen mit PHPUnit_Extensions_Database_TestCase auf, dessen API in der Dokumentation von PHPUnit dokumentiert ist.

Weil PHP die mehrfache Vererbung nicht unterstützt ist es nicht möglich die Controller und Datenbank Testcases in Verbindung zu verwenden. Trotzdem kann man den Zend_Test_PHPUnit_Db_SimpleTester Datenbank Tester im eigenen Controller Testcase verwenden um eine fixe Datenbankumgebung für jeden neuen Controller Test zu erstellen. Der Datenbank TestCase ist generell nur ein Set von bequemen Funktionen auf die auch zugegriffen und die auch ohne die TestCases verwendet werden können.

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