Nette Documentation Preview

syntax
Assertions
**********

.[perex]
Les assertions sont utilisées pour affirmer qu'une valeur réelle correspond à une valeur attendue. Ce sont des méthodes de l'application `Tester\Assert`.

Choisissez les assertions les plus précises. Il est préférable d'utiliser `Assert::same($a, $b)` plutôt que `Assert::true($a === $b)` car il affiche un message d'erreur significatif en cas d'échec. Dans le deuxième cas, nous obtenons uniquement `false should be true` et il ne dit rien sur le contenu des variables $a et $b.

La plupart des assertions peuvent également avoir une option `$description` qui apparaît dans le message d'erreur si l'attente échoue.

Les exemples supposent que l'alias de classe suivant est défini :

```php
use Tester\Assert;
```


Assert::same($expected, $actual, string $description=null) .[method]
--------------------------------------------------------------------
`$expected` doit être le même que `$actual`. Il est identique à l'opérateur PHP `===`.


Assert::notSame($expected, $actual, string $description=null) .[method]
-----------------------------------------------------------------------
Opposé à `Assert::same()`, il est donc identique à l'opérateur PHP `!==`.


Assert::equal($expected, $actual, string $description=null, bool $matchOrder=false, bool $matchIdentity=false) .[method]
------------------------------------------------------------------------------------------------------------------------
`$expected` doit être le même que `$actual`. Contrairement à `Assert::same()`, l'identité de l'objet, l'ordre des paires de clés => valeur dans les tableaux, et les nombres décimaux légèrement différents sont ignorés, ce qui peut être modifié en paramétrant `$matchIdentity` et `$matchOrder`.

Les cas suivants sont identiques du point de vue de `equal()`, mais pas pour `same()`:

```php
Assert::equal(0.3, 0.1 + 0.2);
Assert::equal($obj, clone $obj);
Assert::equal(
	['first' => 11, 'second' => 22],
	['second' => 22, 'first' => 11],
);
```

Cependant, attention, le tableau `[1, 2]` et `[2, 1]` ne sont pas égaux, car seul l'ordre des valeurs diffère, pas les paires clé => valeur. Le tableau `[1, 2]` peut aussi être écrit comme `[0 => 1, 1 => 2]` et donc `[1 => 2, 0 => 1]` seront considérés comme égaux.

Vous pouvez également utiliser ce que l'on appelle les [attentes |#expectations] dans `$expected`.


Assert::notEqual($expected, $actual, string $description=null) .[method]
------------------------------------------------------------------------
A l'opposé de `Assert::equal()`.


Assert::contains($needle, string|array $actual, string $description=null) .[method]
-----------------------------------------------------------------------------------
Si `$actual` est une chaîne de caractères, elle doit contenir la sous-chaîne `$needle`. Si c'est un tableau, il doit contenir l'élément `$needle` (il est comparé strictement).


Assert::notContains($needle, string|array $actual, string $description=null) .[method]
--------------------------------------------------------------------------------------
Opposé à `Assert::contains()`.


Assert::hasKey(string|int $needle, array $actual, string $description=null) .[method]{data-version:2.4}
-------------------------------------------------------------------------------------------------------
`$actual` doit être un tableau et doit contenir la clé `$needle`.


Assert::notHasKey(string|int $needle, array $actual, string $description=null) .[method]{data-version:2.4}
----------------------------------------------------------------------------------------------------------
`$actual` doit être un tableau et ne doit pas contenir la clé `$needle`.


Assert::true($value, string $description=null) .[method]
--------------------------------------------------------
`$value` doit être `true`, donc `$value === true`.


Assert::truthy($value, string $description=null) .[method]
----------------------------------------------------------
`$value` doit être véridique, donc il satisfait la condition `if ($value) ...`.


Assert::false($value, string $description=null) .[method]
---------------------------------------------------------
`$value` doit être `false`, donc `$value === false`.


Assert::falsey($value, string $description=null) .[method]
----------------------------------------------------------
`$value` doit être faux, donc il remplit la condition `if (!$value) ...`.


Assert::null($value, string $description=null) .[method]
--------------------------------------------------------
`$value` doit être `null`, donc `$value === null`.


Assert::notNull($value, string $description=null) .[method]
-----------------------------------------------------------
`$value` ne doit pas être `null`, donc `$value !== null`.


