• 8 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 12/05/2022

Mettez en place un outil pour implémenter des tests unitaires

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Les tests garantissent la qualité de votre code et de votre application. Ce travail de test va vous demander du développement en plus de ce que vous avez à produire pour que votre application fonctionne. Pour vous aider dans cette tâche, vous pouvez utiliser une librairie tierce.

Nous allons utiliser PHPUnit. C'est la référence en matière de tests avec PHP ! Cet outil fournit tout une suite de classes et méthodes utiles pour faciliter l'écriture de tests. Bien évidemment, il existe d'autres outils pour le test unitaire : libre à vous d'en tester plusieurs et de vous faire votre propre idée.

Dans le cadre de ce cours, vous écrirez vos tests dans une application Symfony.

Une fois l’installation faite, nous allons installer PHPUnit avec Composer, en nous positionnant dans le dossier où vous avez créé votre nouvelle application symfony.

Installez PHPUnit avec Composer

Pour installer PHPunit (version 9 aujourd’hui) avec Composer, tapez la commande suivante dans votre outil de ligne de commande préféré :

composer require --dev phpunit/phpunit ^9

Vérifions maintenant que PHPUnit est bien installé. Avec votre outil de ligne de commande, placez-vous à la racine de votre projet Symfony, et lancez la commande suivante :

$ vendor/bin/phpunit

Vous devez obtenir la sortie suivante :

Sortie console
Sortie console

Vous trouverez également toutes les commandes disponibles en ajoutant l’option “--help” à votre commande, comme ceci : $ vendor/bin/phpunit –help  .

Vous avez aussi la possibilité d'installer PHPUnit en téléchargeant un package phar .

Obtenez le rapport de couverture de code

Avant de commencer à implémenter vos premier tests, il est intéressant de suivre le taux de couverture de code (“code coverage report”, en anglais) des tests que vous allez écrire.

En d’autres termes, on regarde si les tests implémentés passent par toutes les conditions possibles dans notre code.

Concrètement, écrire un test, c'est exécuter le code à tester, c'est-à-dire :

  1. Instancier une classe.

  2. Appeler une méthode en lui passant des paramètres (si besoin).

  3. En vérifier la sortie.

PHPUnit fournit la possibilité de générer un rapport permettant de savoir si une instruction est exécutée ou non. Voyons maintenant comment générer votre premier rapport !

Lancez les tests PHPUnit

Pour obtenir un rapport de couverture de code, il vous faut d'abord être en mesure de lancer des tests.

Mais je n'ai pas encore écrit de tests… Qu'est-ce que je vais lancer ?

Pas de panique ! Vous allez créer la classe ProductTest dans le répertoire test/Entity, et ensuite copier-coller le code ci-dessous dans ce fichier avec votre IDE favori.

Créez la classe de test

Tous les tests doivent être écrits dans des classes. Vous allez donc créer votre première classe de tests. Comme vous écrivez ces tests dans un projet Symfony, il y a quelques règles à respecter :

  • cette classe doit être contenue dans le dossier tests du projet ;

  • il faut reproduire l'arborescence de la classe que vous souhaitez tester ;

  • la classe de test doit avoir le même nom que la classe à tester, suffixé par Test .

Dans le dossier tests/Entity , créez la classe ProductTest suivante :

<?php
namespace App\Tests\Entity;
class ProductTest
{
}

Vous allez faire appel à des méthodes de la librairie PHPUnit

Pour ce faire, il faut étendre la classe TestCase :

<?php
namespace App\Tests\Entity;
use PHPUnit\Framework\TestCase;
class ProductTest extends TestCase
{
}
<?php
namespace App\Tests\Entity;
use App\Entity\Product;
class ProductTest extends \PHPUnit\Framework\TestCase
{
public function testDefault()
{
$product = new Product('Pomme', 'food', 1);
$this->assertSame(0.055, $product->computeTVA());
}
}

Créez aussi la classe Product dans le dossier src/Entity, et collez-y le code ci-dessous.

La classe Product

<?php
namespace App\Entity;
use Symfony\Component\Config\Definition\Exception\Exception;
class Product{
const FOOD_PRODUCT = 'food';
public function __construct($name, $type, $price)
{
$this->name = $name;
$this->type = $type;
$this->price = $price;
}
public function computeTVA(): float | Exception
{
}
if (self::FOOD_PRODUCT == $this->type) {
return $this->price * 0.055;
}
}
}
Premier test fourni à l'installation de Symfony full stack
Premier test fourni à l'installation de Symfony full stack

La classe  ProductTest  correspond à une classe de test unitaire. Nous allons voir comment lancer l’ensemble des tests implémentés avec Symfony. Lancez donc la commande suivante depuis la racine de votre projet :

$ vendor/bin/phpunit
Résultat après lancement des tests
Résultat après lancement des tests

Bravo ! Vous venez de lancer vos premiers tests !

Générez le rapport de couverture de code

Revenons à notre mission initiale : générer le rapport de taux de couverture de code.

Voici la commande à lancer pour le générer :

$ vendor/bin/phpunit --coverage-html public/test-coverage

Avec cette commande, vous demandez à générer le rapport sous forme de pages HTML dans le dossier web/test-coverage (le dossier test-coverage n'a pas besoin d'être créé, PHPUnit s'en charge pour vous).

Tout est installé comme il faut ? Parfait !

Lancez à nouveau la commande et vous devriez obtenir le résultat suivant :

Génération du rapport de couverture de code
Génération du rapport de couverture de code

Le nouveau dossier contenant tous les fichiers HTML avec les informations du rapport a été créé dans votre projet :

Tapez la commande :

$ ls -lah public/test-coverage
Dossier contenant le rapport HTML
Dossier contenant le rapport HTML

Il ne nous reste plus qu'à le consulter ! Ouvrez le fichier Product.php.html avec votre navigateur préféré.

Rapport de couverture de code suite aux tests actuellement implémentés
Rapport de couverture de code suite aux tests actuellement implémentés

Comme vous pouvez le voir, tout le code actuellement écrit dans notre application est couvert. Vous pouvez cliquer sur le fichier pour consulter le code de l'application, et découvrir le détail de couverture. En voici un exemple :

Visualiser le code couvert
Visualiser le code couvert
  • Les lignes vertes correspondent aux lignes de code exécutées par les tests.

  • Si une ligne est rouge, c'est que le code n'est pas encore couvert par les tests implémentés.

  • Si une ligne est orange, le code est inatteignable.

En résumé

  • Il y a plusieurs manières d’installer PHPUnit, mais cela reste plus simple en passant par Composer.

  • On lance les tests unitaires via les commandes suivantes :
    vendor/bin/phpunit
    (va lancer la suite de tests définie dans le phpunit.xml.dist)
    vendor/bin/phpunit --filter=testDefault  (pour ne tester qu'une seule méthode à la fois)

  • Pour trouver le juste milieu pour la couverture de code, il faut commencer par ce qui est le plus sensible dans l'application. Par exemple, il sera plus important de tester le prix d'un produit plutôt que son nom.

  • Pour lancer la génération de la couverture de code, il faut exécuter cette commande :  vendor/bin/phpunit --coverage-html public/test-coverage

Dans le prochain chapitre, nous allons écrire notre premier test unitaire ensemble. Vous êtes prêt ? On y va !

Exemple de certificat de réussite
Exemple de certificat de réussite