Beispiele
Zu wissen wir man die eigene Infrastruktur für Tests einstellt und wir Ausnahmen zu
erstellen sind ist nur der halbe Kampf; jetzt ist es Zeit auf einige Testszenarien zu
schauen und zu eruieren wie diese verwendet werden können.
Den UserController testen
Nehmen wir einen standard Task für eine Webseite an: Authentifizierung und Registrierung
von Benutzern. In unserem Beispiel definieren wir einen UserController um das zu
behandeln, und haben die folgenden Notwendigkeiten:
Wenn ein Benutzer nicht authentifiziert ist, wird er immer zur Login Seite des
Controllers umgeleitet, unabhängig von der spezifizierten Aktion.
Die Login Formularseite wird beides zeigen, das Login Formular und das Registrations
Formular.
Die angabe von ungültigen Anmeldedaten sollte in der Rückgabe des Login Formulars
resultieren.
Das Ansehen der Anmeldedaten sollte in einer Umleitung zur Profilseite des Benutzers
resultieren.
Die Profilseite sollte verändert werden um den Benutzernamen des Benutzers zu
enthalten.
Authentifizierte Benutzer welche die Loginseite besuchen sollten zu Ihrer
Profilseite umgeleitet werden.
Bei der Abmeldung, sollten ein Benutzer zur Loginseite umgeleitet werden.
Mit ungültigen Daten sollte die Registrierung fehlschlagen.
Wir können, und sollten zusätzliche Tests definieren, aber diese reichen für jetzt.
Für unsere Anwendung definieren wir ein Plugin, 'Initialisieren' es, damit es bei
routeStartup() läuft. Das erlaubt es uns das Bootstrapping in
einem OOP Interface zu kapseln, was auch einen einfachen Weg bietet um ein Callback zu
ermöglichen. Schauen wir uns erstmals die Basics dieser Klasse an:
_setEnv($env);
if (null === $root) {
$root = realpath(dirname(__FILE__) . '/../../../');
}
$this->_root = $root;
$this->initPhpConfig();
$this->_front = Zend_Controller_Front::getInstance();
}
/**
* Route beginnen
*
* @return void
*/
public function routeStartup(Zend_Controller_Request_Abstract $request)
{
$this->initDb();
$this->initHelpers();
$this->initView();
$this->initPlugins();
$this->initRoutes();
$this->initControllers();
}
// Die Definition von Methoden würde hier folgen...
}
]]>
Das erlaubt es uns einen Bootstrap Callback wie folgt zu erstellen:
getFrontController();
$controller->registerPlugin(
new Bugapp_Plugin_Initialize('development')
);
}
public function setUp()
{
$this->bootstrap = array($this, 'appBootstrap');
parent::setUp();
}
// ...
}
]]>
Sobald das fertig ist, können wir unsere Tests schreiben. Trotzdem, was ist mit den
Tests die erfordern das der Benutzer angemeldet ist? Die einfache Lösung besteht darin
das unsere Anwendungslogik das macht... und ein bischen trickst indem die
resetRequest() und resetResponse()
Methoden verwendet werden, die es uns erlauben eine andere Anfrage abzusetzen.
request->setMethod('POST')
->setPost(array(
'username' => $user,
'password' => $password,
));
$this->dispatch('/user/login');
$this->assertRedirectTo('/user/view');
$this->resetRequest()
->resetResponse();
$this->request->setPost(array());
// ...
}
// ...
}
]]>
Jetzt schreiben wir Tests:
dispatch('/user');
$this->assertController('user');
$this->assertAction('index');
}
public function testLoginFormShouldContainLoginAndRegistrationForms()
{
$this->dispatch('/user');
$this->assertQueryCount('form', 2);
}
public function testInvalidCredentialsShouldResultInRedisplayOfLoginForm()
{
$request = $this->getRequest();
$request->setMethod('POST')
->setPost(array(
'username' => 'bogus',
'password' => 'reallyReallyBogus',
));
$this->dispatch('/user/login');
$this->assertNotRedirect();
$this->assertQuery('form');
}
public function testValidLoginShouldRedirectToProfilePage()
{
$this->loginUser('foobar', 'foobar');
}
public function testAuthenticatedUserShouldHaveCustomizedProfilePage()
{
$this->loginUser('foobar', 'foobar');
$this->request->setMethod('GET');
$this->dispatch('/user/view');
$this->assertNotRedirect();
$this->assertQueryContentContains('h2', 'foobar');
}
public function
testAuthenticatedUsersShouldBeRedirectedToProfileWhenVisitingLogin()
{
$this->loginUser('foobar', 'foobar');
$this->request->setMethod('GET');
$this->dispatch('/user');
$this->assertRedirectTo('/user/view');
}
public function testUserShouldRedirectToLoginPageOnLogout()
{
$this->loginUser('foobar', 'foobar');
$this->request->setMethod('GET');
$this->dispatch('/user/logout');
$this->assertRedirectTo('/user');
}
public function testRegistrationShouldFailWithInvalidData()
{
$data = array(
'username' => 'This will not work',
'email' => 'this is an invalid email',
'password' => 'Th1s!s!nv@l1d',
'passwordVerification' => 'wrong!',
);
$request = $this->getRequest();
$request->setMethod('POST')
->setPost($data);
$this->dispatch('/user/register');
$this->assertNotRedirect();
$this->assertQuery('form .errors');
}
}
]]>
Es ist zu beachten das die Tests knapp sind und, für die meisten von Ihnen, nicht den
aktuellen Inhalt berücksichtigen. Stattdessen sehen Sie nach Teilen in der Anfrage --
Anfrage Codes und Header sowie DOM Knoten. Das erlaubt es schnell zu prüfen das die
Strukturen wie erwartet sind -- und verhinter das die Tests jedesmal wenn der Site neue
Inhalte hinzugefügt werden darin ersticken.
Es ist auch zu beachten das wir die Struktur des Dokuments in unseren Tests verwenden.
Zum Beispiel schauen wir im letzten Test nach einer Form die einen Node mit der Klasse
"errors" hat; das erlaubt es uns lediglich nach dem Vorhandensein von
Form-Prüfungsfehlern zu testen, und uns keine Sorgen darüber zu machen warum spezielle
Fehler überhaupt geworfen werden.
Diese Anwendung könnte eine Datenbank verwenden. Wenn dem so ist,
muß man warscheinlich einige Grundlagen ändern um sicherzustellen das die Datenbank am
Anfang jeden Tests, in einer unverfälschten, testbaren Konfiguration ist. PHPUnit bietet
bereits Funktionalität um das sicherzustellen; Lesen Sie darüber in
der PHPUnit Dokumentation nach. Wir empfehlen eine separate Datenbank für das
Testen zu verwenden statt der Produktionsdatenbank, und entweder eine SQLite Datei oder
eine Datenbank im Speicher zu verwenden, da beide Optionen sehr performant sind, keinen
separaten Server benötigen, und die meisten SQL Syntax verwenden
können.