Tests en cours
**************

.[perex]
La partie la plus visible de Nette Tester est le gestionnaire de tests en ligne de commande. Il est extrêmement rapide et robuste parce qu'il démarre automatiquement tous les tests en tant que processus séparés en parallèle dans plusieurs threads. Il peut également s'exécuter en mode veille.

L'exécuteur de test Nette Tester est invoqué à partir de la ligne de commande. Comme paramètre, on passe le répertoire de test. Pour le répertoire actuel, il suffit d'entrer un point :

/--pre .[terminal]
vendor/bin/tester .
\--

Lorsqu'il est invoqué, le programme d'exécution des tests parcourt le répertoire spécifié et tous les sous-répertoires et recherche les tests, qui sont les fichiers `*.phpt` et `*Test.php`. Il lit et évalue également leurs [annotations |test-annotations] pour savoir lesquels et comment les exécuter.

Il exécute ensuite les tests. Pour chaque test effectué, le runner imprime un caractère pour indiquer la progression :

- <code style="color: #CCC; background-color: #000">.</code> - test passé
- <code style="color: #CCC; background-color: #000">s</code> - le test a été ignoré
- <code style="color: #FFF; background-color: #900">F</code> - le test a échoué

La sortie peut ressembler à ceci :

/--pre .[terminal]
 _____ ___  ___ _____ ___  ___
|_   _/ __)( __/_   _/ __)| _ )
  |_| \___ /___) |_| \___ |_|_\  v2.5.2

Note: No php.ini is used.
PHP 8.3.2 (cli) | php -n | 8 threads

........s..........................

<span style="color: #FFF; background-color: #090">OK (35 tests, 1 skipped, 1.7 seconds)</span>
\--

Lorsque vous l'exécutez à nouveau, il exécute d'abord les tests qui ont échoué lors de l'exécution précédente, de sorte que vous saurez immédiatement si vous avez corrigé l'erreur.

Le code de sortie de Tester est zéro si aucun test n'a échoué. Non-zéro sinon.

.[warning]
Le Testeur exécute les processus PHP sans `php.ini`. Plus de détails dans la section [Own php.ini |#Own php.ini].


Options en ligne de commande .[#toc-command-line-options]
=========================================================

Nous obtenons un aperçu des options de la ligne de commande en exécutant le Testeur sans paramètres ou avec l'option `-h`:

/--pre .[terminal]
 _____ ___  ___ _____ ___  ___
|_   _/ __)( __/_   _/ __)| _ )
  |_| \___ /___) |_| \___ |_|_\  v2.5.2

Usage:
    tester [options] [<test file> | <directory>]...

Options:
    -p <path>                    Specify PHP interpreter to run (default: php).
    -c <path>                    Look for php.ini file (or look in directory) <path>.
    -C                           Use system-wide php.ini.
    -d <key=value>...            Define INI entry 'key' with value 'value'.
    -s                           Show information about skipped tests.
    --stop-on-fail               Stop execution upon the first failure.
    -j <num>                     Run <num> jobs in parallel (default: 8).
    -o <console|console-lines|tap|junit|log|none> (par exemple -o junit:output.xml)
                                 Spécifier un ou plusieurs formats de sortie avec un nom de fichier optionnel.
    -w | --watch <path>          Watch directory.
    -i | --info                  Show tests environment info and exit.
    --setup <path>               Script for runner setup.
    --temp <path>                Chemin d'accès au répertoire temporaire. Par défaut par sys_get_temp_dir().
    --colors [1|0]               Enable or disable colors.
    --coverage <path>            Generate code coverage report to file.
    --coverage-src <path>        Path to source code.
    -h | --help                  This help.
\--


-p <path> .[filter]
-------------------
Spécifie le binaire PHP qui sera utilisé pour exécuter les tests. Par défaut, c'est `php`.

/--pre .[terminal]
tester -p /home/user/php-7.2.0-beta/php-cgi tests
\--