Assert::nan($value, string $description=null) .[method]
-------------------------------------------------------
`$value` doit être Not a Number. Utilisez uniquement le site `Assert::nan()` pour les tests NAN. La valeur NAN est très spécifique et les assertions `Assert::same()` ou `Assert::equal()` peuvent se comporter de manière imprévisible.


Assert::count($count, Countable|array $value, string $description=null) .[method]
---------------------------------------------------------------------------------
Le nombre d'éléments dans `$value` doit être `$count`. Donc identique à `count($value) === $count`.


Assert::type(string|object $type, $value, string $description=null) .[method]
-----------------------------------------------------------------------------
`$value` doit être d'un type donné. Comme `$type` nous pouvons utiliser une chaîne de caractères :
- `array`
- `list` - tableau indexé dans l'ordre croissant des clés numériques à partir de zéro.
- `bool`
- `callable`
- `float`
- `int`
- `null`
- `object`
- `resource`
- `scalar`
- `string`
- nom de la classe ou de l'objet directement, alors il faut passer `$value instanceof $type`


Assert::exception(callable $callable, string $class, string $message=null, $code=null) .[method]
------------------------------------------------------------------------------------------------
Lors de l'invocation de `$callable`, une exception de l'instance `$class` doit être levée. Si nous passons `$message`, le message de l'exception doit [correspondre |#assert-match]. Et si nous passons `$code`, le code de l'exception doit être le même.

Par exemple, ce test échoue car le message de l'exception ne correspond pas :

```php
Assert::exception(
	fn() => throw new App\InvalidValueException('Zero value'),
	App\InvalidValueException::class,
	'Value is to low',
);
```

Le site `Assert::exception()` renvoie une exception levée, vous pouvez donc tester une exception imbriquée.

```php
$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) .[method]
---------------------------------------------------------------------------------------
Vérifie que l'invocation de `$callable` génère les erreurs attendues (c'est-à-dire les avertissements, les avis, etc.). Comme `$type` nous spécifions une des constantes `E_...`, par exemple `E_WARNING`. Et si on passe `$message`, le message d'erreur doit également [correspondre au |#assert-match] modèle. Par exemple :

```php
Assert::error(
	fn() => $i++,
	E_NOTICE,
	'Undefined variable: i',
);
```

Si le callback génère plus d'erreurs, nous devons les attendre toutes dans l'ordre exact. Dans ce cas, nous passons le tableau à `$type`:

```php
Assert::error(function () {
	$a++;
	$b++;
}, [
	[E_NOTICE, 'Undefined variable: a'],
	[E_NOTICE, 'Undefined variable: b'],
]);
```

.[note]
Si `$type` est le nom de la classe, cette assertion se comporte de la même manière que `Assert::exception()`.


Assert::noError(callable $callable) .[method]
---------------------------------------------
Vérifie que la fonction `$callable` ne lève aucun avertissement/notice/erreur ou exception PHP. Elle est utile pour tester un morceau de code où il n'y a pas d'autre assertion.


Assert::match(string $pattern, $actual, string $description=null) .[method]
---------------------------------------------------------------------------
`$actual` doit correspondre à `$pattern`. Nous pouvons utiliser deux variantes de motifs : les expressions régulières ou les caractères génériques.

Si nous transmettons une expression régulière à `$pattern`, nous devons utiliser `~` or `#` pour la délimiter. Les autres délimiteurs ne sont pas pris en charge. Par exemple, test où `$var` ne doit contenir que des chiffres hexadécimaux :

```php
Assert::match('#^[0-9a-f]$#i', $var);
```

L'autre variante est similaire à la comparaison de chaînes de caractères, mais nous pouvons utiliser certains caractères génériques dans `$pattern`:

- `%a%` un ou plusieurs caractères, à l'exception des caractères de fin de ligne
- `%a?%` zéro ou plus de tout sauf les caractères de fin de ligne
- `%A%` un ou plusieurs caractères, y compris les caractères de fin de ligne
- `%A?%` zéro ou plus de tout, y compris les caractères de fin de ligne
- `%s%` un ou plusieurs caractères d'espace blanc, à l'exception des caractères de fin de ligne
- `%s?%` zéro ou plusieurs caractères d'espace blanc, à l'exception des caractères de fin de ligne
- `%S%` un ou plusieurs caractères sauf l'espace blanc
- `%S?%` zéro ou plus de caractères sauf l'espace blanc
- `%c%` un seul caractère de n'importe quelle sorte (sauf les caractères de fin de ligne)
- `%d%` un ou plusieurs chiffres
- `%d?%` zéro ou plusieurs chiffres
- `%i%` valeur entière signée
- `%f%` un nombre à virgule flottante
- `%h%` un ou plusieurs chiffres HEX
- `%w%` un ou plusieurs caractères alphanumériques
- `%%` un caractère %.

