Afirmații
Afirmațiile sunt utilizate pentru a afirma că o valoare reală corespunde unei valori așteptate. Acestea sunt
metode ale aplicației Tester\Assert
.
Alegeți cele mai exacte aserțiuni. Este mai bună Assert::same($a, $b)
decât
Assert::true($a === $b)
, deoarece afișează un mesaj de eroare semnificativ în caz de eșec. În cel de-al doilea
caz, obținem doar false should be true
și nu spune nimic despre conținutul variabilelor $a și $b.
Cele mai multe aserțiuni pot avea, de asemenea, un $description
opțional care apare în mesajul de eroare în
cazul în care așteptarea eșuează.
Exemplele presupun că este definit următorul alias de clasă:
use Tester\Assert;
Assert::same ($expected, $actual, string $description=null)
$expected
trebuie să fie aceeași cu $actual
. Este același lucru cu operatorul PHP
===
.
Assert::notSame ($expected, $actual, string $description=null)
Opusul lui Assert::same()
, deci este același lucru cu operatorul PHP !==
.
Assert::equal ($expected, $actual, string $description=null, bool $matchOrder=false, bool $matchIdentity=false)
$expected
trebuie să fie același cu $actual
. Spre deosebire de Assert::same()
,
identitatea obiectului, ordinea perechilor cheie ⇒ valoare în array-uri și numerele zecimale marginal diferite sunt ignorate,
care pot fi modificate prin setarea $matchIdentity
și $matchOrder
.
Următoarele cazuri sunt identice din punctul de vedere al equal()
, dar nu și pentru same()
:
Assert::equal(0.3, 0.1 + 0.2);
Assert::equal($obj, clone $obj);
Assert::equal(
['first' => 11, 'second' => 22],
['second' => 22, 'first' => 11],
);
Cu toate acestea, atenție, matricea [1, 2]
și [2, 1]
nu sunt egale, deoarece doar ordinea valorilor
diferă, nu și perechile cheie ⇒ valoare. Tabloul [1, 2]
poate fi scris și sub forma
[0 => 1, 1 => 2]
și deci [1 => 2, 0 => 1]
va fi considerat egal.
Puteți utiliza, de asemenea, așa-numitele așteptări în $expected
.
Assert::notEqual ($expected, $actual, string $description=null)
Opusul lui Assert::equal()
.
Assert::contains ($needle, string|array $actual, string $description=null)
Dacă $actual
este un șir de caractere, acesta trebuie să conțină subșirul $needle
. Dacă este
o matrice, trebuie să conțină elementul $needle
(acesta este comparat strict).
Assert::notContains ($needle, string|array $actual, string $description=null)
Opusul lui Assert::contains()
.
Assert::hasKey (string|int $needle, array $actual, string $description=null)
$actual
trebuie să fie o matrice și să conțină cheia $needle
.
Assert::notHasKey (string|int $needle, array $actual, string $description=null)
$actual
trebuie să fie o matrice și să nu conțină cheia $needle
.
Assert::true ($value, string $description=null)
$value
trebuie să fie true
, deci $value === true
.
Assert::truthy ($value, string $description=null)
$value
trebuie să fie adevărat, deci satisface condiția if ($value) ...
.
Assert::false ($value, string $description=null)
$value
trebuie să fie false
, deci $value === false
.
Assert::falsey ($value, string $description=null)
$value
trebuie să fie falsey, deci îndeplinește condiția if (!$value) ...
.
Assert::null ($value, string $description=null)
$value
trebuie să fie null
, deci $value === null
.
Assert::notNull ($value, string $description=null)
$value
nu trebuie să fie null
, deci $value !== null
.
Assert::nan ($value, string $description=null)
$value
trebuie să nu fie un număr. Utilizați numai Assert::nan()
pentru testarea NAN. Valoarea NAN
este foarte specifică, iar afirmațiile Assert::same()
sau Assert::equal()
se pot comporta în mod
imprevizibil.
Assert::count ($count, Countable|array $value, string $description=null)
Numărul de elemente din $value
trebuie să fie $count
. Deci la fel ca
count($value) === $count
.
Assert::type (string|object $type, $value, string $description=null)
$value
trebuie să fie de un anumit tip. La fel ca $type
putem folosi string:
array
list
– matrice indexată în ordine crescătoare a cheilor numerice de la zero.bool
callable
float
int
null
object
resource
scalar
string
- numele clasei sau obiectul direct, atunci trebuie să treacă
$value instanceof $type
Assert::exception (callable $callable, string $class, string $message=null, $code=null)
La invocarea $callable
trebuie să se arunce o excepție de instanță $class
. Dacă se trece
$message
, mesajul excepției trebuie să corespundă. Iar dacă se trece
$code
, codul excepției trebuie să fie același.
De exemplu, acest test eșuează deoarece mesajul excepției nu se potrivește:
Assert::exception(
fn() => throw new App\InvalidValueException('Zero value'),
App\InvalidValueException::class,
'Value is to low',
);
Site-ul Assert::exception()
returnează o excepție lansată, astfel încât puteți testa o excepție
imbricata.
$e = Assert::exception(
fn() => throw new MyException('Something is wrong', 0, new RuntimeException),
MyException::class,
'Something is wrong',
);
Assert::type(RuntimeException::class, $e->getPrevious());
Assert::error (string $callable, int|string|array $type, string $message=null)
Verifică dacă invocarea $callable
generează erorile așteptate (adică avertismente, notificări etc.). Ca
$type
se specifică una dintre constantele E_...
, de exemplu E_WARNING
. Iar dacă se trece
$message
, mesajul de eroare trebuie să corespundă și el modelului. De exemplu:
Assert::error(
fn() => $i++,
E_NOTICE,
'Undefined variable: i',
);
Dacă callback-ul generează mai multe erori, trebuie să le așteptăm pe toate în ordinea exactă. În acest caz, trecem
matricea în $type
:
Assert::error(function () {
$a++;
$b++;
}, [
[E_NOTICE, 'Undefined variable: a'],
[E_NOTICE, 'Undefined variable: b'],
]);
Dacă $type
este numele clasei, această afirmație se comportă la fel ca
Assert::exception()
.
Assert::noError (callable $callable)
Verifică dacă funcția $callable
nu aruncă niciun avertisment/notificare/error sau excepție PHP. Este utilă
pentru testarea unei bucăți de cod în care nu există nicio altă afirmație.
Assert::match (string $pattern, $actual, string $description=null)
$actual
trebuie să se potrivească cu $pattern
. Putem utiliza două variante de tipare: expresii
regulate sau caractere sălbatice.
Dacă trecem o expresie regulată ca $pattern
, trebuie să folosim ~
or #
pentru a
o delimita. Alte delimitatoare nu sunt acceptate. De exemplu, testul în care $var
trebuie să conțină numai cifre
hexazecimale:
Assert::match('#^[0-9a-f]$#i', $var);
Cealaltă variantă este similară cu compararea șirurilor de caractere, dar putem folosi unele caractere wild în
$pattern
:
%a%
unul sau mai multe din orice, cu excepția caracterelor de sfârșit de linie%a?%
zero sau mai multe de orice, cu excepția caracterelor de sfârșit de linie%A%
unul sau mai multe din orice, inclusiv caracterele de sfârșit de linie%A?%
zero sau mai multe de orice, inclusiv caracterele de sfârșit de linie%s%
unul sau mai multe caractere de spațiu alb, cu excepția caracterelor de sfârșit de rând%s?%
zero sau mai multe caractere de spațiu alb, cu excepția caracterelor de sfârșit de rând%S%
unul sau mai multe caractere, cu excepția spațiului alb%S?%
zero sau mai multe caractere, cu excepția spațiului alb%c%
un singur caracter de orice fel (cu excepția celor de sfârșit de rând)%d%
una sau mai multe cifre%d?%
zero sau mai multe cifre%i%
valoare întreagă cu semn%f%
număr în virgulă mobilă%h%
una sau mai multe cifre HEX%w%
unul sau mai multe caractere alfanumerice%%
un caracter %
Exemple:
# Again, hexadecimal number test
Assert::match('%h%', $var);
# Generalized path to file and line number
Assert::match('Error in file %a% on line %i%', $errorMessage);
Assert::matchFile (string $file, $actual, string $description=null)
Afirmația este identică cu Assert::match(), dar modelul este încărcat din
$file
. Este utilă pentru testarea șirurilor foarte lungi. Fișierul de test stă în picioare lizibil.
Assert::fail (string $message, $actual=null, $expected=null)
Această afirmație eșuează întotdeauna. Este doar la îndemână. Putem trece opțional valorile așteptate și cele reale.
Așteptări
Dacă dorim să comparăm structuri mai complexe, cu elemente neconstante, afirmațiile de mai sus ar putea să nu fie
suficiente. De exemplu, testăm o metodă care creează un nou utilizator și îi returnează atributele sub forma unui tablou.
Nu cunoaștem valoarea hash a parolei, dar știm că aceasta trebuie să fie un șir hexazecimal. Și singurul lucru pe care îl
știm despre următorul element este că trebuie să fie un obiect DateTime
.
În aceste cazuri, putem utiliza Tester\Expect
în interiorul parametrului $expected
al metodelor
Assert::equal()
și Assert::notEqual()
, care poate fi folosit pentru a descrie cu ușurință
structura.
use Tester\Expect;
Assert::equal([
'id' => Expect::type('int'), # we expect an integer
'username' => 'milo',
'password' => Expect::match('%h%'), # we expect a string matching pattern
'created_at' => Expect::type(DateTime::class), # we expect an instance of the class
], User::create(123, 'milo', 'RandomPaSsWoRd'));
Cu Expect
, putem face aproape aceleași afirmații ca și cu Assert
. Astfel, avem metode precum
Expect::same()
, Expect::match()
, Expect::count()
, etc. În plus, putem să le înlănțuim
astfel:
Expect::type(MyIterator::class)->andCount(5); # we expect MyIterator and items count is 5
Sau, putem scrie propriile gestionari de afirmații.
Expect::that(function ($value) {
# return false if expectation fails
});
Investigarea aserțiunilor eșuate
Tester arată unde se află eroarea atunci când o aserțiune eșuează. Atunci când comparăm structuri complexe, Tester
creează descărcări ale valorilor comparate și le salvează în directorul output
. De exemplu, atunci când testul
imaginar Arrays.recursive.phpt
eșuează, dumps-urile vor fi salvate după cum urmează:
app/
└── tests/
├── output/
│ ├── Arrays.recursive.actual # actual value
│ └── Arrays.recursive.expected # expected value
│
└── Arrays.recursive.phpt # failing test
Putem schimba numele directorului prin Tester\Dumper::$dumpDir
.