-c <path> .[filter]
-------------------
Spécifie quel `php.ini` sera utilisé lors de l'exécution des tests. Par défaut, aucun php.ini n'est utilisé. Voir [Own php.ini |#Own php.ini] pour plus d'informations.


-C .[filter]
------------
Un `php.ini` à l'échelle du système est utilisé. Donc, sur une plateforme UNIX, tous les fichiers `/etc/php/{sapi}/conf.d/*.ini` aussi. Voir la section [Own php.ini |#Own php.ini].


-d <key=value> .[filter]
------------------------
Définit la valeur de la directive de configuration PHP pour les tests. Le paramètre peut être utilisé plusieurs fois.

/--pre .[terminal]
tester -d max_execution_time=20
\--


-s
---
Des informations sur les tests ignorés seront affichées.


--stop-on-fail .[filter]
------------------------
Le testeur arrête les tests au premier échec.


-j <num> .[filter]
------------------
Les tests s'exécutent dans un `<num>` parallèles. La valeur par défaut est 8. Si nous souhaitons exécuter les tests en série, nous utilisons la valeur 1.


-o <console|console-lines|tap|junit|log|none> .[filter]
-------------------------------------------------------
Format de sortie. Le format par défaut est celui de la console. Vous pouvez spécifier le nom du fichier dans lequel la sortie sera écrite (par exemple, `-o junit:output.xml`). L'option `-o` peut être répétée plusieurs fois pour générer plusieurs formats à la fois.

- `console`: identique à celui par défaut, mais le logo ASCII n'est pas imprimé dans ce cas
- `console-lines`: similaire à la console, mais le résultat de chaque test est listé sur une ligne séparée avec plus d'informations
- `tap`: [format TAP |https://en.wikipedia.org/wiki/Test_Anything_Protocol] approprié au traitement machine
- `junit`: format XML de JUnit, également approprié au traitement par machine
- `log`: Affiche l'état d'avancement des tests. Tous les tests échoués, ignorés et réussis
- `none`: rien n'est imprimé


''-w | --watch <path>'' .[filter]
---------------------------------
Le testeur ne se termine pas après la fin des tests, mais il continue à exécuter et à surveiller les fichiers PHP dans le répertoire donné. Lorsqu'ils sont modifiés, il exécute à nouveau les tests. Le paramètre peut être utilisé plusieurs fois si nous voulons surveiller plusieurs répertoires.

C'est pratique pendant le remaniement d'une bibliothèque ou le débogage des tests.

/--pre .[terminal]
tester --watch src tests
\--


-i | --info .[filter]
---------------------
Elle affiche des informations sur l'environnement d'exécution d'un test. Par exemple :

/--pre .[terminal]
tester -p /usr/bin/php7.1 -c tests/php.ini --info

<span style="color: #0F0">PHP binary:</span>
/usr/bin/php7.1

<span style="color: #0F0">PHP version:</span>
7.1.7-1+0~20170711133844.5+jessie~1.gbp5284f4 (cli)

<span style="color: #0F0">Code coverage engines:</span>
(not available)

<span style="color: #0F0">Loaded php.ini files:</span>
/var/www/dev/demo/tests/php.ini

<span style="color: #0F0">PHP temporary directory:</span>
/tmp

<span style="color: #0F0">Loaded extensions:</span>
Core, ctype, date, dom, ereg, fileinfo, filter, hash, ...
\--


--setup <path> .[filter]
------------------------
Le testeur charge le script PHP donné au démarrage. La variable `Tester\Runner\Runner $runner` est disponible dans ce script. Supposons que le fichier `tests/runner-setup.php`:

```php
$runner->outputHandlers[] = new MyOutputHandler;
```

et nous exécutons le Testeur :

/--pre .[terminal]
tester --setup tests/runner-setup.php tests
\--


--temp <path> .[filter]
-----------------------
Définit un chemin vers le répertoire pour les fichiers temporaires de Tester. La valeur par défaut est retournée par `sys_get_temp_dir()`. Si la valeur par défaut n'est pas valide, vous en serez averti.

Si nous ne sommes pas sûrs du répertoire utilisé, nous pouvons exécuter Tester avec le paramètre `--info`.


--colors 1|0 .[filter]
----------------------
Le Tester détecte par défaut un terminal colorable et colorie sa sortie. Cette option est supérieure à l'autodétection. Nous pouvons définir la coloration de manière globale par une variable d'environnement système `NETTE_TESTER_COLORS`.


--coverage <path> .[filter]
---------------------------
Le testeur va générer un rapport avec un aperçu de la couverture du code source par les tests. Cette option nécessite l'activation de l'extension PHP [Xdebug |https://xdebug.org/] ou [PCOV |https://github.com/krakjoe/pcov], ou PHP 7 avec la SAPI PHPDBG, qui est plus rapide. L'extension du fichier de destination détermine le format du contenu. HTML ou Clover XML.

/--pre .[terminal]
tester tests --coverage coverage.html  # HTML report
tester tests --coverage coverage.xml   # Clover XML report
\--

La priorité pour choisir le mécanisme de collecte est la suivante :
1) PCOV
2) PHPDBG
3) Xdebug

Les tests étendus peuvent échouer lors de l'exécution par PHPDBG en raison de l'épuisement de la mémoire. La collecte des données de couverture est une opération qui consomme de la mémoire. Dans ce cas, l'appel à `Tester\CodeCoverage\Collector::flush()` dans un test peut aider. Il va vider les données collectées dans un fichier et libérer de la mémoire. Lorsque la collecte de données n'est pas en cours, ou que Xdebug est utilisé, l'appel n'a aucun effet.

"Un exemple de rapport HTML":https://files.nette.org/tester/coverage.html avec couverture de code.


--coverage-src <path> .[filter]
-------------------------------
Nous l'utilisons simultanément avec l'option `--coverage`. L'option `<path>` est un chemin vers le code source pour lequel nous générons le rapport. Il peut être utilisé à plusieurs reprises.


Propre php.ini .[#toc-own-php-ini]
==================================
Le Testeur exécute les processus PHP avec l'option `-n`, ce qui signifie qu'aucun `php.ini` n'est chargé (pas même celui de `/etc/php/conf.d/*.ini` sous UNIX). Cela garantit le même environnement pour les tests exécutés, mais cela désactive également toutes les extensions PHP externes couramment chargées par le système PHP.

Si vous souhaitez conserver la configuration du système, utilisez le paramètre `-C`.

Si vous avez besoin de certaines extensions ou de paramètres INI spéciaux, nous vous recommandons de créer votre propre fichier `php.ini` et de le distribuer parmi les tests. Ensuite, on exécute Tester avec l'option `-c`, par exemple `tester -c tests/php.ini`. Le fichier INI peut ressembler à :

```ini
[PHP]

extension=php_pdo_mysql.dll
extension=php_pdo_pgsql.dll

memory_limit=512M
```

L'exécution de Tester avec un système `php.ini` sous UNIX, par exemple `tester -c /etc/php/cgi/php.ini`, ne charge pas les autres INI de `/etc/php/conf.d/*.ini`. C'est le comportement de PHP, pas celui de Tester.