User Tools

Site Tools


backend:symfonytest

Symfony : Les tests

logo

Tests Unitaires

Comme en PHP, on peut éffectuer des tests unitaires pour tester de petites unités d'une application comme des méthodes.

Lancer un test : make:unit-test

Chemin et nom des fichiers de tests

Par convention :

  • On utilise la même arborescence dans le répertoire tests que dans le répertoire src. On utilise le répertoire tests\Controller pour tester les Controllers du répertoire src\Controller
  • On nomme le test sous la forme : MaMethodeTest, on ajoute Test à la fin du nom de la méthode.

On lance un test unitaire avec la commande make:unit-test :

symfony console make:unit-test

On donne le chemin relatif appartir du répertoire src :
Par exemple, pour tester une méthode de l'extension Twig MonExtension.php, on fera :

$ symfony console make:unit-test
 
 The name of the unit test class (e.g. UtilTest):
 > Twig\MonExtensionTest
 
 created: tests/Twig/MonExtensionTest.php
 
  Success!
 
 Next: Open your new test class and start customizing it.
 Find the documentation at https://symfony.com/doc/current/testing.html#unit-tests

Lorsque le test unitaire est créé, 1 fichier est créé :
tests\Twig\MonExtensionTest.php

Nom des méthodes de test

Dans ce fichier, il faut indinquer les méthodes à utiliser comme tests :

  • soit en utilsant un nom de méthode commençant par test
  • soit en utilsant les @test dans l'annotation
public function testSomething ()
{
  ...
}

ou

/**
  * @test
  */ 
public function something ()
{
  ...
}

PHPUnit

PHPUnit est un framework permettant de faire des tests unitaires, il en existe d'autres

Voir la documentation officielle PHPUnit Manual (FR)

Installation

Pour l'installer, il faut utiliser :

bin/phpunit

Il faut peut être ajouter php devant bin/phpunit suivant la configuration de notre machine.

Utilisation

Lancer tous les tests

Pour lancer tous les tests, il faut aussi utiliser :

bin/phpunit
Lancer tous les tests d'un répertoire

Pour lancer tous les tests d'un répartoire, il faut aussi utiliser :

bin/phpunit tests/Twig/
Lancer tous les tests d'un fichier

Pour lancer tous les tests d'un répartoire, il faut aussi utiliser :

bin/phpunit tests/Twig/MonExtensionTest.php
Lancer un test en particulier

Pour lancer un test en particulier, il faut aussi utiliser :

bin/phpunit --filter testSomething 

On peut se créer des alias pour lancer les tests plus rapidement :

alias t=php bin/phpunit

alias tf=php bin/phpunit –filter

Assertions

A l'intérieur des méthodes de test, des méthodes d'assertion telles que sont utilisées pour affirmer qu'une valeur constatée correspond à une valeur attendue.

Document officielle : Assertions (FR).

Liste d'assertions
anything
arrayHasKey
assertArrayHasKey
assertArrayNotHasKey
assertAttributeContains
assertAttributeContainsOnly
assertAttributeEmpty
assertAttributeEquals
assertAttributeGreaterThan
assertAttributeGreaterThanOrEqual
assertAttributeInstanceOf
assertAttributeInternalType
assertAttributeLessThan
assertAttributeLessThanOrEqual
assertAttributeNotContains
assertAttributeNotContainsOnly
assertAttributeNotEmpty
assertAttributeNotEquals
assertAttributeNotInstanceOf
assertAttributeNotInternalType
assertAttributeNotSame
assertAttributeNotType
assertAttributeSame
assertAttributeType
assertClassHasAttribute
assertClassHasStaticAttribute
assertClassNotHasAttribute
assertClassNotHasStaticAttribute
assertContains
assertContainsOnly
assertEmpty
assertEquals
assertEqualXMLStructure
assertFalse
assertFileEquals
assertFileExists
assertFileNotEquals
assertFileNotExists
assertGreaterThan
assertGreaterThanOrEqual
assertInstanceOf
assertInternalType
assertLessThan
assertLessThanOrEqual
assertNotContains
assertNotContainsOnly
assertNotEmpty
assertNotEquals
assertNotInstanceOf
assertNotInternalType
assertNotNull
assertNotRegExp
assertNotSame
assertNotTag
assertNotType
assertNull
assertObjectHasAttribute
assertObjectNotHasAttribute
assertRegExp
assertSame
assertSelectCount
assertSelectEquals
assertSelectRegExp
assertStringEndsNotWith
assertStringEndsWith
assertStringEqualsFile
assertStringMatchesFormat
assertStringMatchesFormatFile
assertStringNotEqualsFile
assertStringNotMatchesFormat
assertStringNotMatchesFormatFile
assertStringStartsNotWith
assertStringStartsWith
assertTag
assertThat
assertTrue
assertType
assertXmlFileEqualsXmlFile
assertXmlFileNotEqualsXmlFile
assertXmlStringEqualsXmlFile
assertXmlStringEqualsXmlString
assertXmlStringNotEqualsXmlFile
assertXmlStringNotEqualsXmlString
attribute
attributeEqualTo
classHasAttribute
classHasStaticAttribute
contains
containsOnly
equalTo
fileExists
greaterThan
greaterThanOrEqual
identicalTo
isEmpty
isFalse
isInstanceOf
isNull
isTrue
isType
lessThan
lessThanOrEqual
logicalAnd
logicalNot
logicalOr
logicalXor
matches
matchesRegularExpression
objectHasAttribute
stringContains
stringEndsWith
stringStartsWith

