Cum eșuează un test
Fiecare verificare din un test PHPUnit este o aserțiune — assertSame, assertTrue, assertCount și multe altele. Ce se întâmplă după un eșec decide cum îți structurezi testul:
O aserțiune eșuată oprește imediat metoda de test în care se află — liniile de după ea nu mai rulează niciodată. Celelalte metode de test ale clasei nu sunt afectate: fiecare rulează și eșuează pe cont propriu.
Asta îți dă două instrumente. Pune verificările independente în metode separate, ca fiecare verificare greșită să fie raportată. Pune verificările dependente una după alta în aceeași metodă, ca testul să eșueze rapid la primul pas greșit.
Raportează tot: metode separate
Când mai multe cazuri trebuie verificate într-o singură rulare, dă fiecăruia propria metodă de test. Un caz greșit face să eșueze doar metoda lui — celelalte metode rulează în continuare și fiecare eșec este listat.
Astfel, o singură rulare PHPUnit îți arată toate problemele — nu doar primul caz greșit.
Vezi toate cazurile greșite dintr-o dată
Acest add ignoră $b, așa că toate cele trei verificări eșuează. Deoarece fiecare verificare este propria metodă de test, toate cele trei mesaje de eșec apar într-o singură rulare — într-o singură metodă ai vedea doar primul.
Ieșire: script PHP
<?php
use PHPUnit\Framework\TestCase;
// add are o eroare: ignoră $b.
function add(int $a, int $b): int {
return $a;
}
final class AddTest extends TestCase {
public function testAddTwoAndTwo(): void {
$this->assertSame(4, add(2, 2));
}
public function testAddTwoAndThree(): void {
$this->assertSame(5, add(2, 3));
}
public function testAddTenAndOne(): void {
$this->assertSame(11, add(10, 1));
}
}
Eșec rapid: aserțiuni una după alta
Uneori, o verificare eșuată înseamnă că restul testului nu mai poate funcționa. Un caz tipic: testul pregătește mai întâi o valoare, apoi o inspectează. Dacă pregătirea a mers deja prost, inspectarea ar fi inutilă sau ar duce chiar la o eroare.
Aserțiunile puse una după alta în aceeași metodă fac exact asta: primul eșec oprește metoda chiar acolo. Verificările de după el nu mai rulează niciodată — și tocmai acesta este scopul.
Oprește-te înainte de verificările inutile
splitWords are o eroare (împarte după caracterul greșit), așa că se întoarce 1 parte în loc de 3. assertCount o raportează și oprește metoda — verificarea primei părți, de mai jos, nu este atinsă niciodată. Rezumatul o dovedește: Assertions: 1, a rulat o singură aserțiune.
Ieșire: script PHP
<?php
use PHPUnit\Framework\TestCase;
// splitWords are o eroare: împarte după ";" în loc de ",".
function splitWords(string $s): array {
return explode(";", $s);
}
final class SplitTest extends TestCase {
public function testSplit(): void {
$parts = splitWords("one,two,three");
$this->assertCount(3, $parts);
// Nu este atinsă niciodată cât timp eroarea există.
$this->assertSame("one", $parts[0]);
}
}
Mesaje la aserțiuni
Fiecare aserțiune acceptă un ultim argument opțional: un mesaj simplu care este afișat numai când verificarea eșuează. $this->assertTrue(isEven(4), "4 should be even") rămâne silențios cât timp verificarea trece și se explică atunci când nu trece.
Mesaje simple
Două verificări booleene cu mesaje simple. Ambele trec aici, așa că mesajele rămân silențioase și rularea afișează OK (1 test, 2 assertions).
Ieșire: script PHP
<?php
use PHPUnit\Framework\TestCase;
function isEven(int $n): bool {
return $n % 2 === 0;
}
final class IsEvenTest extends TestCase {
public function testIsEven(): void {
$this->assertTrue(isEven(4), "4 ar trebui să fie par");
$this->assertFalse(isEven(3), "3 nu ar trebui să fie par");
}
}