Cours pour apprendre à utiliser le framework Laravel 5.5

Laravel utilise PHPUnit pour effectuer les tests. C'est un framework créé par « Sebastian Bergmann » qui fonctionne à partir d'assertions.

Ce framework est installé comme dépendance de Laravel en mode développement :

"require-dev": {
    "filp/whoops": "~2.0",
    "fzaninotto/faker": "~1.4",
    "mockery/mockery": "0.9.*",
    "phpunit/phpunit": "~6.0"
},

Mais vous pouvez aussi utiliser le fichier phar, que vous pouvez trouver sur cette page, et le placer à la racine de votre application. Vous êtes alors prêt à tester !

Vous pouvez vérifier que ça fonctionne en entrant cette commande :

php phpunit(numéro de version).phar -h

Vous obtenez ainsi la liste de toutes les commandes disponibles.

Si vous utilisez la version installée avec Laravel ça donne :

php vendor\phpunit\phpunit\phpunit -h

Je vous conseille de vous faire un alias !

Il y a aussi la possibilité d'utiliser les fichiers placés dans le dossier vendor/bin.

Dans tous les exemples de ce chapitre j'utiliserai le fichier phar en réduisant son nom à phpunit.

Je vous ai dit que les tests s'effectuent dans un environnement particulier, ce qui est bien pratique.

Regardez le fichier phpunit.xml :

<?xml version="1.0" encoding="UTF-8"?>
<phpunit backupGlobals="false"
         backupStaticAttributes="false"
         bootstrap="vendor/autoload.php"
         colors="true"
         convertErrorsToExceptions="true"
         convertNoticesToExceptions="true"
         convertWarningsToExceptions="true"
         processIsolation="false"
         stopOnFailure="false">
    <testsuites>
        <testsuite name="Feature">
            <directory suffix="Test.php">./tests/Feature</directory>
        </testsuite>

        <testsuite name="Unit">
            <directory suffix="Test.php">./tests/Unit</directory>
        </testsuite>
    </testsuites>
    <filter>
        <whitelist processUncoveredFilesFromWhitelist="true">
            <directory suffix=".php">./app</directory>
        </whitelist>
    </filter>
    <php>
        <env name="APP_ENV" value="testing"/>
        <env name="CACHE_DRIVER" value="array"/>
        <env name="SESSION_DRIVER" value="array"/>
        <env name="QUEUE_DRIVER" value="sync"/>
    </php>
</phpunit>

On trouve déjà quatre variables d'environnement :

• APP_ENV : là, on dit qu'on est en mode testing ;
• CACHE_DRIVER : en mode array, ce qui signifie qu'on ne va rien mettre en cache pendant les tests (par défaut on a file) ;
• SESSION_DRIVER : en mode array, ce qui signifie qu'on ne va pas faire persister la session (par défaut on a file) ;
• QUEUE_DRIVER : en mode sync, donc on aura pas de file d'attente.

On peut évidemment ajouter les variables dont on a besoin. Par exemple si pendant les tests je ne veux plus MySql mais sqlite : il y a une variable dans le fichier .env :

DB_CONNECTION=mysql

que je peux modifier. Pour ce faire, dans phpunit.xml, je peux écrire :

<env name="DB_CONNECTION" value="sqlite"/>

Maintenant, pour les tests, je vais utiliser sqlite.

Pour construire un test, on procède généralement en trois étapes :

1. On initialise les données ;
2. On agit sur ces données ;
3. On vérifie que le résultat est conforme à notre attente.

Comme tout ça est un peu abstrait, prenons un exemple. Remplacez le code de la méthode testBasicTest (peu importe dans quel dossier) par celui-ci :

public function testBasicTest()
{
    $data = [10, 20, 30];
    $result = array_sum($data);
    $this->assertEquals(60, $result);
}

On trouve nos trois étapes. On initialise les données :

$data = [10, 20, 30];

On agit sur ces données :

$result = array_sum($data);

On teste le résultat :

$this->assertEquals(60, $result);

La méthode assertEquals permet de comparer deux valeurs, ici 60 et $result. Si vous lancez le test vous obtenez :

Vous voyez à nouveau l'exécution d'un test et d'une assertion. Le tout s'est bien passé. Changez la valeur 60 par une autre et vous obtiendrez ceci :

Vous connaissez maintenant le principe de base d'un test et ce qu'on peut obtenir comme renseignement en cas d'échec.

Les assertions constituent l'outil de base des tests.

Voici quelques assertions et l'utilisation d'un helper de Laravel que l'on teste au passage :

