Abschnitt 17 · Lektion 4
Testbaren Code schreiben
Manche Funktionen wehren sich gegen jeden Test. Du setzt dich hin, willst die erste Behauptung schreiben und merkst, dass du an das Ergebnis gar nicht herankommst. Dann kannst du den Test aufwendiger machen oder den Code ändern. Das zweite hilft mehr.
Woran es liegt
<?php
declare(strict_types=1);
$db = new PDO("sqlite:" . __DIR__ . "/notizen.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("DROP TABLE IF EXISTS notizen");
$db->exec("CREATE TABLE notizen (titel TEXT NOT NULL)");
$db->exec("INSERT INTO notizen (titel) VALUES ('Milch'), ('Brot'), ('Zahnpasta')");
// Drei Dinge holt sich diese Funktion selbst, und jedes einzelne davon
// macht sie unpruefbar: die Verbindung, die Uhrzeit und den Weg nach
// draussen.
function bericht(): void
{
$db = new PDO("sqlite:" . __DIR__ . "/notizen.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$anzahl = (int) $db->query("SELECT count(*) FROM notizen")->fetchColumn();
echo "Bericht vom ", date("d.m.Y H:i:s"), ": ", $anzahl, " Notizen\n";
}
bericht();
// Eine Sekunde warten, damit der Unterschied sichtbar wird.
sleep(1);
bericht(); Die Funktion im ersten Beispiel tut drei Dinge, und jedes davon würde für sich schon reichen:
- Sie baut ihre Datenbankverbindung selbst auf. Ein Test müsste also eine Datenbank haben, sie
füllen und hinterher aufräumen. Das ist langsam, es hinterlässt Spuren, und zwei Tests
nebeneinander kommen sich in die Quere. Nach dem Lauf zeigt
lsdie Spur, nebenindex.phpliegt einenotizen.db, die vorher nicht da war. - Sie liest die Uhr. Zwischen den beiden Aufrufen im Beispiel liegt mit Absicht eine Sekunde, und schon unterscheiden sich die beiden Zeilen im Terminal. Ein Test kann nicht behaupten, was dort steht, weil es beim nächsten Lauf anders ist.
- Sie gibt selbst aus. Das Ergebnis geht direkt nach draußen, statt zurückzukommen. Vergleichen lässt es sich nicht, weil man es gar nicht in die Hand bekommt.
Hereingeben statt holen
<?php
declare(strict_types=1);
interface NotizSpeicher
{
/** @return list<string> */
public function alle(): array;
}
final class ArraySpeicher implements NotizSpeicher
{
/** @param list<string> $notizen */
public function __construct(private readonly array $notizen = [])
{
}
public function alle(): array
{
return $this->notizen;
}
}
// Speicher und Zeitpunkt kommen herein, das Ergebnis geht als Text
// zurueck. Woher beides im Betrieb kommt, weiss die Funktion nicht.
function begruessung(NotizSpeicher $speicher, DateTimeImmutable $zeitpunkt): string
{
$stunde = (int) $zeitpunkt->format("G");
$gruss = match (true) {
$stunde < 12 => "Guten Morgen",
$stunde < 18 => "Guten Tag",
default => "Guten Abend",
};
return $gruss . ", offene Notizen: " . count($speicher->alle());
}
echo begruessung(new ArraySpeicher(["Milch", "Brot", "Zahnpasta"]), new DateTimeImmutable("2026-03-02 07:30")), "\n";
echo begruessung(new ArraySpeicher(), new DateTimeImmutable("2026-03-02 13:15")), "\n";
echo begruessung(new ArraySpeicher(["Milch"]), new DateTimeImmutable("2026-03-02 21:45")), "\n"; Die Begrüßung im zweiten Beispiel braucht dieselben zwei Zutaten wie der Bericht oben, nämlich die Notizen und die Uhrzeit. Beide kommen als Parameter herein, und das Ergebnis kommt als Text zurück, statt ausgegeben zu werden. Die drei Aufrufe darunter geben bei jedem Lauf dieselben drei Zeilen aus, egal zu welcher Stunde.
DateTimeImmutable ist PHPs Klasse für einen Zeitpunkt. new DateTimeImmutable("2026-03-02 07:30")
legt einen fest, und ohne Argument bekommst du den jetzigen Moment. format() nimmt dieselben
Buchstaben wie date(). Das G im Beispiel ist die Stunde ohne führende Null.
Der Speicher ist das Interface NotizSpeicher aus dem Abschnitt über Objekte, gekürzt auf die eine
Methode, die hier gebraucht wird. begruessung() verlangt als Typ nur das Interface. Im Betrieb
steckt dahinter ein Speicher, der wirklich in die Datenbank schreibt, im Test ein ArraySpeicher,
der seine Notizen im Arbeitsspeicher hält. Für die Funktion ist beides dasselbe, und für den Test
muss sie nicht angepasst werden.
Mit der Uhr geht es genauso, denn ein Zeitpunkt ist ein Wert wie jeder andere. Ruft eine Funktion
date() mitten im Rumpf auf, hängt sie an der Wanduhr, und die kannst du von außen nicht
verstellen. Kommt der Zeitpunkt dagegen als Parameter, gibt der Test einfach den 24. Dezember herein
und muss nicht bis Weihnachten warten.
Der echte Zeitpunkt entsteht dann ganz oben, an der Stelle, an der die Anfrage ankommt. Dort steht
ein einziges new DateTimeImmutable(), und alles darunter rechnet mit dem Wert, den es bekommt.
Der Test mit einem Speicher im Arbeitsspeicher
{
"name": "hofladen/kasse",
"require-dev": {
"phpunit/phpunit": "^11"
},
"autoload": {
"psr-4": {
"App\\": "src/"
}
}
} <?xml version="1.0" encoding="UTF-8"?>
<phpunit bootstrap="vendor/autoload.php">
<testsuites>
<testsuite name="alle">
<directory>tests</directory>
</testsuite>
</testsuites>
</phpunit> <?php
declare(strict_types=1);
// Startet PHPUnit. Der Pruefen-Button startet immer eine PHP-Datei, also
// uebernimmt diese Zeile den Aufruf. Im Terminal brauchst du sie nicht,
// dort tippst du vendor/bin/phpunit direkt, wie auf deinem Rechner.
require __DIR__ . "/vendor/bin/phpunit"; <?php
declare(strict_types=1);
namespace App;
interface NotizSpeicher
{
/** @return list<string> */
public function alle(): array;
} <?php
declare(strict_types=1);
namespace App;
final class ArraySpeicher implements NotizSpeicher
{
/** @param list<string> $notizen */
public function __construct(private readonly array $notizen = [])
{
}
public function alle(): array
{
return $this->notizen;
}
} <?php
declare(strict_types=1);
namespace App;
final class Zaehler
{
// Der Speicher kommt herein. Welcher es ist, weiss diese Klasse nicht
// und muss sie nicht wissen.
public function __construct(private readonly NotizSpeicher $speicher)
{
}
public function kurzfassung(): string
{
$alle = $this->speicher->alle();
if ($alle === []) {
return "Noch keine Notizen";
}
return "Notizen: " . count($alle) . ", zuletzt: " . $alle[array_key_last($alle)];
}
} <?php
declare(strict_types=1);
use App\ArraySpeicher;
use App\Zaehler;
use PHPUnit\Framework\TestCase;
final class ZaehlerTest extends TestCase
{
public function testNenntAnzahlUndLetzteNotiz(): void
{
$zaehler = new Zaehler(new ArraySpeicher(["Milch", "Brot", "Zahnpasta"]));
$this->assertSame("Notizen: 3, zuletzt: Zahnpasta", $zaehler->kurzfassung());
}
public function testSagtEtwasBeiLeeremSpeicher(): void
{
$zaehler = new Zaehler(new ArraySpeicher());
$this->assertSame("Noch keine Notizen", $zaehler->kurzfassung());
}
} In einem Projekt steckt dieselbe Idee in einer Klasse. Zaehler bekommt seinen Speicher im
Konstruktor, merkt ihn sich und benutzt ihn. Im Test steht in derselben Zeile ein ArraySpeicher
mit drei erfundenen Notizen.
Der Test baut nichts auf und räumt nichts weg. Er braucht weder Datei noch Datenbank. Je Fall sind es zwei Zeilen, und der ganze Lauf dauert ein paar Millisekunden.
So ein Speicher, der nur für den Test da ist, heißt Attrappe, englisch test double oder fake. Er
ist eine echte Umsetzung des Interfaces, nur eben eine sehr einfache. Ein weiteres Werkzeug braucht
es dafür nicht. Mit Aufzeichnen im Reiter Debug siehst du, was die Klasse bekommt, wenn
src/Zaehler.php vorn liegt. In $this->speicher steht dann der ArraySpeicher samt seinen drei
erfundenen Notizen, beim zweiten Test ein leerer. Der Klasse selbst ist nicht anzusehen, dass es
keine Datenbank war.
Warum das den Code auch ohne Tests besser macht
Nimmt eine Klasse ihre Zutaten entgegen, steht schon in ihrem Konstruktor, wovon sie abhängt, und du musst nicht weiterlesen. Holt sie sich alles selbst, weißt du es erst, wenn du alle Methoden durchgegangen bist.
Der Zaehler arbeitet außerdem mit jedem Speicher, den es irgendwann geben wird, und niemand muss
ihn dafür anfassen. Andersherum gilt es auch. Fällt ein Test schwer, liegt das meistens an einem
Schnitt, der auch im Betrieb stört.
Nicht jede Kleinigkeit braucht dafür ein Interface. Bei Speichern und Uhren gibt es fast immer einen zweiten Fall, also eine Datenbank im Betrieb und eine Attrappe im Test oder eine Uhr, die läuft, und eine, die stillsteht. Eine Funktion, die zwei Zahlen addiert, hat keinen.
Der Bericht in der Aufgabe holt sich beides noch selbst, die Datenbank und die Uhr.
Zum Mitnehmen
Code, der seine Datenbank, die Uhrzeit oder den Weg nach draußen selbst holt, lässt sich kaum testen. Kommen Speicher und Zeitpunkt als Parameter herein und geht das Ergebnis als Rückgabewert hinaus, reicht im Test eine Attrappe wie der ArraySpeicher.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.