Exemples :

```php
# 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) .[method]
----------------------------------------------------------------------------
L'assertion est identique à [Assert::match() |#assert-match] mais le motif est chargé depuis `$file`. Elle est utile pour tester des chaînes très longues. Le fichier de test est lisible.


Assert::fail(string $message, $actual=null, $expected=null) .[method]
---------------------------------------------------------------------
Cette assertion échoue toujours. Elle est simplement pratique. Nous pouvons optionnellement passer les valeurs attendues et réelles.


Attentes .[#toc-expectations]
-----------------------------
Si nous voulons comparer des structures plus complexes avec des éléments non constants, les assertions ci-dessus peuvent ne pas être suffisantes. Par exemple, nous testons une méthode qui crée un nouvel utilisateur et renvoie ses attributs sous forme de tableau. Nous ne connaissons pas la valeur de hachage du mot de passe, mais nous savons qu'il doit être une chaîne hexadécimale. Et la seule chose que nous savons de l'élément suivant est qu'il doit être un objet `DateTime`.

Dans ces cas, nous pouvons utiliser le paramètre `Tester\Expect` à l'intérieur du paramètre `$expected` des méthodes `Assert::equal()` et `Assert::notEqual()`, qui peuvent être utilisées pour décrire facilement la structure.

```php
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'));
```

Avec `Expect`, nous pouvons faire presque les mêmes affirmations qu'avec `Assert`. Nous avons donc des méthodes comme `Expect::same()`, `Expect::match()`, `Expect::count()`, etc. De plus, nous pouvons les enchaîner comme suit :

```php
Expect::type(MyIterator::class)->andCount(5);  # we expect MyIterator and items count is 5
```

Ou bien, nous pouvons écrire nos propres gestionnaires d'assertions.

```php
Expect::that(function ($value) {
	# return false if expectation fails
});
```


Enquête sur les assertions échouées .[#toc-failed-assertions-investigation]
---------------------------------------------------------------------------
Le testeur montre où se trouve l'erreur lorsqu'une assertion échoue. Lorsque nous comparons des structures complexes, le testeur crée des dumps des valeurs comparées et les enregistre dans le répertoire `output`. Par exemple, lorsque le test imaginaire `Arrays.recursive.phpt` échoue, les vidages seront enregistrés comme suit :

```
app/
└── tests/
	├── output/
	│   ├── Arrays.recursive.actual    # actual value
	│   └── Arrays.recursive.expected  # expected value
	│
	└── Arrays.recursive.phpt          # failing test