public function testBasicTest()
{
    $data = 'Je suis petit';
    $this->assertTrue(starts_with($data, 'Je'));
    $this->assertFalse(starts_with($data, 'Tu'));
    $this->assertSame(starts_with($data, 'Tu'), false);
    $this->assertStringStartsWith('Je', $data);
    $this->assertStringEndsWith('petit', $data);
}

Lorsqu'on lance le test, on obtient ici :

un test et cinq assertions correctes.

Il est facile d'appeler une route pour effectuer un test sur la réponse. Modifiez la route de base pour celle-ci :

Route::get('/', function () {
    return 'coucou';
});

On a donc une requête avec l'URL de base et comme réponse la chaîne coucou. Nous allons vérifier que la requête aboutit bien, qu'il y a une réponse correcte, et que la réponse est coucou :

public function testBasicTest()
{
    $response = $this->call('GET', '/');
    $response->assertSuccessful();
    $this->assertEquals('coucou', $response->getContent());
}

L'assertion assertSuccessful nous assure que la réponse est correcte. Ce n'est pas une assertion de PHPUnit : elle est spécifique à Laravel. Vous trouverez toutes les assertions de Laravel ici.

La méthode getContent permet de lire la réponse. On obtient :

Mettez ce code pour la route :

Route::get('/', function () {
    return view('welcome')->with('message', 'Vous y êtes !');
});

Ajoutez dans cette vue ceci :

{{ $message }}

Maintenant voici le test :

public function testBasicTest()
{
    $response = $this->call('GET', '/');
    $response->assertViewHas('message', 'Vous y êtes !');
}

On envoie la requête et on récupère la réponse. On peut tester la valeur de la variable $message dans la vue avec l'assertion assertViewHas :

Créez ce contrôleur :

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class WelcomeController extends Controller
{
    public function index()
    {
        return view('welcome');
    }
}

Créez cette route pour mettre en œuvre le contrôleur ci-dessus :

Route::get('welcome', 'WelcomeController@index');

Vérifiez que ça fonctionne (vous aurez peut-être besoin de retoucher la vue où nous avons introduit une variable).

Supprimez le fichier ExampleTest.php qui ne va plus nous servir.

Créez ce test avec Artisan :

php artisan make:test WelcomeControllerTest

Par défaut vous obtenez ce code :

<?php

namespace Tests\Feature;

use Tests\TestCase;
use Illuminate\Foundation\Testing\RefreshDatabase;

class WelcomeControllerTest extends TestCase
{
    /**
     * A basic test example.
     *
     * @return void
     */
    public function testExample()
    {
        $this->assertTrue(true);
    }
}

Changez ainsi le code de la méthode :

public function testIndex()
{
    $response = $this->call('GET', 'welcome');
    $response->assertStatus(200);
}

On n'a plus de méthode spécifique pour les contrôleurs comme c'était le cas avant.

Nous allons voir maintenant comment l'utiliser, mais pour cela on va mettre en place le code à tester. Ce ne sera pas trop réaliste, mais c'est juste pour comprendre le mécanisme de fonctionnement de Mockery. Remplacez le code du contrôleur WelcomeController par celui-ci :

<?php
 
namespace App\Http\Controllers;
 
use App\Services\Livre;
 
class WelcomeController extends Controller
{
    public function __construct()
    {
        $this->middleware('guest');
    }
 
    public function index(Livre $livre)
    {
        $titre = $livre->getTitle();

        return view('welcome', compact('titre'));
    }
}

J'ai prévu l'injection d'une classe dans la méthode index. Voilà la classe en question :

<?php

namespace App\Services;

class Livre 
{
    public function getTitle() {
        return 'Titre';
    }
}

Bon, d'accord, ce n'est pas très joli, mais c'est juste pour la démonstration.

La difficulté ici réside dans la présence de l'injection d'une classe. Comme on veut isoler les tests, l'idéal serait de pouvoir simuler cette classe. C'est justement ce que permet de faire Mockery.

Voici la classe de test que nous allons utiliser :

<?php

namespace Tests\Feature;

use Tests\TestCase;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Collection;
use App\Services\Livre;
use Mockery;

class WelcomeControllerTest extends TestCase
{
    public function testIndex()
    {
        // Création Mock
        $mock = Mockery::mock(Livre::class)
        ->shouldReceive('getTitle')
        ->andReturn('Titre');
 
        // Création lien
        $this->app->instance('\App\Services\Livre', $mock);
 
        // Action
        $response = $this->call('GET', 'welcome');
 
        // Assertions
        $response->assertSuccessful();
        $response->assertViewHas('titre', 'Titre');
 
    }
 
