<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 24249 -->
<!-- Reviewed: no -->
<sect2 id="zend.test.phpunit.db.quickstart">
    <title>Quickstart</title>

    <sect3 id="zend.test.phpunit.db.quickstart.testcase">
        <title>Einen Datenbank TestCase erstellen</title>

        <para>
            Wir schreiben jetzt einige Datenbank Tests für das Bug Datenbank Beispiel in der
            Dokumentation von <classname>Zend_Db_Table</classname>. 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
            <classname>Zend_Test_PHPUnit_DatabaseTestCase</classname> erweitert. Diese Klasse
            erweitert die Datenbank Erweiterung von PHPUnit, welche Ihrerseits den standardmäßigen
            Basis <classname>PHPUnit_Framework_TestCase</classname> 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.
        </para>

        <note>
            <para>
                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.
            </para>
        </note>

        <programlisting language="php"><![CDATA[
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'
        );
    }
}
]]></programlisting>

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

        <itemizedlist>
            <listitem>
                <para>
                    Man kann ein <classname>Zend_Db_Adapter_Abstract</classname> nicht direkt von
                    der <methodname>getConnection()</methodname> Methode erhalten, aber einen
                    PHPUnit spezifischen Wrapper welcher mit der Methode
                    <methodname>createZendDbConnection()</methodname> erstellt wird.
                </para>
            </listitem>

            <listitem>
                <para>
                    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.
                </para>
            </listitem>

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

            <listitem>
                <para>
                    DataSets müssen das Interface
                    <classname>PHPUnit_Extensions_Database_DataSet_IDataSet</classname>
                    implementieren. Es gibt eine Vielzahl an Typen von <acronym>XML</acronym> 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.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3 id="zend.test.phpunit.db.quickstart.dataset">
        <title>Einen Seed Datensatz spezifizieren</title>

        <para>
            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 <acronym>XML</acronym> Format:
        </para>

        <programlisting language="xml"><![CDATA[
<?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>
]]></programlisting>

        <para>
            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:
        </para>

        <programlisting language="sql"><![CDATA[
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 ;
]]></programlisting>
    </sect3>

    <sect3 id="zend.test.phpunit.db.quickstart.initial-tests">
        <title>Einige initiale Datenbank Tests</title>

        <para>
            Jetzt, da wie die zwei benötigten Abstrakten Methoden von
            <classname>Zend_Test_PHPUnit_DatabaseTestCase</classname> 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.
        </para>

        <programlisting language="php"><![CDATA[
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
        );
    }
}
]]></programlisting>

        <para>
            Jetzt sieht ab <methodname>$bugsTable->insert($data);</methodname> 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
            <classname>Zend_Test_PHPUnit_Db_DataSet_QueryDataSet</classname> und geben Ihr eine
            Datenbank Verbindung an. Dann sagen wir diesem Datenbank das er eine Tabelle "zfbugs"
            enthält welche durch ein <acronym>SQL</acronym> Statement angegeben wird. Der aktuelle
            Status der Datenbank wird mit dem erwarteten Datenbank Status vergleichen der in der
            anderen <acronym>XML</acronym> Datei "bugsInsertIntoAssertions.xml" enthalten ist.
            Diese <acronym>XML</acronym> Datei ist eine leichte Abwandlung von der oben angegeben,
            und enthält eine weitere Zeile mit den erwarteten Daten:
        </para>

        <programlisting language="xml"><![CDATA[
<?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>
]]></programlisting>

        <para>
            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:
        </para>

        <programlisting language="php"><![CDATA[
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
        );
    }
}
]]></programlisting>

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

        <para>
            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.
        </para>

        <para>
            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.
        </para>

        <programlisting language="php"><![CDATA[
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
        );
    }
}
]]></programlisting>

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