# Quickstart

## Einen Datenbank TestCase erstellen

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.

Man sollte mit der PHPUnit Datenbank Erweiterung vertraut sein um diesem Quickstart einfach folgen zu können. Auch wenn diese Konzepte in dieser Dokumentation beschrieben werden, kann es hilfreich sein zuerst die Dokumentation von PHPUnit zu lesen.

    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:

- Man kann ein `Zend_Db_Adapter_Abstract` nicht direkt von der `getConnection()` Methode erhalten, aber einen PHPUnit spezifischen Wrapper welcher mit der Methode `createZendDbConnection()` erstellt wird.

- Das Datenbank Schema (Tabellen und Datenbank) wird nicht bei jedem Testlauf wieder erstellt. Die Datenbank und die Tabellen müssen manuell erstellt werden bevor die Tests aufgeführt werden.

- Datenbank Tests schneiden standardmäßig die Daten während `setUp()` ab und fügen anschließend die Seed Daten ein, welche von der Methode `getDataSet()` zurückgegeben werden.

- DataSets müssen das Interface `PHPUnit_Extensions_Database_DataSet_IDataSet` implementieren. Es gibt eine Vielzahl an Typen von XML und YAML Konfigurationsdateien die in PHPUnit enthalten sind, welche es erlauben zu spezifizieren wie Tabellen und Datensätze auszusehen haben und man sollte in die Dokumentation von PHPUnit schauen um die aktuellsten Informationen über die Spezifikation diese Datensets zu erhalten.

## Einen Seed Datensatz spezifizieren

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 ;

## Einige initiale Datenbank Tests

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.