    public function tearDown()
    {
        Mockery::close();
    }
}

Et voici le code à ajouter dans la vue pour faire réaliste :

{{ $titre }}

Si je lance le test, j'obtiens :

Voyons de plus près ce code… On crée un objet Mock en lui demandant de simuler la classe Livre :

$mock = Mockery::mock(Livre::class)

Ensuite on définit le comportement que l'on désire pour cet objet :

->shouldReceive('getTitle')
->andReturn('Titre');

On lui dit qu'il reçoit (shouldReceive) l'appel de la méthode getTitle et doit retourner Titre.

Ensuite on informe le conteneur de Laravel de la liaison entre la classe Livre et notre objet Mock :

$this->app->instance('\App\Services\Livre', $mock);

Ensuite on effectue l'action, ici la requête :

$response = $this->call('GET', 'welcome');

Pour finir, on prévoit deux assertions : une pour vérifier qu'on a une réponse correcte et la seconde pour vérifier qu'on a bien le titre dans la vue :

$response->assertSuccessful();
$response->assertViewHas('titre', 'Titre');

Vous connaissez maintenant le principe de l'utilisation de Mockery. Il existe de vastes possibilités avec ce composant.

Il faut commencer par l'installer :

composer require --dev laravel/dusk

et ensuite utiliser cette commande :

php artisan dusk:install

Vous allez vous retrouver avec un nouveau dossier dans les tests :

Enfin il faut renseigner correctement la variable APP_URL dans le fichier .env :

APP_URL=http://monsite.dev

Pour lancer les tests, c'est :

php artisan dusk

mais on peut aussi se limiter à un groupe de tests :

php artisan dusk --group=groupe1

On va voir ça en œuvre avec l'application d'exemple. Voici l'ensemble des fichiers de test :

Ils sont classés par catégories.

Pour que ça fonctionne il faut régénérer la base de données avec les valeurs par défaut :

php artisan migrate:fresh --seed

Il faut aussi régler la locale sur en :

'locale' => 'en',

On va voir les tests du groupe login (LoginTest.php) :

<?php

namespace Tests\Browser;

use Tests\DuskTestCase;
use Laravel\Dusk\Browser;

class LoginTest extends DuskTestCase
{
    /**
     * Test login by name and logout
     * @group login
     *
     * @return void
     */
    public function testLoginByNameAndLogout()
    {
        $this->browse(function (Browser $browser) {
            $browser->visit('/login')
                    ->type('log', 'Slacker')
                    ->type('password', 'slacker')
                    ->press('Login')
                    ->assertPathIs('/')
                    ->assertSee('Logout')
                    ->clickLink('Logout')
                    ->assertSee('Login');
        });
    }

    /**
     * Test login by email
     * @group login
     *
     * @return void
     */
    public function testLoginByEmail()
    {
        $this->browse(function (Browser $browser) {
            $browser->visit('/login')
                    ->type('log', 'redac@la.fr')
                    ->type('password', 'redac')
                    ->press('Login')
                    ->assertPathIs('/')
                    ->assertSee('Logout')
                    ->clickLink('Logout');
        });
    }

    /**
     * Test login fail
     * @group login
     *
     * @return void
     */
    public function testLoginFail()
    {
        $this->browse(function (Browser $browser) {
            $browser->visit('/login')
                    ->type('log', 'toto@la.fr')
                    ->type('password', 'toto')
                    ->press('Login')
                    ->assertSee('These credentials do not match our records');
        });
    }
}

On les lance ainsi :

php artisan dusk --group=login

et si tout va bien :

Voyons un peu le code, par exemple testLoginByNameAndLogout. On commence par visiter la page de login :

$browser->visit('/login')

On entre (type) la valeur Slacker dans le champ log :

->type('log', 'Slacker')

On entre (type) la valeur slacker dans le champ password :

->type('password', 'slacker')

On actionne (press) le bouton Login :

->press('Login')

On vérifie que l'URL (assertPathIs) est « / » :

->assertPathIs('/')

On vérifie qu'il y a dans la page (assertSee) Logout :

->assertSee('Logout')

On clique sur le lien (clickLink) Logout :

->clickLink('Logout')

On vérifie qu'il y a dans la page (assertSee) Login :

->assertSee('Login');

Vous voyez que c'est d'une grande simplicité ! La documentation complète est ici.

Vous pouvez explorer le code des autres fichiers et lancer les tests. Récemment il y a eu quelques bugs après en avoir lancé plusieurs. Il vaut donc mieux se limiter à un groupe.