```

Nous pouvons changer le nom du répertoire par `Tester\Dumper::$dumpDir`.

Assertions

Les assertions sont utilisées pour affirmer qu'une valeur réelle correspond à une valeur attendue. Ce sont des méthodes de l'application Tester\Assert.

Choisissez les assertions les plus précises. Il est préférable d'utiliser Assert::same($a, $b) plutôt que Assert::true($a === $b) car il affiche un message d'erreur significatif en cas d'échec. Dans le deuxième cas, nous obtenons uniquement false should be true et il ne dit rien sur le contenu des variables $a et $b.

La plupart des assertions peuvent également avoir une option $description qui apparaît dans le message d'erreur si l'attente échoue.

Les exemples supposent que l'alias de classe suivant est défini :

use Tester\Assert;

Assert::same($expected, $actual, string $description=null)

$expected doit être le même que $actual. Il est identique à l'opérateur PHP ===.

Assert::notSame($expected, $actual, string $description=null)

Opposé à Assert::same(), il est donc identique à l'opérateur PHP !==.

Assert::equal($expected, $actual, string $description=null, bool $matchOrder=false, bool $matchIdentity=false)

$expected doit être le même que $actual. Contrairement à Assert::same(), l'identité de l'objet, l'ordre des paires de clés ⇒ valeur dans les tableaux, et les nombres décimaux légèrement différents sont ignorés, ce qui peut être modifié en paramétrant $matchIdentity et $matchOrder.

Les cas suivants sont identiques du point de vue de equal(), mais pas pour same():

Assert::equal(0.3, 0.1 + 0.2);
Assert::equal($obj, clone $obj);
Assert::equal(
	['first' => 11, 'second' => 22],
	['second' => 22, 'first' => 11],
);

Cependant, attention, le tableau [1, 2] et [2, 1] ne sont pas égaux, car seul l'ordre des valeurs diffère, pas les paires clé ⇒ valeur. Le tableau [1, 2] peut aussi être écrit comme [0 => 1, 1 => 2] et donc [1 => 2, 0 => 1] seront considérés comme égaux.

Vous pouvez également utiliser ce que l'on appelle les attentes dans $expected.

Assert::notEqual($expected, $actual, string $description=null)

A l'opposé de Assert::equal().

Assert::contains($needle, string|array $actual, string $description=null)

Si $actual est une chaîne de caractères, elle doit contenir la sous-chaîne $needle. Si c'est un tableau, il doit contenir l'élément $needle (il est comparé strictement).

Assert::notContains($needle, string|array $actual, string $description=null)

Opposé à Assert::contains().

Assert::hasKey(string|int $needle, array $actual, string $description=null)

$actual doit être un tableau et doit contenir la clé $needle.

Assert::notHasKey(string|int $needle, array $actual, string $description=null)

$actual doit être un tableau et ne doit pas contenir la clé $needle.

Assert::true($value, string $description=null)

$value doit être true, donc $value === true.

Assert::truthy($value, string $description=null)

$value doit être véridique, donc il satisfait la condition if ($value) ....

Assert::false($value, string $description=null)

$value doit être false, donc $value === false.

Assert::falsey($value, string $description=null)

$value doit être faux, donc il remplit la condition if (!$value) ....

Assert::null($value, string $description=null)

$value doit être null, donc $value === null.

Assert::notNull($value, string $description=null)

$value ne doit pas être null, donc $value !== null.

Assert::nan($value, string $description=null)

$value doit être Not a Number. Utilisez uniquement le site Assert::nan() pour les tests NAN. La valeur NAN est très spécifique et les assertions Assert::same() ou Assert::equal() peuvent se comporter de manière imprévisible.

Assert::count($count, Countable|array $value, string $description=null)

Le nombre d'éléments dans $value doit être $count. Donc identique à count($value) === $count.

Assert::type(string|object $type, $value, string $description=null)

$value doit être d'un type donné. Comme $type nous pouvons utiliser une chaîne de caractères :

  • array
  • list – tableau indexé dans l'ordre croissant des clés numériques à partir de zéro.
  • bool
  • callable
  • float
  • int
  • null
  • object
  • resource
  • scalar
  • string
  • nom de la classe ou de l'objet directement, alors il faut passer $value instanceof $type

Assert::exception(callable $callable, string $class, string $message=null, $code=null)

Lors de l'invocation de $callable, une exception de l'instance $class doit être levée. Si nous passons $message, le message de l'exception doit correspondre. Et si nous passons $code, le code de l'exception doit être le même.

Par exemple, ce test échoue car le message de l'exception ne correspond pas :

Assert::exception(
	fn() => throw new App\InvalidValueException('Zero value'),
	App\InvalidValueException::class,
	'Value is to low',
);

Le site Assert::exception() renvoie une exception levée, vous pouvez donc tester une exception imbriquée.

$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)

Vérifie que l'invocation de $callable génère les erreurs attendues (c'est-à-dire les avertissements, les avis, etc.). Comme $type nous spécifions une des constantes E_..., par exemple E_WARNING. Et si on passe $message, le message d'erreur doit également correspondre au modèle. Par exemple :

Assert::error(
	fn() => $i++,
	E_NOTICE,
	'Undefined variable: i',
);

Si le callback génère plus d'erreurs, nous devons les attendre toutes dans l'ordre exact. Dans ce cas, nous passons le tableau à $type:

Assert::error(function () {
	$a++;
	$b++;
}, [
	[E_NOTICE, 'Undefined variable: a'],
	[E_NOTICE, 'Undefined variable: b'],
]);

Si $type est le nom de la classe, cette assertion se comporte de la même manière que Assert::exception().

Assert::noError(callable $callable)

Vérifie que la fonction $callable ne lève aucun avertissement/notice/erreur ou exception PHP. Elle est utile pour tester un morceau de code où il n'y a pas d'autre assertion.

Assert::match(string $pattern, $actual, string $description=null)

$actual doit correspondre à $pattern. Nous pouvons utiliser deux variantes de motifs : les expressions régulières ou les caractères génériques.

Si nous transmettons une expression régulière à $pattern, nous devons utiliser ~ or # pour la délimiter. Les autres délimiteurs ne sont pas pris en charge. Par exemple, test où $var ne doit contenir que des chiffres hexadécimaux :

Assert::match('#^[0-9a-f]$#i', $var);

L'autre variante est similaire à la comparaison de chaînes de caractères, mais nous pouvons utiliser certains caractères génériques dans $pattern:

  • %a% un ou plusieurs caractères, à l'exception des caractères de fin de ligne
  • %a?% zéro ou plus de tout sauf les caractères de fin de ligne
  • %A% un ou plusieurs caractères, y compris les caractères de fin de ligne
  • %A?% zéro ou plus de tout, y compris les caractères de fin de ligne
  • %s% un ou plusieurs caractères d'espace blanc, à l'exception des caractères de fin de ligne
  • %s?% zéro ou plusieurs caractères d'espace blanc, à l'exception des caractères de fin de ligne
  • %S% un ou plusieurs caractères sauf l'espace blanc
  • %S?% zéro ou plus de caractères sauf l'espace blanc
  • %c% un seul caractère de n'importe quelle sorte (sauf les caractères de fin de ligne)
  • %d% un ou plusieurs chiffres
  • %d?% zéro ou plusieurs chiffres
  • %i% valeur entière signée
  • %f% un nombre à virgule flottante
  • %h% un ou plusieurs chiffres HEX
  • %w% un ou plusieurs caractères alphanumériques
  • %% un caractère %.

Exemples :

# 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)

L'assertion est identique à Assert::match() mais le motif est chargé depuis $file. Elle est utile pour tester des chaînes très longues. Le fichier de test est lisible.

Assert::fail(string $message, $actual=null, $expected=null)

Cette assertion échoue toujours. Elle est simplement pratique. Nous pouvons optionnellement passer les valeurs attendues et réelles.

Attentes

Si nous voulons comparer des structures plus complexes avec des éléments non constants, les assertions ci-dessus peuvent ne pas être suffisantes. Par exemple, nous testons une méthode qui crée un nouvel utilisateur et renvoie ses attributs sous forme de tableau. Nous ne connaissons pas la valeur de hachage du mot de passe, mais nous savons qu'il doit être une chaîne hexadécimale. Et la seule chose que nous savons de l'élément suivant est qu'il doit être un objet DateTime.

Dans ces cas, nous pouvons utiliser le paramètre Tester\Expect à l'intérieur du paramètre $expected des méthodes Assert::equal() et Assert::notEqual(), qui peuvent être utilisées pour décrire facilement la structure.

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'));

Avec Expect, nous pouvons faire presque les mêmes affirmations qu'avec Assert. Nous avons donc des méthodes comme Expect::same(), Expect::match(), Expect::count(), etc. De plus, nous pouvons les enchaîner comme suit :

Expect::type(MyIterator::class)->andCount(5);  # we expect MyIterator and items count is 5

Ou bien, nous pouvons écrire nos propres gestionnaires d'assertions.

Expect::that(function ($value) {
	# return false if expectation fails
});

Enquête sur les assertions échouées

Le testeur montre où se trouve l'erreur lorsqu'une assertion échoue. Lorsque nous comparons des structures complexes, le testeur crée des dumps des valeurs comparées et les enregistre dans le répertoire output. Par exemple, lorsque le test imaginaire Arrays.recursive.phpt échoue, les vidages seront enregistrés comme suit :

app/
└── tests/
	├── output/
	│   ├── Arrays.recursive.actual    # actual value
	│   └── Arrays.recursive.expected  # expected value
	│
	└── Arrays.recursive.phpt          # failing test

Nous pouvons changer le nom du répertoire par Tester\Dumper::$dumpDir.