Abschnitt 17 · Lektion 3
Behauptungen
assertTrue($liste->suche("Milch") === "Milch holen") sieht nach einem ordentlichen Test aus. Reißt
er, steht im Bericht Failed asserting that false is true., und welche Notiz stattdessen herauskam,
darfst du selbst suchen. assertSame("Milch holen", $liste->suche("Milch")) schreibt sie gleich mit
hin, unter --- Expected und +++ Actual als -'Milch holen' und +'Milch kaufen'.
Jeder assert…-Aufruf in einem Test heißt Behauptung (englisch assertion). PHPUnit 11 bringt
160 solche Methoden mit. Im Alltag reicht eine Handvoll, wenn du weißt, welche wann passt.
assertSame ist der Normalfall
{
"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;
final class Korb
{
/** @var array<string, int> */
private array $waren = [];
public function lege(string $ware, int $menge): void
{
if ($menge < 1) {
throw new \InvalidArgumentException("Die Menge muss mindestens 1 sein.");
}
$this->waren[$ware] = ($this->waren[$ware] ?? 0) + $menge;
}
public function anzahl(): int
{
return array_sum($this->waren);
}
/** @return list<string> */
public function sorten(): array
{
return array_keys($this->waren);
}
public function menge(string $ware): ?int
{
return $this->waren[$ware] ?? null;
}
public function istLeer(): bool
{
return $this->waren === [];
}
public function beleg(): string
{
$zeilen = [];
foreach ($this->waren as $ware => $menge) {
$zeilen[] = $menge . " x " . $ware;
}
return implode(", ", $zeilen);
}
} <?php
declare(strict_types=1);
use App\Korb;
use PHPUnit\Framework\TestCase;
final class VergleichTest extends TestCase
{
private function korbMitBrot(): Korb
{
$korb = new Korb();
$korb->lege("Brot", 2);
return $korb;
}
public function testEqualsVergleichtLocker(): void
{
// anzahl() gibt eine ganze Zahl zurueck, hier steht ein Text.
// assertEquals vergleicht locker und ist zufrieden.
$this->assertEquals("2", $this->korbMitBrot()->anzahl());
}
public function testEqualsAuchBeiKommazahlen(): void
{
$this->assertEquals(2.0, $this->korbMitBrot()->anzahl());
}
public function testSameSiehtDenTyp(): void
{
// Dieselbe Behauptung wie oben, nur mit assertSame. Sie reisst
// mit Absicht.
$this->assertSame("2", $this->korbMitBrot()->anzahl());
}
public function testSameMitPassendemTyp(): void
{
$this->assertSame(2, $this->korbMitBrot()->anzahl());
}
} assertSame($erwartet, $tatsaechlich) vergleicht mit ===, also Wert und Typ. assertEquals()
vergleicht locker, ungefähr wie ==, und macht vorher passend, was sich passend machen lässt. Das
ist der Unterschied aus der Lektion „Vergleichen“ im Abschnitt über Rechnen und Text. Hier
entscheidet er über Grün und Rot.
anzahl() liefert im Beispiel die ganze Zahl 2. Die Erwartung "2" als Text geht bei
assertEquals durch, und 2.0 als Kommazahl auch. Bei assertSame reißt dieselbe Erwartung mit
Failed asserting that 2 is identical to '2'., also „2 ist nicht dasselbe wie der Text ‘2’“. Mit
vendor/bin/phpunit --filter Same laufen nur die Tests, die Same im Namen tragen, und in der
Fortschrittszeile steht dann F. statt ..F..
Ein Test mit assertEquals bliebe sogar dann grün, wenn anzahl() irgendwann einen Text statt
einer Zahl zurückgibt, und gerade so eine Änderung soll er ja melden.
Anders ist es bei Kommazahlen mit Nachkommastellen. Die kannst du nicht sinnvoll auf Gleichheit
prüfen, weil 0.1 + 0.2 nicht exakt 0.3 ist. assertSame(0.3, 0.1 + 0.2) reißt mit
0.30000000000000004. assertEqualsWithDelta($erwartet, $tatsaechlich, 0.001) lässt dafür einen
kleinen Spielraum. Wo der Code schon rundet, wie Rechnung in der Lektion davor, geht assertSame
weiterhin.
Eine Handvoll Behauptungen
{
"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;
final class Notizliste
{
/** @var list<string> */
private array $notizen = [];
public function notiere(string $text): void
{
if (trim($text) === "") {
throw new \InvalidArgumentException("Eine Notiz braucht einen Text.");
}
$this->notizen[] = $text;
}
/** @return list<string> */
public function alle(): array
{
return $this->notizen;
}
public function suche(string $wort): ?string
{
foreach ($this->notizen as $notiz) {
if (str_contains($notiz, $wort)) {
return $notiz;
}
}
return null;
}
public function istLeer(): bool
{
return $this->notizen === [];
}
public function text(): string
{
return implode(", ", $this->notizen);
}
} <?php
declare(strict_types=1);
use App\Notizliste;
use PHPUnit\Framework\TestCase;
final class NotizlisteTest extends TestCase
{
public function testEineFrischeListeIstLeer(): void
{
$this->assertTrue((new Notizliste())->istLeer());
}
public function testMitEinerNotizIstSieNichtMehrLeer(): void
{
$liste = new Notizliste();
$liste->notiere("Milch kaufen");
$this->assertFalse($liste->istLeer());
}
public function testZweiNotizenSindZweiEintraege(): void
{
$liste = new Notizliste();
$liste->notiere("Milch kaufen");
$liste->notiere("Zaun streichen");
$this->assertCount(2, $liste->alle());
}
public function testEineSucheOhneTrefferGibtNull(): void
{
$liste = new Notizliste();
$liste->notiere("Milch kaufen");
$this->assertNull($liste->suche("Kaffee"));
}
public function testDerTextNenntJedeNotiz(): void
{
$liste = new Notizliste();
$liste->notiere("Zaun streichen");
$this->assertStringContainsString("Zaun", $liste->text());
}
} Im Beispiel stehen fünf Tests mit fünf verschiedenen Behauptungen:
assertTrueundassertFalsefür alles, was schonboolist, wieistLeer(), und nie mit einem Vergleich darin.assertNullfür den Fall „gibt es nicht“. Der Bericht nennt dabei den Wert, der stattdessen kam, etwaFailed asserting that 'Milch kaufen' is null.assertCountfür Arrays. Die Meldung spricht dann von Größen,actual size 3 matches expected size 2, und das liest sich im Vorbeigehen leichter als3 is identical to 2ausassertSame(2, count(…)).assertStringContainsStringfür Text, bei dem nur ein Teil zählt, etwa ein Beleg, eine Fehlermeldung oder eine erzeugte Seite. Ein Test auf den vollen Wortlaut reißt, sobald jemand ein Komma verschiebt.
Bei den übrigen steht schon im Namen, was sie prüfen, etwa assertArrayHasKey oder
assertFileExists.
Eine Ausnahme prüfen
{
"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;
final class Notizliste
{
/** @var list<string> */
private array $notizen = [];
public function notiere(string $text): void
{
if (trim($text) === "") {
throw new \InvalidArgumentException("Eine Notiz braucht einen Text.");
}
$this->notizen[] = $text;
}
/** @return list<string> */
public function alle(): array
{
return $this->notizen;
}
public function suche(string $wort): ?string
{
foreach ($this->notizen as $notiz) {
if (str_contains($notiz, $wort)) {
return $notiz;
}
}
return null;
}
public function istLeer(): bool
{
return $this->notizen === [];
}
public function text(): string
{
return implode(", ", $this->notizen);
}
} <?php
declare(strict_types=1);
use App\Notizliste;
use PHPUnit\Framework\TestCase;
final class LeereNotizTest extends TestCase
{
public function testEineLeereNotizWirdAbgelehnt(): void
{
$liste = new Notizliste();
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage("braucht einen Text");
$liste->notiere(" ");
}
public function testHierKommtKeineAusnahme(): void
{
// Reisst mit Absicht: "Brot" ist eine gueltige Notiz, es wird also
// nichts geworfen, obwohl dieser Test es erwartet.
$liste = new Notizliste();
$this->expectException(InvalidArgumentException::class);
$liste->notiere("Brot");
}
public function testDieAnkuendigungKommtZuSpaet(): void
{
// Reisst ebenfalls mit Absicht: Die Ausnahme fliegt schon beim
// Aufruf, bis zur Ankuendigung darunter kommt der Test nie.
$liste = new Notizliste();
$liste->notiere("");
$this->expectException(InvalidArgumentException::class);
}
} Wirft eine Funktion im Fehlerfall, gibt sie nichts zurück, was eine Behauptung vergleichen könnte.
Für diesen Fall gibt es eine Ankündigung, $this->expectException(InvalidArgumentException::class).
Sie heißt so viel wie „im weiteren Verlauf dieses Tests wird eine solche Ausnahme geworfen“. Kommt
die Ausnahme, ist der Test bestanden. Im ersten Test des Beispiels prüft expectExceptionMessage()
zusätzlich ein Stück ihres Textes.
Der zweite erwartet eine Ausnahme, die nicht kommt, und reißt mit
Failed asserting that exception of type "InvalidArgumentException" is thrown.
Im dritten steht die Ankündigung unter dem Aufruf. Die Ankündigung gehört vor den Aufruf, denn
die Ausnahme fliegt schon dort, und bis zur Zeile darunter kommt der Test nie. PHPUnit meldet ihn
mit einem E als Fehler im Code und mit InvalidArgumentException: Eine Notiz braucht einen Text.,
und der ganze Lauf endet mit ERRORS! statt mit FAILURES!.
Mehrere Behauptungen in einem Test
Ich prüfe in einem Test eine Sache, weil PHPUnit dort bei der ersten gerissenen Behauptung aufhört. Stehen fünf in einer Methode, siehst du nur die erste und lässt danach noch einmal laufen. Stehen sie in fünf Methoden, siehst du auf einen Schlag, welche vier in Ordnung sind.
Zwei Behauptungen, die dieselbe Sache von zwei Seiten beschreiben, stehen trotzdem gut in einem Test, etwa die Zahl der Notizen und die erste davon.
Namen, die im Fehlerfall etwas sagen
Im Bericht steht der Methodenname über der Meldung, und oft ist er das Einzige, was man liest. Bei
testListe1 musst du erst die Datei öffnen. An testEineSucheOhneTrefferGibtNull siehst du schon
im Vorbeigehen, welche Regel verletzt ist. Ein guter Name nennt den Fall und das, was dabei
herauskommen soll. Lang darf er ruhig sein, denn von Hand ruft ihn niemand auf.
In der Aufgabe stehen fünf Fälle für einen Korb als Kommentar, und jeder bekommt seinen eigenen
Test.
Zum Mitnehmen
Eine Behauptung vergleicht, was herauskam, mit dem, was herauskommen soll, und assertSame tut es wie === samt Typ. Eine erwartete Ausnahme kündigt expectException an, und zwar vor dem Aufruf, der sie wirft.
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.