Test Doubles

Les tests doubles (doublures de tests) permettent de passer de faux objets au méthodes qu'on veut tester.

Document officielle : Doublure de test (FR).

Dummies

Toutes les méthodes du faux objet retournerons null .

On utilise la méthode createMock() pour créer de faux objets (dummies) :

$monObjetDummy = $this->createMock(MonObjet::class);

On peut alors utiliser ce faux objet dans notre méthode de test.

Stubs

Les méthodes du faux objet pourrons retourner des valeurs spécifiques.

On utilise la méthode createStub() pour créer de faux objets (stubs), en réalité cette méthode renvoie directement vers createMock() :

$monObjetStub = $this->createStub(MonObjet::class);

Pour indiquer la valeur que doit retourner une méthode on utilise method() et willReturn :

$monObjetStub
  ->method('maMethode')
  ->willReturn(maValeurDeRetour);

On peut alors utiliser ce faux objet dans notre méthode de test.

Mocks

On spécifie des attentes et non plus des valeurs de retour .

On utilise la méthode createMock() pour créer de faux objets (mocks) :

$monObjetMock = $this->createStub(MonObjet::class);

Pour indiquer la valeur que doit retourner une méthode on utilise expects() , method et with() :

$monObjetMock
  ->expects($this->once())
  ->method('uneMethode')
  ->with('valeurDeRetourDeUneMethode');

On peut utiliser plusieurs méthodes à la place de once() comme :
- atLeastOnce()
- never()
- exactly()
- returnValue()
- throwException()
- …

On peut alors utiliser ce faux objet dans notre méthode de test.

Tests Fonctionnels

Les tests fonctionnels sont des tests de plus grande ampleur.
On applique les mêmes conventions que celles des test unitaires.

On va utiliser d'autres classes que celles de PHPUnit utilisées par les tests unitaires mais en réalités ces classes héritent des classes de PHPUnit.
Symfony a implémenté de nouvelles classes permettant de faire des test fonctionnels à partir de tests unitaires.

Lancer un test : make:functional-test

On lance un test unitaire avec la commande make:functional-test :

symfony console make:functional-test

On donne le chemin relatif appartir du répertoire src :
Par exemple, pour tester un controller MonController.php, on fera :

$ symfony console make:unit-test
 
 The name of the unit test class (e.g. UtilTest):
 > Controller\MonControllerTest
 
 created: tests/Controller/MonControllerTest.php
 
  Success!
 
 Next: Open your new test class and start customizing it.
 Find the documentation at https://symfony.com/doc/current/testing.html#unit-tests

Lorsque le test unitaire est créé, 1 fichier est créé :
tests/Controller/MonControllerTest.php

On a alors cette méthode :

public function testSomething()
{
    $client = static::createClient();
    $crawler = $client->request('GET', '/');
 
    $this->assertResponseIsSuccessful();
    $this->assertSelectorTextContains('h1', 'Hello World');
}

DomCrawler


Voir la documentation officielle The DomCrawler Component

La méthode précédente se décompose comme ceci :

  • $client = static::createClient(); revient à dire que $client est un navigateur web.
  • $crawler = $client→request('GET', '/'); , on envoie une requête GET au navigateur et on récupère un objet permettant de faire du crawling, c'est à dire explorer la page (comme le font les robots de ré)férencement), grace au composant DomCrawler.
    • Obtenir le texte du body
      $crawler->filter('body')->text()
    • Obtenir l'attribut classe du body
      $crawler->filter('body')->attr('class')
  • $this→assertResponseIsSuccessful(); , on s'attend à ce que la réponse soit un succés (répone entre 200 et 299)
  • $this→assertSelectorTextContains('h1', 'Hello World'); , on s'attend à ce que le contenu du h1 soit Hello World

On peut aussi utiliser toutes les méthodes d'assertion des tests unitaires.
On peut tester le titre d'une page :

$this->assertPageTitleSame('Bienvenue');
$this->assertPageTitleContains('Bien');


La syntaxe se rapproche de celle du CSS.

$this->assertSame(
  'app_home', 
  $crawler->filter('body')->attr('class'));


On demande de rechercher :

  • un a
  • dans les li qui ont la class=“active”
  • dans les ul
  • dans la nav
  • Et on regarde si son texte est Home
$this->assertSame(
  'Home', 
  $crawler->filter('nav ul li[class="active"] a')->text());

On peut l'écrire également comme ceci :

$this->assertSelectorTextSame('nav ul li[class="active"] a', 'Home');


On peut vérifié qu'il n'y a qu'une seule li avec la classe active :

$this->assertCount(
  1,
  $crawler->filter('nav ul li[class="active"]')
);

On peut aussi vérifier si une li , avec la classe active, existe : <code php> $this→assertSelectorExists('nav ul li[class=“active”]');

backend/symfonytest.txt · Last modified: 2020/09/16 10:35 (external edit)