diff --git a/build/build.xml b/build/build.xml index b05d0eaaa..48ebd2a40 100644 --- a/build/build.xml +++ b/build/build.xml @@ -550,6 +550,13 @@ + + + + + + + @@ -1376,6 +1383,13 @@ + + + + + + + diff --git a/src/6.1/fr/README b/src/6.1/fr/README deleted file mode 100644 index 57131f882..000000000 --- a/src/6.1/fr/README +++ /dev/null @@ -1,17 +0,0 @@ -Guide de traduction -=================== - -Dans ce fichier sont recensées les règles de traductions utilisées de manière à garantir la cohérence d'ensemble. -Sont notamment visés les termes techniques. - -actual: constatée (valeur) -array: traduit par tableau sauf quand on fait explicitement référence à PHP -assertion: traduit par asssertion, plus parlant que affirmation -composable: composable (rien trouvé de mieux) -expected: attendue (valeur) -framework: framework -isolated: indépendant (isolé est ambigu, étanche un peu moins...) -notice: remarque -return: retourne plutôt que renvoie - -verbe ing: traduits par l'infinitif dans les titres: testing => tester diff --git a/src/6.1/fr/README.md b/src/6.1/fr/README.md new file mode 100644 index 000000000..dabdefa59 --- /dev/null +++ b/src/6.1/fr/README.md @@ -0,0 +1,80 @@ +## Comment construire la documentation + +Pour compiler la documentation en français, les pré-requis sont les suivants : + +- Apache Ant +- PHP 5 (avec les extensions DOM, PRCE, SPL et Tokenizer) +- Ruby +- xsltproc + +Pour compiler la documentation en français : + + cd build + ant build-fr-6.1 + +Attention, la documentation est en cours de traduction (cf. tableau ci dessous) + + +## Contributions attendues + + * Traduire les fichiers encore en anglais + * Mettre à jour les fichiers existants + * Partir à la chasse aux typos et aux fautes d'orthographes, de grammaire et de syntaxes + * Détecter le franglais et les anglicismes + * Revue de pair sur les PR + + +## Plan + +| Fichier | Etat | Contributeurs | Nb ligne revues/Total | +| --------------------------------- | :-------: | :---------------: | :----------------------: | +| annotations.xml | OK | @brice @gbprod | done | +| assertions.xml | OK | @gbprod | done | +| bibliography.xml | OK | @gbprod | done | +| book.xml | OK | @gbprod | done | +| code-coverage-analysis.xml | OK | @brice @gbprod | done | +| configuration.xml | OK | @gbprod | done | +| copyright.xml | OK | @gbprod | done | +| database.xml | OK | @gbprod | done | +| extending-phpunit.xml | OK | @gbprod | done | +| fixtures.xml | OK | @gbprod | done | +| incomplete-and-skipped-tests.xml | OK | @gbprod | done | +| index.xml | OK | @gbprod | done | +| installation.xml | OK | @brice @methylbro @gbprod | done | +| logging.xml | OK | @gbprod | done | +| organizing-tests.xml | OK | @gbprod | done | +| other-uses-for-tests.xml | OK | @gbprod | done | +| risky-tests.xml | OK | @gbprod | done | +| test-doubles.xml                 | OK       | @brice @gbprod | done               | +| testing-practices.xml | OK | @gbprod | done | +| textui.xml | OK | @gbprod | done | +| writing-tests-for-phpunit.xml | OK | @gbprod | done | + +## Guide de traduction + +Dans ce fichier sont recensées les règles de traductions utilisées de manière à garantir la cohérence d'ensemble. +Sont notamment visés les termes techniques. + +actual: constatée (valeur) +array: traduit par tableau sauf quand on fait explicitement référence à PHP +assertion: traduit par asssertion, plus parlant que affirmation +composable: composable (rien trouvé de mieux) +expected: attendue (valeur) +framework: framework +isolated: indépendant (isolé est ambigu, étanche un peu moins...) +notice: remarque +return: retourne plutôt que renvoie +requirements: pré-requis +extension: extensions +code coverage: couverture de code +appendix: annexe +fixture: fixture (pas trouvé mieux en français) +stub: bouchon + +verbe ing: traduits par l'infinitif dans les titres: testing => tester + +## Historique du projet de traduction + +14/02/2017 : Je relance le projet de traduction de la doc de PHPUnit afin de permettre à des francophones de mieux appréhender ce produit. La dernière version française complète est lié à la version 4.3 de phpunit. C'est cette version qui est dupliquée dans les répertoires 4.4 à 6.0. La traduction commence à la version 6.1 avec un travail en cours de récupération des fichiers manquants et mise à jour des fichiers existant. + +03/03/2017 : J'ai ajouté un tableau d'avancement ppur mesurer le travail à fournir pour arriver au bout des traductions. diff --git a/src/6.1/fr/annotations.xml b/src/6.1/fr/annotations.xml index f4b7e803a..d61c6da9f 100644 --- a/src/6.1/fr/annotations.xml +++ b/src/6.1/fr/annotations.xml @@ -6,17 +6,25 @@ Annotation - Une annotation est une forme spéciale de méta donnée syntaxique qui peut + Une annotation est une forme spéciale de métadonnée syntaxique qui peut être ajoutée au code source de certains langages de programmation. Bien que PHP n'ait pas de fonctionnalité dédiée à l'annotation du code source, l'utilisation - d'étiquettes telles que @annotation paramètres dans les blocs de documentation + d'étiquettes telles que @annotation arguments dans les blocs de documentation s'est établi dans la communauté PHP pour annoter le code source. En PHP, les blocs de - documentation sont réflexifs: ils peuvent être accédés via la méthode de l'API de réflexivité + documentation sont réflexifs : ils peuvent être accédés via la méthode de l'API de réflexivité getDocComment() au niveau des fonctions, classes, méthodes et attributs. Des applications telles que PHPUnit utilisent ces informations durant l'exécution pour adapter leur comportement. + + + Un "doc comment" en PHP doit commencé par /** et se terminer avec + */. Les annotations se trouvant des des commentaires d'un autre style + seront ignorées. + + + Cette annexe montre toutes les sortes d'annotations gérées par PHPUnit. @@ -34,6 +42,67 @@ +
+ @after + + + + L'annotation @after peut être utilisé pour spécifier des méthodes + devant être appelées après chaque méthode de test dans une classe de cas de tests. + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase +{ + /** + * @after + */ + public function tearDownSomeFixtures() + { + // ... + } + + /** + * @after + */ + public function tearDownSomeOtherFixtures() + { + // ... + } +} + +
+ +
+ @afterClass + + + + L'annotation @afterClass peut-être utilisées pour spécifier + des méthodes statiques devant être appelées après chaque méthode de test + dans une classe de test pour être exécuté afin de nettoyer des fixtures partagées. + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase +{ + /** + * @afterClass + */ + public static function tearDownSomeSharedFixtures() + { + // ... + } + + /** + * @afterClass + */ + public static function tearDownSomeOtherSharedFixtures() + { + // ... + } +} + +
+
@backupGlobals @@ -41,11 +110,12 @@ @backupGlobals Les opérations de sauvegarde et de restauration des variables globales peuvent - être complètement désactivées pour tous les tests d'une classe de cas de test - comme ceci : /** + être complètement désactivées pour tous les tests d'une classe de cas de test comme ceci : use PHPUnit\Framework\TestCase; + +/** * @backupGlobals disabled */ -class MonTest extends PHPUnit_Framework_TestCase +class MyTest extends TestCase { // ... } @@ -54,16 +124,19 @@ class MonTest extends PHPUnit_Framework_TestCase @backupGlobals - L'annotation @backupGlobals peut également être utilisée sur les opérations - de sauvegarde et de restauration : /** + L'annotation @backupGlobals peut également être + utilisée au niveau d'une méthode. Cela permet une configuration fine des + des opérations de sauvegarde et de restauration : use PHPUnit\Framework\TestCase; + +/** * @backupGlobals disabled */ -class MonTest extends PHPUnit_Framework_TestCase +class MyTest extends TestCase { /** * @backupGlobals enabled */ - public function testQuiIntergitAvecDesVariablesGlobales() + public function testThatInteractsWithGlobalVariables() { // ... } @@ -77,32 +150,96 @@ class MonTest extends PHPUnit_Framework_TestCase @backupStaticAttributes - Les opérations de sauvegarde et de restauration pour les attributs statiques - des classes peuvent être complètement désactivés pour tous les tests d'une classe - de cas de test comme ceci : - /** - * @backupStaticAttributes disabled + L'annotation @backupStaticAttributes peut être utilisée pour + enregistrer tous les attributs statiques dans toutes les classes déclarées + avant chaque test et les restaurer après. Elle peut être utilisé au niveau de la classe ou + au niveau de la méthode : + + use PHPUnit\Framework\TestCase; + +/** + * @backupStaticAttributes enabled */ -class MonTest extends PHPUnit_Framework_TestCase +class MyTest extends TestCase { - // ... + /** + * @backupStaticAttributes disabled + */ + public function testThatInteractsWithStaticAttributes() + { + // ... + } +} + + + + + + @backupStaticAttributes est limitée par le fonctionnement interne de PHP + et peut entrainer la persistance inattendue de valeurs statique et fuiter dans + les tests suivants tests dans certaines circonstances. + + + Voir pour les détails. + + + +
+ +
+ @before + + + + L'annotation @before peut être utilisée pour spécifier des méthodes + devant être appelées avant chaque méthode de test dans une classe de cas de test. + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase +{ + /** + * @before + */ + public function setupSomeFixtures() + { + // ... + } + + /** + * @before + */ + public function setupSomeOtherFixtures() + { + // ... + } } +
+ +
+ @beforeClass - @backupStaticAttributes - L'annotation @backupStaticAttributes peut également être utilisée au - niveau d'une méthode de test. Ceci permet une configuration plus fine des opérations - de sauvegarde et de restauration: /** - * @backupStaticAttributes disabled - */ -class MonTest extends PHPUnit_Framework_TestCase + L'annotation @beforeClass peut être utilisée pour spécifier + des méthodes statiques qui doivent être appellées avant chaque méthodes de test dans une classe + de test qui sont exécutés pour paramétrer des fixtures partagées. + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase { /** - * @backupStaticAttributes enabled + * @beforeClass */ - public function testQuiInteragitAvecDesAttributsStatiques() + public static function setUpSomeSharedFixtures() + { + // ... + } + + /** + * @beforeClass + */ + public static function setUpSomeOtherSharedFixtures() { // ... } @@ -118,8 +255,8 @@ class MonTest extends PHPUnit_Framework_TestCase @codeCoverageIgnoreStart @codeCoverageIgnoreEnd - Les annotations @codeCoverageIgnore, - @codeCoverageIgnoreStart et + Les annotations @codeCoverageIgnore, + @codeCoverageIgnoreStart et @codeCoverageIgnoreEnd peuvent être utilisées pour exclure des lignes de code de l'analyse de couverture. @@ -137,18 +274,18 @@ class MonTest extends PHPUnit_Framework_TestCase Code Coverage @covers - L'annotation @covers peut être utilisée dans le code de test pour - indique quelle(s) méthode(s) un test veut tester:/** - * @covers CompteBancaire::getBalance + L'annotation @covers peut être utilisée dans le code de test pour + indique quelle(s) méthode(s) une méthode de test veut tester:/** + * @covers BankAccount::getBalance */ -public function testBalanceEstInitiallementAZero() +public function testBalanceIsInitiallyZero() { $this->assertEquals(0, $this->ba->getBalance()); } - Si elle est fournie, seule l'information de couverture de code pour + Si elle est fournie, seule l'information de couverture de code pour la(les) méthode(s) sera prise en considération. @@ -169,46 +306,85 @@ public function testBalanceEstInitiallementAZero() - + Indique que la méthode de test annotée couvre la méthode indiquée. - + Indique que la méthode de test annotée couvre toutes les méthodes d'une classe donnée. - ]]> + ]]> Indique que la méthode de test annotée couvre toutes les méthodes d'une classe donnée ainsi que les classe(s) et interface(s) parentes. - ]]> + ]]> Indique que la méthode de test annotée couvre toutes les méthodes publiques d'une classe donnée. - ]]> + ]]> Indique que la méthode de test annotée couvre toutes les méthodes protected d'une classe donnée. - ]]> + ]]> Indique que la méthode de test annotée couvre toutes les méthodes privées d'une classe donnée. - ]]> + ]]> Indique que la méthode de test annotée couvre toutes les méthodes d'une classe donnée qui ne sont pas publiques. - ]]> + ]]> Indique que la méthode de test annotée couvre toutes les méthodes d'une classe donnée qui ne sont pas protected. - ]]> + ]]> Indique que la méthode de test annotée couvre toutes les méthodes d'une classe donnée qui ne sont pas privées. + + + Indique que la méthode de test annotée couvre la méthode globale spécifiée. +
+
+ @coversDefaultClass + + + @coversDefaultClass + + L'annotation @coversDefaultClass peut être utilisée pour + spécifier un espace de nom ou un nom de classe par défaut. Ainsi, les noms long n'ont pas besoin d'être + répétés pour chaque annotation @covers. Voir + . + + + + Utiliser @coversDefaultClass pour simplifier les annotations + publicMethod(); + } +} +?>]]> + +
+
@coversNothing @@ -216,17 +392,17 @@ public function testBalanceEstInitiallementAZero() @coversNothing L'annotation @coversNothing peut être utilisée dans le code de test - pour indiquer qu'aucune information de couverture de code ne sera enregistrée pour le + pour indiquer qu'aucune information de couverture de code ne sera enregistrée pour le cas de test annoté. - Ceci peut être utilisé pour le test d'intégration. Voir + Ceci peut être utilisé pour les tests d'intégration. Voir pour un exemple. - + L'annotation peut être utilisée au niveau de la classe et de la méthode et sera surchargée par toute étiquette @covers. @@ -239,15 +415,14 @@ public function testBalanceEstInitiallementAZero() @dataProvider Une méthode de test peut accepter des paramètres arbitraires. Ces paramètres - peuvent être fournis pas une méthode fournisseuse de données ( - (provider() dans + peuvent être fournis pas une méthode fournisseuse de données ((provider() dans ). La méthode fournisseur de données peut être indiquée en utilisant l'annotation @dataProvider. - Voir pour plus de + Voir pour plus de détails.
@@ -261,8 +436,7 @@ public function testBalanceEstInitiallementAZero() PHPUnit gère la déclaration des dépendances explicites entre les méthodes de test. De telles dépendances ne définissent pas l'ordre dans lequel les méthodes de test doivent être exécutées mais elles permettent de retourner - l'instance d'une fixture de test par un producteur et de la passer aux - consommateurs dépendants. + l'instance d'une fixture de test par un producteur et de la passer aux consommateurs dépendants. montre comment utiliser l'annotation @depends pour exprimer des dépendances entre méthodes de test. @@ -297,43 +471,48 @@ public function testBalanceEstInitiallementAZero() @expectedExceptionCode - L'annotation @expectedExceptionCode, en conjonction avec + L'annotation @expectedExceptionCode, en conjonction avec @expectedException permet de faire des assertions sur le code d'erreur d'une exception levée ce qui permet de cibler une exception particulière. - class MonTest extends PHPUnit_Framework_TestCase + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase { /** - * @expectedException MonException + * @expectedException MyException * @expectedExceptionCode 20 */ - public function testExceptionAUnCodeErreur20() + public function testExceptionHasErrorcode20() { - throw new MonException('Un message', 20); + throw new MyException('Some Message', 20); } } - Pour faciliter les tests et réduire la duplication, un raccourci peut être utilisé pour - indiquer une constante de classe comme un + Pour faciliter les tests et réduire la duplication, un raccourci peut être utilisé pour + indiquer une constante de classe comme un @expectedExceptionCode en utilisant la syntaxe "@expectedExceptionCode ClassName::CONST". - - class MonTest extends PHPUnit_Framework_TestCase - { - /** - * @expectedException MonException - * @expectedExceptionCode MaClasse::CODE_ERREUR - */ - public function testExceptionAUnCodeErreur20() - { - throw new MonException('Un message', 20); - } - } - class MaClasse - { - const CODE_ERREUR = 20; - } + + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase +{ + /** + * @expectedException MyException + * @expectedExceptionCode MyClass::ERRORCODE + */ + public function testExceptionHasErrorcode20() + { + throw new MyException('Some Message', 20); + } +} +class MyClass +{ + const ERRORCODE = 20; +} + @@ -345,41 +524,45 @@ public function testBalanceEstInitiallementAZero() @expectedExceptionMessage L'annotation @expectedExceptionMessage fonctionne de manière - similaire à @expectedExceptionCode en ce qu'il vous permet de + similaire à @expectedExceptionCode et vous permet de faire une assertion sur le message d'erreur d'une exception. - class MonTest extends PHPUnit_Framework_TestCase + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase { /** - * @expectedException MonException - * @expectedExceptionMessage Un message + * @expectedException MyException + * @expectedExceptionMessage Some Message */ - public function testExceptionALeBonMessage() + public function testExceptionHasRightMessage() { - throw new MonException('Un message', 20); + throw new MyException('Some Message', 20); } } Le message attendu peut être une partie d'une chaîne d'un message d'exception. - Ceci peut être utile pour faire une assertion sur le fait qu'un nom ou un + Ceci peut être utile pour faire une assertion sur le fait qu'un nom ou un paramètre qui est passé s'affiche dans une exception sans fixer la totalité du message d'exception dans le test. - class MonTest extends PHPUnit_Framework_TestCase + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase { /** - * @expectedException MonException - * @expectedExceptionMessage cassé + * @expectedException MyException + * @expectedExceptionMessage broken */ - public function testExceptionALeBonMessage() + public function testExceptionHasRightMessage() { - $param = "cassé"; - throw new MonException('Paramètre "'.$param.'" incorrect.', 20); + $param = "broken"; + throw new MyException('Invalid parameter "'.$param.'".', 20); } } - Pour faciliter les tests et réduire la duplication, un raccourci peut être utilisé pour - indiquer une constante de classe comme un + Pour faciliter les tests et réduire la duplication, un raccourci peut être utilisé pour + indiquer une constante de classe comme un @expectedExceptionCode en utilisant la syntaxe "@expectedExceptionCode ClassName::CONST". @@ -388,6 +571,34 @@ public function testBalanceEstInitiallementAZero() +
+ @expectedExceptionMessageRegExp + + + @expectedExceptionMessageRegExp + + Le message d'exception attendu peut aussi être spécifié par une expression régulière en utilisant + l'annotation @expectedExceptionMessageRegExp. C'est + utile pour des situations où une sous-chaine n'est pas adaptée pour correspondre + au message donné. + + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase +{ + /** + * @expectedException MyException + * @expectedExceptionMessageRegExp /Argument \d+ can not be an? \w+/ + */ + public function testExceptionHasRightMessage() + { + throw new MyException('Argument 2 can not be an integer'); + } +} + + +
+
@group @@ -395,12 +606,14 @@ public function testBalanceEstInitiallementAZero() @group Un test peut être marqué comme appartement à un ou plusieurs groupes en utilisant - l'annotation @group comme ceci class MonTest extends PHPUnit_Framework_TestCase + l'annotation @group comme ceci use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase { /** * @group specification */ - public function testQuelquechose() + public function testSomething() { } @@ -408,20 +621,94 @@ public function testBalanceEstInitiallementAZero() * @group regresssion * @group bug2204 */ - public function testAutreChose() + public function testSomethingElse() { } } - + Des tests peuvent être sélectionnés pour l'exécution en se basant sur les groupes en utilisant les options --group et --exclude-group - du lanceur de test en ligne de commandes ou en utilisant les directives respectives du + du lanceur de test en ligne de commandes ou en utilisant les directives respectives du fichier de configuration XML.
+
+ @large + + + @large + + L'annotation @large est un alias pour + @group large. + + + + PHP_Invoker + timeoutForLargeTests + + Si le paquet PHP_Invoker est installé et que le mode strict + est activé, un test "large" échouera s'il prend plus de 60 + secondes pour s'exécuter. Ce délai est configurable via l'attribut + timeoutForLargeTests dans le fichier de + configuration XML. + +
+ +
+ @medium + + + @medium + + L'annotation @medium est un alias pour + @group medium. Un test "medium" ne doit pas dépendre d'un test + marqué comme @large. + + + + PHP_Invoker + timeoutForMediumTests + + Si le paquet PHP_Invoker est installé et que le mode strict + est activé, un test "medium" échouera s'il prend plus de 10 + secondes pour s'exécuter. Ce délai est configurable via l'attribut + timeoutForMediumTests dans le fichier de + configuration XML. + +
+ +
+ @preserveGlobalState + + + @preserveGlobalState + + Quand un test est exécuté dans un processus séparé, PHPUnit va + tenter de conserver l'état global du processus parent en + sérialisant toutes les globales dans le processus parent et en les désérialisant + dans le processus enfant. Cela peut poser des problèmes si le processus parent + contient des globales qui ne sont pas sérialisable. Pour corriger cela, vous pouvez empécher + PHPUnit de conserver l'état global avec + l'annotation @preserveGlobalState. + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase +{ + /** + * @runInSeparateProcess + * @preserveGlobalState disabled + */ + public function testInSeparateProcess() + { + // ... + } +} + +
+
@requires @@ -429,8 +716,7 @@ public function testBalanceEstInitiallementAZero() @requires L'annotation @requires peut être utilisée pour sauter des tests lorsque - des pré-requis communs, comme la version de PHP ou des extensions installées, ne sont pas - fournis. + des pré-requis communs, comme la version de PHP ou des extensions installées, ne sont pas fournis. @@ -445,9 +731,26 @@ public function testBalanceEstInitiallementAZero() @runTestsInSeparateProcesses - - + Indique que tous les tests d'une classe de tests doivent être executés dans + un processus PHP séparé. use PHPUnit\Framework\TestCase; + +/** + * @runTestsInSeparateProcesses + */ +class MyTest extends TestCase +{ + // ... +} + + Note: Par défaut, PHPUnit va + essayer de conserver l'état global depuis le processus parent en + sérialisant toutes les globales dans le processus parent et en les désérialisant + dans le processus enfant. Cela peut poser des problèmes si le processus parent + contient des globales qui ne sont pas sérialisable. Voir pour plus d'information + sur comment le corriger. +
@@ -455,9 +758,59 @@ public function testBalanceEstInitiallementAZero() @runInSeparateProcess + + Indique qu'un test doit être executé dans un processus PHP séparé. + use PHPUnit\Framework\TestCase; + +class MyTest extends TestCase +{ + /** + * @runInSeparateProcess + */ + public function testInSeparateProcess() + { + // ... + } +} + + Note: Par défaut, PHPUnit va + essayer de conserver l'état global depuis le processus parent en + sérialisant toutes les globales dans le processus parent et en les désérialisant + dans le processus enfant. Cela peut poser des problèmes si le processus parent + contient des globales qui ne sont pas sérialisable. Voir pour plus d'information + sur comment le corriger. +
- +
+ @small + + + @small + + L'annotation @small est un alias pour + @group small. Un test "small" ne doit pas dépendre d'un test + marqué comme @medium ou @large. + + + + PHP_Invoker + timeoutForSmallTests + + Si le paquet PHP_Invoker est installé et que le mode strict + est activé, un test "small" va échoué s'il prend plus d'1 + seconde pour s'executer. Ce délai est configurable via + l'attrubut timeoutForSmallTests dans le fichier + de configuration XML. + + + + + Les tests doivent être explicitement annotés par soit @small, + @medium, ou @large pour activer les temps limites d'execution. + +
@@ -472,7 +825,7 @@ public function testBalanceEstInitiallementAZero() /** * @test */ -public function balanceInitialeDoitEtre0() +public function initialBalanceShouldBe0() { $this->assertEquals(0, $this->ba->getBalance()); } @@ -499,4 +852,32 @@ public function balanceInitialeDoitEtre0()
+ +
+ @uses + + + @uses + + L'annotation @uses spécifies du code qui sera exécuté + par un test, mais qui n'et pas destiné à être couvert par le test. Un bon + exemple est un objet-valeur qui est nécessaire pour tester une partie du code. + /** + * @covers BankAccount::deposit + * @uses Money + */ +public function testMoneyCanBeDepositedInAccount() +{ + // ... +} + + + + Cette annotation est spéciali + This annotation is notamment utile en mode de couverture stricte où + du code involontairement couvert va faire échouer un test. Voir + fpour plus + d'informations sur le mode de couverture stricte. + +
diff --git a/src/6.1/fr/assertions.xml b/src/6.1/fr/assertions.xml new file mode 100644 index 000000000..7a187a882 --- /dev/null +++ b/src/6.1/fr/assertions.xml @@ -0,0 +1,2516 @@ + + + Assertions + + + Cette annexe liste les différentes méthodes d'assertion disponibles. + + +
+ De l'utilisation Statique vs. Non-Statique des méthodes d'assertion + + + Les assertions de PHPUnitsont implémentées dans PHPUnit\Framework\Assert. + PHPUnit\Framework\TestCase hérite de PHPUnit\Framework\Assert. + + + + Les méthodes d'assertion sont declarées static et peuvent être appelées + depuis n'importe quel contexte en utilisant PHPUnit\Framework\Assert::assertTrue(), + par exemple, ou en utilisant $this->assertTrue() ou self::assertTrue(), + par exemple, dans une classe qui étends PHPUnit\Framework\TestCase. + + + + En fait, vous pouvez même utiliser des fonctions globales d'encapsulation comme assertTrue() dans + n'importe quel contexte (y compris les classes qui étendent PHPUnit\Framework\TestCase) + quand vous incluez (manuellement) le fichier de code source src/Framework/Assert/Functions.php + fournit avec PHPUnit. + + + + Une question fréquente, surtout de la part des développeurs qui ne connaissent pas PHPUnit, est si + utiliser $this->assertTrue() ou self::assertTrue(), + par exemple, est "la bonne façon" d'appeler une assertion. La réponse courte est: il + n'y a pas de bonne façon. Et il n'y a pas de mauvaise façon non plus. C'est une + question de préférence personnelle. + + + + Pour la plupart des gens, il "semble juste" d'utiliser $this->assertTrue() + parce que la méthode de test est appelée sur un objet de test. Le fait que les méthodes + d'assertion soient déclarées static autorise leur (ré)utilisation + en dehors du scope d'un objet de test. Enfin, les fonctions globales + d'encapsulation permettent aux développeurs de taper moins de caractères (assertTrue() au lieu de + $this->assertTrue() ou self::assertTrue()). + +
+ +
+ assertArrayHasKey() + assertArrayHasKey() + assertArrayNotHasKey() + assertArrayHasKey(mixed $key, array $array[, string $message = '']) + Signale une erreur identifiée par $message si le tableau $array ne dispose pas de la clé $key. + assertArrayNotHasKey() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertArrayHasKey() + assertArrayHasKey('foo', ['bar' => 'baz']); + } +} +?>]]> + phpunit ArrayHasKeyTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) ArrayHasKeyTest::testFailure +Failed asserting that an array has the key 'foo'. + +/home/sb/ArrayHasKeyTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertClassHasAttribute() + assertClassHasAttribute() + assertClassNotHasAttribute() + assertClassHasAttribute(string $attributeName, string $className[, string $message = '']) + Signale une erreur identifiée par $message si $className::attributeName n'existe pas. + assertClassNotHasAttribute() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertClassHasAttribute() + assertClassHasAttribute('foo', stdClass::class); + } +} +?>]]> + phpunit ClassHasAttributeTest + +
+ +
+ assertArraySubset() + assertArraySubset() + assertArraySubset() + assertArraySubset(array $subset, array $array[, bool $strict = '', string $message = '']) + Signale une erreur identifiée par $message si $array ne contient pas le $subset. + $strict indique de comparer l'identité des objets dans les tableaux. + + Utilisation de assertArraySubset() + assertArraySubset(['config' => ['key-a', 'key-b']], ['config' => ['key-a']]); + } +} +?>]]> + phpunit ArrayHasKeyTest Array &1 ( + 0 => 'key-a' + 1 => 'key-b' + ) +). + +/home/sb/ArraySubsetTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1.]]> + +
+ +
+ assertClassHasStaticAttribute() + assertClassHasStaticAttribute() + assertClassNotHasStaticAttribute() + assertClassHasStaticAttribute(string $attributeName, string $className[, string $message = '']) + Signale une erreur identifiée par $message si $className::attributeName n'existe pas. + assertClassNotHasStaticAttribute() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertClassHasStaticAttribute() + assertClassHasStaticAttribute('foo', stdClass::class); + } +} +?>]]> + phpunit ClassHasStaticAttributeTest + +
+ +
+ assertContains() + assertContains() + assertNotContains() + assertAttributeContains() + assertAttributeNotContains() + assertContains(mixed $needle, Iterator|array $haystack[, string $message = '']) + Signale une erreur identifiée par $message si $needle n'est pas un élément de $haystack. + assertNotContains() est l'inverse de cette assertion et prend les mêmes arguments. + assertAttributeContains() et assertAttributeNotContains() sont des encapsulateurs de commodités qui utilisent un attribut public, protected, ou private d'une classe ou d'un objet en tant que haystack. + + Utilisation de assertContains() + assertContains(4, [1, 2, 3]); + } +} +?>]]> + phpunit ContainsTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) ContainsTest::testFailure +Failed asserting that an array contains 4. + +/home/sb/ContainsTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + + + assertContains(string $needle, string $haystack[, string $message = '', boolean $ignoreCase = false]) + Signale une erreur identifiée par $message si $needle n'est pas une sous-chaine de $haystack. + Si $ignoreCase est true, ce test sera sensible à la casse. + + Utilisation de assertContains() + assertContains('baz', 'foobar'); + } +} +?>]]> + phpunit ContainsTest + + + + Utilisation de assertContains() with $ignoreCase + assertContains('foo', 'FooBar'); + } + + public function testOK() + { + $this->assertContains('foo', 'FooBar', '', true); + } +} +?>]]> + phpunit ContainsTest + +
+ +
+ assertContainsOnly() + assertContainsOnly() + assertNotContainsOnly() + assertAttributeContainsOnly() + assertAttributeNotContainsOnly() + assertContainsOnly(string $type, Iterator|array $haystack[, boolean $isNativeType = null, string $message = '']) + Signale une erreur identifiée par $message si $haystack ne contient pas seulement des valeurs du type $type. + $isNativeType indique si $type est un type PHP natif ou non. + assertNotContainsOnly() est l'inverse de cette assertion et prend les mêmes arguments. + assertAttributeContainsOnly() et assertAttributeNotContainsOnly() sont des encapsulateurs de commodités qui utilisent l'attribut public, protected, ou private d'une classe ou d'un objet en tant que haystack. + + Utilisation de assertContainsOnly() + assertContainsOnly('string', ['1', '2', 3]); + } +} +?>]]> + phpunit ContainsOnlyTest '1' + 1 => '2' + 2 => 3 +) contains only values of type "string". + +/home/sb/ContainsOnlyTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1.]]> + +
+
+ assertContainsOnlyInstancesOf() + assertContainsOnlyInstancesOf() + assertContainsOnlyInstancesOf(string $classname, Traversable|array $haystack[, string $message = '']) + Signale une erreur identifiée par $message si $haystack ne contient pas seulement des intance de la classe $classname. + + Utilisation de assertContainsOnlyInstancesOf() + assertContainsOnlyInstancesOf( + Foo::class, + [new Foo, new Bar, new Foo] + ); + } +} +?>]]> + phpunit ContainsOnlyInstancesOfTest Bar Object(...)) is an instance of class "Foo". + +/home/sb/ContainsOnlyInstancesOfTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1.]]> + +
+
+ assertCount() + assertCount() + assertNotCount() + assertCount($expectedCount, $haystack[, string $message = '']) + Signale une erreur identifiée par $message si le nombre d'éléments dans $haystack n'est pas $expectedCount. + assertNotCount() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertCount() + assertCount(0, ['foo']); + } +} +?>]]> + phpunit CountTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 4.75Mb + +There was 1 failure: + +1) CountTest::testFailure +Failed asserting that actual size 1 matches expected size 0. + +/home/sb/CountTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertDirectoryExists() + assertDirectoryExists() + assertDirectoryNotExists() + assertDirectoryExists(string $directory[, string $message = '']) + Signale une erreur identifiée par $message si le répertoire spécifié par $directory n'existe pas. + assertDirectoryNotExists() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertDirectoryExists() + assertDirectoryExists('/path/to/directory'); + } +} +?>]]> + phpunit DirectoryExistsTest + +
+ +
+ assertDirectoryIsReadable() + assertDirectoryIsReadable() + assertDirectoryNotIsReadable() + assertDirectoryIsReadable(string $directory[, string $message = '']) + Signale une erreur identifiée par $message si le répertoire spécifié par $directory n'est pas un répertoire ou n'est pas accessible en lecture. + assertDirectoryNotIsReadable() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertDirectoryIsReadable() + assertDirectoryIsReadable('/path/to/directory'); + } +} +?>]]> + phpunit DirectoryIsReadableTest + +
+ +
+ assertDirectoryIsWritable() + assertDirectoryIsWritable() + assertDirectoryNotIsWritable() + assertDirectoryIsWritable(string $directory[, string $message = '']) + Signale une erreur identifiée par $message si le répertoire spécifié par $directory n'est pas un répertoire accessible en écriture. + assertDirectoryNotIsWritable() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertDirectoryIsWritable() + assertDirectoryIsWritable('/path/to/directory'); + } +} +?>]]> + phpunit DirectoryIsWritableTest + +
+ +
+ assertEmpty() + assertEmpty() + assertNotEmpty() + assertAttributeEmpty() + assertAttributeNotEmpty() + assertEmpty(mixed $actual[, string $message = '']) + Signale une erreur identifiée par $message si $actual n'est pas vide. + assertNotEmpty() est l'inverse de cette assertion et prend les mêmes arguments. + assertAttributeEmpty() et assertAttributeNotEmpty() sont des encapsulateurs de commodités qui peuvent être appliqués à un attribut public, protected ou private d'une classe ou d'un objet. + + Utilisation de assertEmpty() + assertEmpty(['foo']); + } +} +?>]]> + phpunit EmptyTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 4.75Mb + +There was 1 failure: + +1) EmptyTest::testFailure +Failed asserting that an array is empty. + +/home/sb/EmptyTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertEqualXMLStructure() + assertEqualXMLStructure() + assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement[, boolean $checkAttributes = false, string $message = '']) + Signale une erreur identifiée par $message si la structure XML du DOMElement dans $actualElement n'est pas égale à la structure XML du DOMElement dans $expectedElement. + + Utilisation de assertEqualXMLStructure() + assertEqualXMLStructure($expected, $actual); + } + + public function testFailureWithDifferentNodeAttributes() + { + $expected = new DOMDocument; + $expected->loadXML(''); + + $actual = new DOMDocument; + $actual->loadXML(''); + + $this->assertEqualXMLStructure( + $expected->firstChild, $actual->firstChild, true + ); + } + + public function testFailureWithDifferentChildrenCount() + { + $expected = new DOMDocument; + $expected->loadXML(''); + + $actual = new DOMDocument; + $actual->loadXML(''); + + $this->assertEqualXMLStructure( + $expected->firstChild, $actual->firstChild + ); + } + + public function testFailureWithDifferentChildren() + { + $expected = new DOMDocument; + $expected->loadXML(''); + + $actual = new DOMDocument; + $actual->loadXML(''); + + $this->assertEqualXMLStructure( + $expected->firstChild, $actual->firstChild + ); + } +} +?>]]> + phpunit EqualXMLStructureTest + +
+ +
+ assertEquals() + assertEquals() + assertNotEquals() + assertAttributeEquals() + assertAttributeNotEquals() + assertEquals(mixed $expected, mixed $actual[, string $message = '']) + Signale une erreur identifiée par $message si les deux variables $expected et $actual ne sont pas égales. + assertNotEquals() est l'inverse de cette assertion et prend les mêmes arguments. + assertAttributeEquals() et assertAttributeNotEquals() sont des encapsulateurs de commodités qui utilisent un attribut public, protected ou private d'une classe ou d'un objet en tant que valeur. + + Utilisation de assertEquals() + assertEquals(1, 0); + } + + public function testFailure2() + { + $this->assertEquals('bar', 'baz'); + } + + public function testFailure3() + { + $this->assertEquals("foo\nbar\nbaz\n", "foo\nbah\nbaz\n"); + } +} +?>]]> + phpunit EqualsTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +FFF + +Time: 0 seconds, Memory: 5.25Mb + +There were 3 failures: + +1) EqualsTest::testFailure +Failed asserting that 0 matches expected 1. + +/home/sb/EqualsTest.php:6 + +2) EqualsTest::testFailure2 +Failed asserting that two strings are equal. +--- Expected ++++ Actual +@@ @@ +-'bar' ++'baz' + +/home/sb/EqualsTest.php:11 + +3) EqualsTest::testFailure3 +Failed asserting that two strings are equal. +--- Expected ++++ Actual +@@ @@ + 'foo +-bar ++bah + baz + ' + +/home/sb/EqualsTest.php:16 + +FAILURES! +Tests: 3, Assertions: 3, Failures: 3. + + + Des comparaisons plus spécialisées sont utilisés pour des types d'arguments spécifiques pour $expected et $actual, voir ci-dessous. + + assertEquals(float $expected, float $actual[, string $message = '', float $delta = 0]) + Signale une erreur identifiée par $message si l'écart entre les deux nombres réels $expected et $actual est inférieur à $delta. + Lisez "What Every Computer Scientist Should Know About Floating-Point Arithmetic" pour comprendre pourquoi $delta est nécessaire. + + Utilisation de assertEquals() avec des nombres réels + assertEquals(1.0, 1.1, '', 0.2); + } + + public function testFailure() + { + $this->assertEquals(1.0, 1.1); + } +} +?>]]> + phpunit EqualsTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +.F + +Time: 0 seconds, Memory: 5.75Mb + +There was 1 failure: + +1) EqualsTest::testFailure +Failed asserting that 1.1 matches expected 1.0. + +/home/sb/EqualsTest.php:11 + +FAILURES! +Tests: 2, Assertions: 2, Failures: 1. + + + assertEquals(DOMDocument $expected, DOMDocument $actual[, string $message = '']) + Signale une erreur identifiée par $message si la forme cannonique sans commentaires des documents XML représentéspar les deux objets DOMDocument $expected et $actual ne sont pas égaux. + + Utilisation de assertEquals() avec des objets DOMDocument + loadXML(''); + + $actual = new DOMDocument; + $actual->loadXML(''); + + $this->assertEquals($expected, $actual); + } +} +?>]]> + phpunit EqualsTest +- +- +- ++ ++ ++ + +/home/sb/EqualsTest.php:12 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1.]]> + + + assertEquals(object $expected, object $actual[, string $message = '']) + Signale une erreur identifiée par $message si les deux objets $expected et $actual n'ont pas les attributs avec des valeurs égales. + + Utilisation de assertEquals() avec des objets + foo = 'foo'; + $expected->bar = 'bar'; + + $actual = new stdClass; + $actual->foo = 'bar'; + $actual->baz = 'bar'; + + $this->assertEquals($expected, $actual); + } +} +?>]]> + phpunit EqualsTest 'foo' +- 'bar' => 'bar' ++ 'foo' => 'bar' ++ 'baz' => 'bar' + ) + +/home/sb/EqualsTest.php:14 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1.]]> + + + assertEquals(array $expected, array $actual[, string $message = '']) + Signale une erreur identifiée par $message si les deux tableaux $expected et $actual ne sont pas égaux. + + + Utilisation de assertEquals() avec des tableaux + assertEquals(['a', 'b', 'c'], ['a', 'c', 'd']); + } +} +?>]]> + phpunit EqualsTest 'a' +- 1 => 'b' +- 2 => 'c' ++ 1 => 'c' ++ 2 => 'd' + ) + +/home/sb/EqualsTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1.]]> + +
+ +
+ assertFalse() + assertFalse() + assertFalse(bool $condition[, string $message = '']) + Signale une erreur identifiée par $message si $condition est true. + assertNotFalse() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertFalse() + assertFalse(true); + } +} +?>]]> + phpunit FalseTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) FalseTest::testFailure +Failed asserting that true is false. + +/home/sb/FalseTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertFileEquals() + assertFileEquals() + assertFileNotEquals() + assertFileEquals(string $expected, string $actual[, string $message = '']) + Signale une erreur identifiée par $message si le fichier spécifié par $expected n'a pas les mêmes contenus que le fichier spécifié par $actual. + assertFileNotEquals() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertFileEquals() + assertFileEquals('/home/sb/expected', '/home/sb/actual'); + } +} +?>]]> + phpunit FileEqualsTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.25Mb + +There was 1 failure: + +1) FileEqualsTest::testFailure +Failed asserting that two strings are equal. +--- Expected ++++ Actual +@@ @@ +-'expected ++'actual + ' + +/home/sb/FileEqualsTest.php:6 + +FAILURES! +Tests: 1, Assertions: 3, Failures: 1. + +
+ +
+ assertFileExists() + assertFileExists() + assertFileNotExists() + assertFileExists(string $filename[, string $message = '']) + Signale une erreur identifiée par $message si le fichier spécifié par $filename n'existe pas. + assertFileNotExists() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertFileExists() + assertFileExists('/path/to/file'); + } +} +?>]]> + phpunit FileExistsTest + +
+ +
+ assertFileIsReadable() + assertFileIsReadable() + assertFileNotIsReadable() + assertFileIsReadable(string $filename[, string $message = '']) + Signale une erreur identifiée par $message si le fichier spécifié par $filename n'est pas un fichier ou n'est pas accessible en lecture. + assertFileNotIsReadable() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertFileIsReadable() + assertFileIsReadable('/path/to/file'); + } +} +?>]]> + phpunit FileIsReadableTest + +
+ +
+ assertFileIsWritable() + assertFileIsWritable() + assertFileNotIsWritable() + assertFileIsWritable(string $filename[, string $message = '']) + Signale une erreur identifiée par $message si le fichier spécifié par $filename n'est pas un fichier ou n'est pas accessible en éciture. + assertFileNotIsWritable() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertFileIsWritable() + assertFileIsWritable('/path/to/file'); + } +} +?>]]> + phpunit FileIsWritableTest + +
+ +
+ assertGreaterThan() + assertGreaterThan() + assertAttributeGreaterThan() + assertGreaterThan(mixed $expected, mixed $actual[, string $message = '']) + Signale une erreur identifiée par $message si la valeur de $actual n'est pas plus élevée que la valeur de $expected. + assertAttributeGreaterThan() est un encapsulateur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet en tant que valeur. + + Utilisation de assertGreaterThan() + assertGreaterThan(2, 1); + } +} +?>]]> + phpunit GreaterThanTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) GreaterThanTest::testFailure +Failed asserting that 1 is greater than 2. + +/home/sb/GreaterThanTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertGreaterThanOrEqual() + assertGreaterThanOrEqual() + assertAttributeGreaterThanOrEqual() + assertGreaterThanOrEqual(mixed $expected, mixed $actual[, string $message = '']) + Signale une erreur identifiée par $message si la valeur de $actual n'est pas plus grande ou égale à la valeur de $expected. + assertAttributeGreaterThanOrEqual() est un encapsulateur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet en tant que valeur. + + Utilisation de assertGreaterThanOrEqual() + assertGreaterThanOrEqual(2, 1); + } +} +?>]]> + phpunit GreaterThanOrEqualTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.25Mb + +There was 1 failure: + +1) GreatThanOrEqualTest::testFailure +Failed asserting that 1 is equal to 2 or is greater than 2. + +/home/sb/GreaterThanOrEqualTest.php:6 + +FAILURES! +Tests: 1, Assertions: 2, Failures: 1. + +
+ +
+ assertInfinite() + assertInfinite() + assertFinite() + assertInfinite(mixed $variable[, string $message = '']) + Signale une erreur identifiée par $message si $variable n'est pas INF. + assertFinite() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertInfinite() + assertInfinite(1); + } +} +?>]]> + phpunit InfiniteTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) InfiniteTest::testFailure +Failed asserting that 1 is infinite. + +/home/sb/InfiniteTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertInstanceOf() + assertInstanceOf() + assertNotInstanceOf() + assertAttributeInstanceOf() + assertAttributeNotInstanceOf() + assertInstanceOf($expected, $actual[, $message = '']) + Signale une erreur identifiée par $message si $actual n'est pas une instance de $expected. + assertNotInstanceOf() est l'inverse de cette assertion et prend les mêmes arguments. + assertAttributeInstanceOf() et assertAttributeNotInstanceOf() sont des encapsulateurs de commodités qui peuvent être appliqués à un attribut public, protected ou private d'une classe ou d'un objet. + + Utilisation de assertInstanceOf() + assertInstanceOf(RuntimeException::class, new Exception); + } +} +?>]]> + phpunit InstanceOfTest + +
+ +
+ assertInternalType() + assertInternalType() + assertNotInternalType() + assertAttributeInternalType() + assertAttributeNotInternalType() + assertInternalType($expected, $actual[, $message = '']) + Signale une erreur identifiée par $message si $actual n'est pas du type $expected. + assertNotInternalType() est l'inverse de cette assertion et prend les mêmes arguments. + assertAttributeInternalType() et assertAttributeNotInternalType() sont des encapsulateurs de commodités qui peuvent être appliqués a un attribut public, protected ou private d'une classe ou d'un objet. + + Utilisation de assertInternalType() + assertInternalType('string', 42); + } +} +?>]]> + phpunit InternalTypeTest + +
+ +
+ assertIsReadable() + assertIsReadable() + assertNotIsReadable() + assertIsReadable(string $filename[, string $message = '']) + Signale une erreur identifiée par $message si le fichier ou le répertoire spécifié par $filename n'est pas accessible en lecture. + assertNotIsReadable() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertIsReadable() + assertIsReadable('/path/to/unreadable'); + } +} +?>]]> + phpunit IsReadableTest + +
+ +
+ assertIsWritable() + assertIsWritable() + assertNotIsWritable() + assertIsWritable(string $filename[, string $message = '']) + Signale une erreur identifiée par $message si le fichier ou le répertoire spécifié par $filename n'est pas accessible en écriture. + assertNotIsWritable() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertIsWritable() + assertIsWritable('/path/to/unwritable'); + } +} +?>]]> + phpunit IsWritableTest + +
+ +
+ assertJsonFileEqualsJsonFile() + assertJsonFileEqualsJsonFile() + assertJsonFileNotEqualsJsonFile() + assertJsonFileEqualsJsonFile(mixed $expectedFile, mixed $actualFile[, string $message = '']) + + Signale une erreur identifiée par $message si la valeur de $actualFile ne correspond pas à la valeur de + $expectedFile. + + + Utilisation de assertJsonFileEqualsJsonFile() + assertJsonFileEqualsJsonFile( + 'path/to/fixture/file', 'path/to/actual/file'); + } +} +?>]]> + phpunit JsonFileEqualsJsonFileTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) JsonFileEqualsJsonFile::testFailure +Failed asserting that '{"Mascot":"Tux"}' matches JSON string "["Mascott", "Tux", "OS", "Linux"]". + +/home/sb/JsonFileEqualsJsonFileTest.php:5 + +FAILURES! +Tests: 1, Assertions: 3, Failures: 1. + +
+ +
+ assertJsonStringEqualsJsonFile() + assertJsonStringEqualsJsonFile() + assertJsonStringNotEqualsJsonFile() + assertJsonStringEqualsJsonFile(mixed $expectedFile, mixed $actualJson[, string $message = '']) + + Signale une erreur identifiée par $message si la valeur de $actualJson ne correspond pas à la valeur de + $expectedFile. + + + Utilisation de assertJsonStringEqualsJsonFile() + assertJsonStringEqualsJsonFile( + 'path/to/fixture/file', json_encode(['Mascot' => 'ux']) + ); + } +} +?>]]> + phpunit JsonStringEqualsJsonFileTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) JsonStringEqualsJsonFile::testFailure +Failed asserting that '{"Mascot":"ux"}' matches JSON string "{"Mascott":"Tux"}". + +/home/sb/JsonStringEqualsJsonFileTest.php:5 + +FAILURES! +Tests: 1, Assertions: 3, Failures: 1. + +
+ +
+ assertJsonStringEqualsJsonString() + assertJsonStringEqualsJsonString() + assertJsonStringNotEqualsJsonString() + assertJsonStringEqualsJsonString(mixed $expectedJson, mixed $actualJson[, string $message = '']) + + Signale une erreur identifiée par $message si la valeur de $actualJson ne correspond pas à la valeur de + $expectedJson. + + + Utilisation de assertJsonStringEqualsJsonString() + assertJsonStringEqualsJsonString( + json_encode(['Mascot' => 'Tux']), + json_encode(['Mascot' => 'ux']) + ); + } +} +?>]]> + phpunit JsonStringEqualsJsonStringTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) JsonStringEqualsJsonStringTest::testFailure +Failed asserting that two objects are equal. +--- Expected ++++ Actual +@@ @@ + stdClass Object ( + - 'Mascot' => 'Tux' + + 'Mascot' => 'ux' +) + +/home/sb/JsonStringEqualsJsonStringTest.php:5 + +FAILURES! +Tests: 1, Assertions: 3, Failures: 1. + +
+ +
+ assertLessThan() + assertLessThan() + assertAttributeLessThan() + assertLessThan(mixed $expected, mixed $actual[, string $message = '']) + Signale une erreur identifiée par $message si la valeur de $actual n'est pas plus petit que $expected. + assertAttributeLessThan() est un encapsulateur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet en tant que valeur. + + Utilisation de assertLessThan() + assertLessThan(1, 2); + } +} +?>]]> + phpunit LessThanTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) LessThanTest::testFailure +Failed asserting that 2 is less than 1. + +/home/sb/LessThanTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertLessThanOrEqual() + assertLessThanOrEqual() + assertAttributeLessThanOrEqual() + assertLessThanOrEqual(mixed $expected, mixed $actual[, string $message = '']) + Signale une erreur identifiée par $message si la valeur de $actual n'est pas plus petite ou égale à la valeur de $expected. + assertAttributeLessThanOrEqual() est un encapsulateur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet en tant que valeur. + + Utilisation de assertLessThanOrEqual() + assertLessThanOrEqual(1, 2); + } +} +?>]]> + phpunit LessThanOrEqualTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.25Mb + +There was 1 failure: + +1) LessThanOrEqualTest::testFailure +Failed asserting that 2 is equal to 1 or is less than 1. + +/home/sb/LessThanOrEqualTest.php:6 + +FAILURES! +Tests: 1, Assertions: 2, Failures: 1. + +
+ +
+ assertNan() + assertNan() + assertNan(mixed $variable[, string $message = '']) + Signale une erreur identifiée par $message si $variable n'est pas NAN. + + Utilisation de assertNan() + assertNan(1); + } +} +?>]]> + phpunit NanTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) NanTest::testFailure +Failed asserting that 1 is nan. + +/home/sb/NanTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertNull() + assertNull() + assertNotNull() + assertNull(mixed $variable[, string $message = '']) + Signale une erreur identifiée par $message si $variable n'est pas null. + assertNotNull() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertNull() + assertNull('foo'); + } +} +?>]]> + phpunit NotNullTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) NullTest::testFailure +Failed asserting that 'foo' is null. + +/home/sb/NotNullTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertObjectHasAttribute() + assertObjectHasAttribute() + assertObjectNotHasAttribute() + assertObjectHasAttribute(string $attributeName, object $object[, string $message = '']) + Signale une erreur identifiée par $message si $object->attributeName n'existe pas. + assertObjectNotHasAttribute() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertObjectHasAttribute() + assertObjectHasAttribute('foo', new stdClass); + } +} +?>]]> + phpunit ObjectHasAttributeTest + +
+ +
+ assertRegExp() + assertRegExp() + assertNotRegExp() + assertRegExp(string $pattern, string $string[, string $message = '']) + Signale une erreur identifiée par $message si $string ne correspond pas a l'expression régulière $pattern. + assertNotRegExp() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertRegExp() + assertRegExp('/foo/', 'bar'); + } +} +?>]]> + phpunit RegExpTest + +
+ +
+ assertStringMatchesFormat() + assertStringMatchesFormat() + assertStringNotMatchesFormat() + assertStringMatchesFormat(string $format, string $string[, string $message = '']) + Signale une erreur identifiée par $message si $string ne correspond pas à la chaine $format. + assertStringNotMatchesFormat() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertStringMatchesFormat() + assertStringMatchesFormat('%i', 'foo'); + } +} +?>]]> + phpunit StringMatchesFormatTest + + Le format de chaine peut contenir les arguments suivants: + + %e: Représente un séparateur de répertoire, par exemple / sur Linux. + %s: Un ou plusieurs de n'importe quoi (caractère ou espace) sauf le caractère de fin de ligne. + %S: Zéro ou pusieurs de n'importe quoi (caractère ou espace) sauf le caractère de fin de ligne. + %a: Un ou plusieurs de n'importe quoi (caractère ou espace) incluant le caratère de fin de ligne. + %A: Zéro ou pusieurs de n'importe quoi (caractère ou espace) incluant le caratère de fin de ligne. + %w: Zéro ou plusieurs caratères espace. + %i: Une valeure entière signée, par exemple +3142, -3142. + %d: Une valeure entière non signée, par exemple 123456. + %x: Un ou plusieurs caractères hexadecimaux. Ce sont les caractères compris entre 0-9, a-f, A-F. + %f: Un nombre à virgule flottante, par exemple: 3.142, -3.142, 3.142E-10, 3.142e+10. + %c: Un caractère unique quel qu'il soit. + +
+ +
+ assertStringMatchesFormatFile() + assertStringMatchesFormatFile() + assertStringNotMatchesFormatFile() + assertStringMatchesFormatFile(string $formatFile, string $string[, string $message = '']) + Signale une erreur identifiée par $message si $string ne correspond pas au contenu du $formatFile. + assertStringNotMatchesFormatFile() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertStringMatchesFormatFile() + assertStringMatchesFormatFile('/path/to/expected.txt', 'foo'); + } +} +?>]]> + phpunit StringMatchesFormatFileTest + +
+ +
+ assertSame() + assertSame() + assertNotSame() + assertAttributeSame() + assertAttributeNotSame() + assertSame(mixed $expected, mixed $actual[, string $message = '']) + Signale une erreur identifiée par $message si les deux variables $expected et $actual ne sont pas du même type et n'ont pas la même valeur. + assertNotSame() est l'inverse de cette assertion et prend les mêmes arguments. + assertAttributeSame() et assertAttributeNotSame() sont des encapsulateurs de commodités qui utilisent un attribut public, protected ou private d'une classe ou d'un objet en tant que valeur. + + Utilisation de assertSame() + assertSame('2204', 2204); + } +} +?>]]> + phpunit SameTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) SameTest::testFailure +Failed asserting that 2204 is identical to '2204'. + +/home/sb/SameTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + + + assertSame(object $expected, object $actual[, string $message = '']) + Signale une erreur identifiée par $message si les deux variables $expected et $actual ne référencent pas le même objet. + + + Utilisation de assertSame() with objects + assertSame(new stdClass, new stdClass); + } +} +?>]]> + phpunit SameTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 4.75Mb + +There was 1 failure: + +1) SameTest::testFailure +Failed asserting that two variables reference the same object. + +/home/sb/SameTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertStringEndsWith() + assertStringEndsWith() + assertStringEndsNotWith() + assertStringEndsWith(string $suffix, string $string[, string $message = '']) + Signale une erreur identifiée par $message si $string ne termine pas par $suffix. + assertStringEndsNotWith() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertStringEndsWith() + assertStringEndsWith('suffix', 'foo'); + } +} +?>]]> + phpunit StringEndsWithTest + +
+ +
+ assertStringEqualsFile() + assertStringEqualsFile() + assertStringNotEqualsFile() + assertStringEqualsFile(string $expectedFile, string $actualString[, string $message = '']) + Signale une erreur identifiée par $message le fichier spécifié par $expectedFile n'a pas $actualString comme contenu. + assertStringNotEqualsFile() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertStringEqualsFile() + assertStringEqualsFile('/home/sb/expected', 'actual'); + } +} +?>]]> + phpunit StringEqualsFileTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.25Mb + +There was 1 failure: + +1) StringEqualsFileTest::testFailure +Failed asserting that two strings are equal. +--- Expected ++++ Actual +@@ @@ +-'expected +-' ++'actual' + +/home/sb/StringEqualsFileTest.php:6 + +FAILURES! +Tests: 1, Assertions: 2, Failures: 1. + +
+ +
+ assertStringStartsWith() + assertStringStartsWith() + assertStringStartsNotWith() + assertStringStartsWith(string $prefix, string $string[, string $message = '']) + Signale une erreur identifiée par $message si $string ne commence pas par $prefix. + assertStringStartsNotWith() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertStringStartsWith() + assertStringStartsWith('prefix', 'foo'); + } +} +?>]]> + phpunit StringStartsWithTest + +
+ +
+ assertThat() + assertThat() + + + Des assertions plus complexes peuvent être formulées en utilisant les + classes PHPUnit_Framework_Constraint. Elles peuvent être + evaluées avec la méthode assertThat(). + montre comment les contraintes + logicalNot() et equalTo() + peuvent être utilisées pour exprimer la même assertion que + assertNotEquals(). + + + assertThat(mixed $value, PHPUnit_Framework_Constraint $constraint[, $message = '']) + Signale une erreur identifiée par $messagesi $value ne correspond pas à $constraint. + + Utilisation de assertThat() + assertThat( + $theBiscuit, + $this->logicalNot( + $this->equalTo($myBiscuit) + ) + ); + } +} +?>]]> + + + + montre les + classes PHPUnit_Framework_Constraint disponibles. + + + + Contraintes + + + + + Contrainte + Signification + + + + + attribute() + PHPUnit_Framework_Constraint_Attribute attribute(PHPUnit_Framework_Constraint $constraint, $attributeName) + Contrainte qui applique une autre contrainte à un attribut d'une classe ou d'un objet. + + + anything() + PHPUnit_Framework_Constraint_IsAnything anything() + Contrainte qui accepte toute valeur d'entrée. + + + arrayHasKey() + PHPUnit_Framework_Constraint_ArrayHasKey arrayHasKey(mixed $key) + Ccontrainte qui valide que le tableau évalué a une clé donnée. + + + contains() + PHPUnit_Framework_Constraint_TraversableContains contains(mixed $value) + Contrainte qui valide que le tableau ou l'objet qui implémente l'interface Iterator évalué contient une valeur donnée. + + + containsOnly() + PHPUnit_Framework_Constraint_TraversableContainsOnly containsOnly(string $type) + Contrainte qui valide que le tableau ou l'objet qui implémente l'interface Iterator évalué ne contient que des valeurs d'un type donné. + + + containsOnlyInstancesOf() + PHPUnit_Framework_Constraint_TraversableContainsOnly containsOnlyInstancesOf(string $classname) + Contrainte qui valide que le tableau ou l'objet qui implémente l'interface Iterator évalué ne contient que des instance d'une classe donnée. + + + equalTo() + PHPUnit_Framework_Constraint_IsEqual equalTo($value, $delta = 0, $maxDepth = 10) + Contrainte qui vérifie si une valeur est égale à une autre. + + + attributeEqualTo() + PHPUnit_Framework_Constraint_Attribute attributeEqualTo($attributeName, $value, $delta = 0, $maxDepth = 10) + Contrainte qui vérifie si une valeur est égale à un attribut d'une classe ou d'un objet. + + + directoryExists() + PHPUnit_Framework_Constraint_DirectoryExists directoryExists() + Contrainte qui vérifie si le répertoire évalué existe. + + + fileExists() + PHPUnit_Framework_Constraint_FileExists fileExists() + Contrainte qui vérifie si le fichier(name) évalué existe. + + + isReadable() + PHPUnit_Framework_Constraint_IsReadable isReadable() + Contrainte qui vérifie si le fichier(name) évalué est accessible en écriture. + + + isWritable() + PHPUnit_Framework_Constraint_IsWritable isWritable() + Contrainte qui vérifie si le fichier(name) évalué est accessible en écriture. + + + greaterThan() + PHPUnit_Framework_Constraint_GreaterThan greaterThan(mixed $value) + Contrainte qui valide que la valeur évaluée est supérieure à une valeur donnée. + + + greaterThanOrEqual() + PHPUnit_Framework_Constraint_Or greaterThanOrEqual(mixed $value) + Contrainte qui valide que la valeur évaluée est supérieure ou égale à une valeur donnée. + + + classHasAttribute() + PHPUnit_Framework_Constraint_ClassHasAttribute classHasAttribute(string $attributeName) + La contrainte qui valide que la classe évaluée possède un attribut donné. + + + classHasStaticAttribute() + PHPUnit_Framework_Constraint_ClassHasStaticAttribute classHasStaticAttribute(string $attributeName) + La contrainte qui valide que la classe évaluée possède un attribut statique donné. + + + hasAttribute() + PHPUnit_Framework_Constraint_ObjectHasAttribute hasAttribute(string $attributeName) + La contrainte qui valide que l'objet évalué possède un attribut donné. + + + identicalTo() + PHPUnit_Framework_Constraint_IsIdentical identicalTo(mixed $value) + Contrainte qui valide qu'une valeur est identique à une autre. + + + isFalse() + PHPUnit_Framework_Constraint_IsFalse isFalse() + Contrainte qui valide qu'une valeur évaluée est false. + + + isInstanceOf() + PHPUnit_Framework_Constraint_IsInstanceOf isInstanceOf(string $className) + La contrainte qui VALIDE que l'objet évalué est une instance d'une classe donnée. + + + isNull() + PHPUnit_Framework_Constraint_IsNull isNull() + Contrainte qui valide qu'une valeur évaluée est null. + + + isTrue() + PHPUnit_Framework_Constraint_IsTrue isTrue() + Contrainte qui valide qu'une valeur évaluée est true. + + + isType() + PHPUnit_Framework_Constraint_IsType isType(string $type) + Contrainte qui valide que la valeur évaluée est d'un type spécifié. + + + lessThan() + PHPUnit_Framework_Constraint_LessThan lessThan(mixed $value) + Constraint that asserts that the value it is evaluated for is smaller than a given value. + + + lessThanOrEqual() + PHPUnit_Framework_Constraint_Or lessThanOrEqual(mixed $value) + Contrainte qui valide que la valeur évaluée est inférieure ou égale à une valeur donnée. + + + logicalAnd() + logicalAnd() + ET logique (AND). + + + logicalNot() + logicalNot(PHPUnit_Framework_Constraint $constraint) + NON logique (NOT). + + + logicalOr() + logicalOr() + OU logique (OR). + + + logicalXor() + logicalXor() + OU exclusif logique (XOR). + + + matchesRegularExpression() + PHPUnit_Framework_Constraint_PCREMatch matchesRegularExpression(string $pattern) + Contrainte qui valide que la chaine évaluée correspond à une expression régulière. + + + stringContains() + PHPUnit_Framework_Constraint_StringContains stringContains(string $string, bool $case) + Contrainte qui valide que la chaine évaluée contient une chaine donnée. + + + stringEndsWith() + PHPUnit_Framework_Constraint_StringEndsWith stringEndsWith(string $suffix) + Contrainte qui valide que la chaine évaluée termine par un suffix donné. + + + stringStartsWith() + PHPUnit_Framework_Constraint_StringStartsWith stringStartsWith(string $prefix) + Contrainte qui valide que la chaine évaluée commence par un préfix donné. + + + +
+
+ +
+ assertTrue() + assertTrue() + assertTrue(bool $condition[, string $message = '']) + Signale une erreur identifiée par $message si $condition est false. + assertNotTrue() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertTrue() + assertTrue(false); + } +} +?>]]> + phpunit TrueTest +PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + +F + +Time: 0 seconds, Memory: 5.00Mb + +There was 1 failure: + +1) TrueTest::testFailure +Failed asserting that false is true. + +/home/sb/TrueTest.php:6 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1. + +
+ +
+ assertXmlFileEqualsXmlFile() + assertXmlFileEqualsXmlFile() + assertXmlFileNotEqualsXmlFile() + assertXmlFileEqualsXmlFile(string $expectedFile, string $actualFile[, string $message = '']) + Signale une erreur identifiée par $message si le document XML dans $actualFile n'est pas égal au document XML dans $expectedFile. + assertXmlFileNotEqualsXmlFile() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertXmlFileEqualsXmlFile() + assertXmlFileEqualsXmlFile( + '/home/sb/expected.xml', '/home/sb/actual.xml'); + } +} +?>]]> + phpunit XmlFileEqualsXmlFileTest + +- ++ + + +/home/sb/XmlFileEqualsXmlFileTest.php:7 + +FAILURES! +Tests: 1, Assertions: 3, Failures: 1.]]> + +
+ +
+ assertXmlStringEqualsXmlFile() + assertXmlStringEqualsXmlFile() + assertXmlStringNotEqualsXmlFile() + assertXmlStringEqualsXmlFile(string $expectedFile, string $actualXml[, string $message = '']) + Signale une erreur identifiée par $message si le document XML dans $actualXml n'est pas égal au document XML dans $expectedFile. + assertXmlStringNotEqualsXmlFile() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertXmlStringEqualsXmlFile() + assertXmlStringEqualsXmlFile( + '/home/sb/expected.xml', ''); + } +} +?>]]> + phpunit XmlStringEqualsXmlFileTest + +- ++ + + +/home/sb/XmlStringEqualsXmlFileTest.php:7 + +FAILURES! +Tests: 1, Assertions: 2, Failures: 1.]]> + +
+ +
+ assertXmlStringEqualsXmlString() + assertXmlStringEqualsXmlString() + assertXmlStringNotEqualsXmlString() + assertXmlStringEqualsXmlString(string $expectedXml, string $actualXml[, string $message = '']) + Signale une erreur identifiée par $message si le document XML dans $actualXml n'est pas égal au document XML dans $expectedXml. + assertXmlStringNotEqualsXmlString() est l'inverse de cette assertion et prend les mêmes arguments. + + Utilisation de assertXmlStringEqualsXmlString() + assertXmlStringEqualsXmlString( + '', ''); + } +} +?>]]> + phpunit XmlStringEqualsXmlStringTest + +- ++ + + +/home/sb/XmlStringEqualsXmlStringTest.php:7 + +FAILURES! +Tests: 1, Assertions: 1, Failures: 1.]]> + +
+ + diff --git a/src/6.1/fr/book.xml b/src/6.1/fr/book.xml index e332dcfa6..817334e8a 100644 --- a/src/6.1/fr/book.xml +++ b/src/6.1/fr/book.xml @@ -35,16 +35,16 @@ - + + - - + diff --git a/src/6.1/fr/code-coverage-analysis.xml b/src/6.1/fr/code-coverage-analysis.xml index af70511fb..9993ef0ff 100644 --- a/src/6.1/fr/code-coverage-analysis.xml +++ b/src/6.1/fr/code-coverage-analysis.xml @@ -4,140 +4,259 @@ Analyse de couverture de code
- Murali Nandigama + Wikipedia - La beauté du test ne se trouve pas dans l'effort mais dans l'efficience. - - - Savoir ce qui doit être testé est magnifique, et savoir ce qui est testé - est magnifique. + En informatique, la couverture de code est une mesure utilisée pour décrire le + taux de code source testé d'un programme lorsqu'il est testé par une suite de + test particulière. Un programme avec un taux de couverture de code élevée a été plus complètement + testé et a une plus faible chance de contenir des bugs logiciel qu'un programme + avec un taux de couverture de code faible.
Couverture de code + Xdebug Dans ce chapitre, vous apprendrez tout sur la fonctionnalité de couverture - de code de PHPUnit qui fournit une vision interne des parties du code de - production qui sont exécutées quand les tests sont exécutés. Cela aide à - répondre à des questions comme : + de code de PHPUnit qui fournit une vision interne des parties du code de + production qui sont exécutées quand les tests sont exécutés. Elle utilise le composant + PHP_CodeCoverage + qui tire parti de la fonctionnalité de couverture de code fournie par l'extension + Xdebug de PHP. - - - - Comment trouvez-vous le code qui n'est pas encore testé - ou, en d'autres mots, pas - encore couvert par un test ? - - - - Comment mesurez-vous la complétude du test ? - - + + + Xdebug n'est pas distribué au sein de PHPUnit. Si une notice indiquant que + l'extension Xdebug n'est pas chargé en lançant les tests, cela signifie que + Xdebug n'est pas installé ou n'est pas configuré correctement. Avant de pouvoir + utiliser les fonctionnalités de couverture de code dans PHPUnit, vous devez lire + le guide d'installation de Xdebug.. + + - Un exemple de ce que peuvent signifier des statistiques de couverture de code est, - s'il y a une méthode avec 100 lignes de code, et seulement 75 de ces lignes sont réellement - exécutées quand les tests sont lancés, alors la méthode est considérée comme ayant une couverture - de code de 75 pour cent. + PHPUnit peut générer un rapport de couverture de code HTML aussi bien que + des fichiers de log en XML avec les informations de couverture de code dans différents formats + (Clover, Crap4J, PHPUnit). Les informations de couverture de code peuvent aussi être rapporté + en text (et affiché vers STDOUT) et exporté en PHP pour un traitement + ultérieur. - Xdebug - - La fonctionnalité de couverture de code de PHPUnit fait usage du composant - PHP_CodeCoverage - qui, à son tour, tire partie de la fonctionnalité de couverture d'instructions - fournie par l'extension Xdebug - de PHP. + Reportez-vous à pour obtenir la liste des options de ligne de commande + qui contrôlent la fonctionnalité de couverture de code ainsi que pour les paramètres de + configuration appropriés. - - Générons un rapport de couverture de code pour la classe CompteBancaire - de . - - - phpunit --coverage-html ./rapport CompteBancaireTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. +
+ Indicateurs logiciels pour la couverture de code -... + + Différents indicateurs logiciels existent pour mesurer la couverture de code: + -Time: 0 seconds + + + Couverture de codeCouverture de ligne + Couverture de ligne + + + L'indicateur logiciel de couverture de ligne mesure + si chaque ligne exécutable a été exécutée. + + + + + + Couverture de codeCouverture de fonction de méthode + Couverture de fonction de méthode + + + L'indicateur logiciel de couverture de fonction de méthode + mesure si chaque fonction ou méthode à été invoquée. + PHP_CodeCoverage considère qu'une fonction ou une méthode a été couverte + seulement quand toutes ses lignes executables sont couvertes. + + + + + + Couverture de codeCouverture de classe et de trait + Couverture de classe et de trait + + + L'indicateur logiciel de couverture de classe et de trait + mesure si chaque méthode d'une classe ou d'un trait est couverte. + PHP_CodeCoverage considère qu'une classe ou un trait est couvert + seulement quand toutes ses méthodes sont couvertes. + + + + + + Couverture de codeCouverture d'opcode + Couverture d'opcode + + + L'indicateur logiciel de couverture d'opcode mesure + si chaque opcode d'une fonction ou d'une méthode a été executé lors de l'execution + de la suite de test. Une ligne de code se compile habituellement en plus + d'un opcode. La couverture de ligne considère une ligne de code comme couverte + dès que l'un de ses opcode est executé. + + + + + + Couverture de codeCouverture de branche + Couverture de branche + + + L'indicateur logiciel de couverture de branche mesure + si l'expression booléenne de chaque structure de contrôle a été évalué + à true et à false pendant l'execution + de la suite de test. + + + + + + Couverture de codeCouverture de chemin + Couverture de chemin + + + L'indicateur logiciel de couverture de chemin mesure + si chacun des chemins d'execution possible dans une fonction ou une méthode + ont été suivit lors de l'execution de la suite de test. Un chemin d'execution est + une séquence unique de branches depuis l'entrée de la fonction ou + de la méthode jusqu'à sa sortie. + + + + + + L'index Change Risk Anti-Patterns (CRAP) + L'index Change Risk Anti-Patterns (CRAP) + + + L'index Change Risk Anti-Patterns (CRAP) est + calculé en se basant sur la complexité cyclomatique et la couverture de code + d'une portion de code. Du code qui n'est pas trop complexe et qui a une couverture + de code adéquate aurat un index CRAP faible. L'index CRAP peut être baissé + en écrivant des tests et en refactorisant le code pour diminuer sa + complexité. + + + + -OK (3 tests, 3 assertions) + + + L'indicateur logiciel de Couverture d'Opcode, + Couverture de branche, et de + Couverture de chemin ne sont pas encore + supportés par PHP_CodeCoverage. + + +
-Generating report, this may take a moment. +
+ Liste blanche de fichiers - - montre - un extrait du rapport de couverture de code. Les lignes de code qui ont été - exécutés pendant le fonctionnement des tests sont surlignés en vert, les lignes - de code qui sont exécutables mais n'ont pas été exécutées sont surlignées en rouge - et le "code mort" est surligné en gris. Le nombre à gauche du numéro de la ligne de code - indique combien de tests couvrent cette ligne. - + + Couverture de codeListe blanche -
- Couverture de code pour setBalance() + Il est requis de configurer une liste blanche pour dire à + PHPUnit quels fichiers de code source inclure dans le raport de couverture de code. + Cela peut être fait en utilisant l'option de ligne de commande --whitelist + ou via le fichier de configuration (voir ). + - -
+ + Optionnellement, tous les fichiers en liste blanche peut être ajouté au rapport + de couverture de code en paramétrant addUncoveredFilesFromWhitelist="true" + dans votre fichier de configuration PHPUnit (voir ). Cela autorise + l'inclusion de fichiers quine sont pas encore testé du tout. Si vous voulez avoir des + information sur quelles lignes d'un fichier non couvert sont exécutable, + par exemple, vous devez également définir + processUncoveredFilesFromWhitelist="true" dans votre + fichier de configuration PHPUnit (voir ). + - - Cliquer sur le numéro de ligne d'une ligne couverte ouvrira un panneau (voir - ) qui - montre les cas de test qui couvrent cette ligne. - + + + Notez que le chargement des fichiers de code source qui est effectué lorsque + processUncoveredFilesFromWhitelist="true" est défini peut + causer des problèmes quand un fichier de code source contient du code en dehors de la portée + d'une classe ou d'une fonction, par exemple. + + +
-
- Panneau avec l'information des tests couvrant la ligne +
+ Ignorer des blocs de code - -
+ + Annotation + @codeCoverageIgnore + @codeCoverageIgnoreStart + @codeCoverageIgnoreEnd - - Le rapport de couverture de code de notre exemple CompteBancaire - montre que nous n'avons actuellement aucun test qui appellent les méthodes - setBalance(), deposerArgent() et - retirerArgent() avec des valeurs acceptables. - - montre un test qui peut être ajouté à la classe de cas de test - BankAccountTest pour couvrir complètement la classe - CompteBancaire. - + Parfois, vous avez des blocs de code que vous ne pouvez pas tester et que vous pouvez vouloir + ignorer lors de l'analyse de la couverture de code. PHPUnit vous permet de le faire + en utilisant les annotations @codeCoverageIgnore, + @codeCoverageIgnoreStart et + @codeCoverageIgnoreEnd comme montré dans + . + - - Test manquant pour atteindre la couverture de code complète - + Utiliser les annotations <literal>@codeCoverageIgnore</literal>, <literal>@codeCoverageIgnoreStart</literal> et <literal>@codeCoverageIgnoreEnd</literal> + assertEquals(0, $this->compte_bancaire->getBalance()); - $this->compte_bancaire->deposerArgent(1); - $this->assertEquals(1, $this->compte_bancaire->getBalance()); - $this->compte_bancaire->retirerArgent(1); - $this->assertEquals(0, $this->compte_bancaire->getBalance()); } } -?>]]> - - - montre - la couverture de code de la méthode setBalance() avec le test - additionnel. - +if (false) { + // @codeCoverageIgnoreStart + print '*'; + // @codeCoverageIgnoreEnd +} -
- Couverture de code pour <literal>setBalance()</literal> avec un test additionnel +exit; // @codeCoverageIgnore +?>]]> + - -
+ + Les lignes de code ignorées (marquées comme ignorées à l'aide des annotations) + sont comptées comme exécutées (si elles sont exécutables) et ne seront pas + mises en évidence. + +
Spécifier les méthodes couvertes @@ -149,7 +268,7 @@ class BankAccountTest extends PHPUnit_Framework_TestCase L'annotation @covers (voir ) peut être utilisée dans le code de test pour indiquer quelle(s) méthode(s) une méthode de test - veut test. Si elle est fournie, seules les informations de couverture de code pour + veut tester. Si elle est fournie, seules les informations de couverture de code pour la(les) méthode(s) indiquées seront prises en considération. montre un exemple. @@ -158,36 +277,36 @@ class BankAccountTest extends PHPUnit_Framework_TestCase Tests qui indiquent quelle(s) méthode(s) ils veulent couvrir compte_bancaire = new CompteBancaire; + $this->ba = new BankAccount; } /** - * @covers CompteBancaire::getBalance + * @covers BankAccount::getBalance */ - public function testBalanceEstInitialementZero() + public function testBalanceIsInitiallyZero() { - $this->assertEquals(0, $this->compte_bancaire->getBalance()); + $this->assertEquals(0, $this->ba->getBalance()); } /** - * @covers CompteBancaire::retirerArgent + * @covers BankAccount::withdrawMoney */ - public function testBalanceNePeutPasDevenirNegative() + public function testBalanceCannotBecomeNegative() { try { - $this->compte_bancaire->retirerArgent(1); + $this->ba->withdrawMoney(1); } - catch (CompteBancaireException $e) { - $this->assertEquals(0, $this->compte_bancaire->getBalance()); + catch (BankAccountException $e) { + $this->assertEquals(0, $this->ba->getBalance()); return; } @@ -196,16 +315,16 @@ class CompteBancaireTest extends PHPUnit_Framework_TestCase } /** - * @covers CompteBancaire::deposerArgent + * @covers BankAccount::depositMoney */ - public function testBalanceNePeutPasDevenirNegative2() + public function testBalanceCannotBecomeNegative2() { try { - $this->compte_bancaire->deposerArgent(-1); + $this->ba->depositMoney(-1); } - catch (CompteBancaireException $e) { - $this->assertEquals(0, $this->compte_bancaire->getBalance()); + catch (BankAccountException $e) { + $this->assertEquals(0, $this->ba->getBalance()); return; } @@ -214,18 +333,17 @@ class CompteBancaireTest extends PHPUnit_Framework_TestCase } /** - * @covers CompteBancaire::getBalance - * @covers CompteBancaire::deposerArgent - * @covers CompteBancaire::retirerArgent + * @covers BankAccount::getBalance + * @covers BankAccount::depositMoney + * @covers BankAccount::withdrawMoney */ - - public function testDeposerArgent() + public function testDepositWithdrawMoney() { - $this->assertEquals(0, $this->compte_bancaire->getBalance()); - $this->compte_bancaire->deposerArgent(1); - $this->assertEquals(1, $this->compte_bancaire->getBalance()); - $this->compte_bancaire->retirerArgent(1); - $this->assertEquals(0, $this->compte_bancaire->getBalance()); + $this->assertEquals(0, $this->ba->getBalance()); + $this->ba->depositMoney(1); + $this->assertEquals(1, $this->ba->getBalance()); + $this->ba->withdrawMoney(1); + $this->assertEquals(0, $this->ba->getBalance()); } } ?>]]> @@ -246,21 +364,25 @@ class CompteBancaireTest extends PHPUnit_Framework_TestCase Un test qui indique qu'aucune méthode ne doit être couverte addEntry("suzy", "Hello world!"); + $guestbook = new Guestbook(); + $guestbook->addEntry("suzy", "Hello world!"); $queryTable = $this->getConnection()->createQueryTable( - 'livre_d_or', 'SELECT * FROM livre_d_or' + 'guestbook', 'SELECT * FROM guestbook' ); + $expectedTable = $this->createFlatXmlDataSet("expectedBook.xml") - ->getTable("livre_d_or"); + ->getTable("guestbook"); + $this->assertTablesEqual($expectedTable, $queryTable); } } @@ -269,143 +391,34 @@ class IntegrationLivreDOrTest extends PHPUnit_Extensions_Database_TestCase
-
- Ignorer des blocs de code - - - Annotation - @codeCoverageIgnore - @codeCoverageIgnoreStart - @codeCoverageIgnoreEnd - - Parfois, vous avez des blocs de code que vous ne pouvez pas tester et que - voulez ignorer lors de l'analyse de couverture de code. PHPUnit vous permet - de faire cela en utilisant les annotations - @codeCoverageIgnore, - @codeCoverageIgnoreStart et - @codeCoverageIgnoreEnd comme montré dans - . - - - - Utiliser les annotations <literal>@codeCoverageIgnore</literal>, <literal>@codeCoverageIgnoreStart</literal> et <literal>@codeCoverageIgnoreEnd</literal> - ]]> - - - - Les lignes de code qui sont marquées comme devant être ignorées en utilisant - les annotations sont comptées comme exécutées (si elles sont exécutables) et ne - seront pas surlignées. - -
- -
- Inclure et exclure des fichiers - - - Code Coverage - Liste noire - Liste blanche - - Par défaut, tous les fichiers de code source qui contiennent au moins une ligne - de code qui a été exécutée (et seulement ces fichiers) sont inclus dans le rapport. - Les fichiers de code source qui sont inclus dans le rapport peuvent être filtrés en - utilisant une approche par liste noire ou liste blanche. - - - - La liste noire est pré-remplie avec tous les fichiers de code source de - PHPUnit lui-même ainsi que les tests. Quand la liste blanche est vide (par - défaut), le filtrage par liste noire est utilisé. Quand la liste blanche - n'est pas vide, le filtrage par liste blanche est utilisé. Chaque fichier - de la liste blanche est ajouté au rapport de couverture de code, qu'il ait - été exécuté ou pas. Toutes les lignes d'un tel fichier, incluant celles qui - ne sont pas exécutables, sont comptées comme non exécutées. - - - - Quand vous configurez - processUncoveredFilesFromWhitelist="true" - dans votre configuration PHPUnit (voir ) alors ces fichiers - seront à inclure par PHP_CodeCoverage pour calculer correctement le nombre - de lignes exécutables. - - - - - Merci de noter que le chargement des fichiers de code source réalisé - quand processUncoveredFilesFromWhitelist="true" est positionné, - peut poser des problèmes quand un fichier de code source contient du code hors de la portée - d'une classe ou d'une fonction, par exemple. - - - - - Le fichier de configuration XML de PHPUnit (voir ) - peut être utilisé pour contrôler les listes noires et blanches. Utiliser une liste - blanche est recommandé comme meilleure pratique pour contrôler la liste des fichiers inclus dans - le rapport de couverture de code. - -
-
Cas limites - Dans la plupart des cas, on peut dire sans risque que PHPUnit offre - une information de couverture de code "basée sur les lignes" mais du fait - de la façon dont l'information est collectée, il existe quelques cas limites - qui valent la peine d'être mentionnés. + Cette section présente des cas limites remarquables qui conduisent à des informations + de couverture de code prêtant à confusion. ]]> - - +
- diff --git a/src/6.1/fr/configuration.xml b/src/6.1/fr/configuration.xml index 51f1bc553..1af11680f 100644 --- a/src/6.1/fr/configuration.xml +++ b/src/6.1/fr/configuration.xml @@ -1,7 +1,7 @@ - Le fichier de configuration Configuration + Le fichier de configuration XML
PHPUnit @@ -16,8 +16,8 @@ xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/6.1/phpunit.xsd" backupGlobals="true" backupStaticAttributes="false" - - cacheTokens="true" + + cacheTokens="false" colors="false" convertErrorsToExceptions="true" convertNoticesToExceptions="true" @@ -25,23 +25,25 @@ forceCoversAnnotation="false" mapTestClassNameToCoveredClassName="false" printerClass="PHPUnit_TextUI_ResultPrinter" - + processIsolation="false" stopOnError="false" stopOnFailure="false" stopOnIncomplete="false" stopOnSkipped="false" + stopOnRisky="false" testSuiteLoaderClass="PHPUnit_Runner_StandardTestSuiteLoader" - - strict="false" + + timeoutForSmallTests="1" + timeoutForMediumTests="10" + timeoutForLargeTests="60" verbose="false"> ]]> Le fichier de configuration XML ci-dessus correspond au comportement par - défaut du lanceur de tests TextUI documenté dans - . + défaut du lanceur de tests TextUI documenté dans . @@ -50,31 +52,104 @@ + + convertErrorsToExceptions + + + Par défaut, PHPUnit va installer un gestionnaire d'erreur qui converti + les erreurs suivantes en exceptions : + + + + E_WARNING + E_NOTICE + E_USER_ERROR + E_USER_WARNING + E_USER_NOTICE + E_STRICT + E_RECOVERABLE_ERROR + E_DEPRECATED + E_USER_DEPRECATED + + + + Mettre convertErrorsToExceptions à + false désactivera cette fonctionnalité. + + + + convertNoticesToExceptions + + + Si défini à false, le gestionnaire d'erreurs installé + par convertErrorsToExceptions ne convertira pas les erreurs + E_NOTICE, E_USER_NOTICE, ou + E_STRICT en exceptions. + + + + + convertWarningsToExceptions - convertErrorsToExceptions - Peuvent être utilisées pour désactiver la conversion automatique - de toutes les erreurs, avertissement ou information de php en exception. - + Si défini à false, le gestionnaire d'erreurs installé + par convertErrorsToExceptions ne convertira pas les erreurs + E_WARNING ou E_USER_WARNING + en exceptions. + - - forceCoversAnnotation - - - La couverture de code ne sera enregistrée que pour les tests qui - utilisent l'annotation @covers documentée dans - . - - - + + forceCoversAnnotation + + + La couverture de code ne sera enregistrée que pour les tests qui + utilisent l'annotation @covers documentée dans + . + + + - + + timeoutForLargeTests + + + Si les limites de temps basées sur la taille du test sont appliquées alors cet attribut + défini le délai pour tous les tests marqués comme @large. + Si un test ne se termine pas dans le délai configuré, il + échouera. + + + + + timeoutForMediumTests + + + Si les limites de temps basées sur la taille du test sont appliquées alors cet attribut + défini le délai pour tous les tests marqués comme @medium. + Si un test ne se termine pas dans le délai configuré, il + échouera. + + + + + + timeoutForSmallTests + + + Si les limites de temps basées sur la taille du test sont appliquées alors cet attribut + défini le délai pour tous les tests qui ne sont pas marqués comme + @medium or @large. Si un test + ne se termine pas dans le délai configuré, il échouera. + + + +
@@ -84,15 +159,15 @@ Série de tests L'élément ]]> et son ou ses - fils ]]> peuvent être utilisés pour + enfants ]]> peuvent être utilisés pour composer une série de tests à partir des séries de test et des cas de test. - - /chemin/vers/fichiers *Test.php - /chemin/vers/MonTest.php - /chemin/a/exclure + + /path/to/*Test.php files + /path/to/MyTest.php + /path/to/exclude ]]> @@ -100,15 +175,15 @@ En utilisant les attributs phpVersion et phpVersionOperator, une version requise de PHP peut être indiquée. L'exemple ci-dessous ne va ajouter que - les fichiers /chemin/vers/*Test.php et - /chemin/vers/MonTest.php si la version de PHP est + les fichiers /path/to/*Test.php et + /path/to/MyTest.php si la version de PHP est au moins 5.3.0. - - /chemin/vers/fichiers - /chemin/vers/MonTest.php + + /path/to/files + /path/to/MyTest.php ]]> @@ -124,20 +199,21 @@ Groupes de tests - L'élément ]]> et ses fils + L'élément ]]> et ses enfants ]]>, ]]> et ]]> peuvent être utilisés pour choisir - des groupes de tests depuis une série de tests qui doivent (ou ne doivent pas) - être exécutés. + des groupes de tests marqués avec l'annotation @group + (documenté dans ) + qui doivent (ou ne doivent pas) être exécutés. - nom + name - nom + name ]]> @@ -147,39 +223,29 @@ - --group nom - --exclude-group nom + --group name + --exclude-group name
-
- Inclure et exclure des fichiers de la couverture de code +
+ Inclure des fichiers de la couverture de code Couverture de code - Liste noire Liste blanche - L'élément ]]> et ses fils peuvent être - utilisés pour configurer les listes noires et les listes blanches pour les rapports - de couverture de code. + L'élément ]]> et ses enfants peuvent être + utilisés pour configurer les listes blanches pour les rapports de couverture de code. - - /chemin/vers/fichiers - /chemin/vers/fichier - - /chemin/vers/fichiers - /chemin/vers/fichier - - - /chemin/vers/fichiers - /chemin/vers/fichier + /path/to/files + /path/to/file - /chemin/vers/fichiers - /chemin/vers/fichier + /path/to/files + /path/to/file ]]> @@ -191,20 +257,17 @@ Journalisation - L'élément ]]> et ses fils + L'élément ]]> et ses enfants ]]> peuvent être utilisés pour configurer la journalisation de l'exécution des tests. - + - - @@ -220,55 +283,41 @@ --coverage-clover /tmp/coverage.xml --coverage-php /tmp/coverage.serialized --coverage-text - --log-json /tmp/logfile.json ]]> /tmp/logfile.txt - --log-tap /tmp/logfile.tap --log-junit /tmp/logfile.xml --testdox-html /tmp/testdox.html --testdox-text /tmp/testdox.txt - Les attributs charset, yui, - highlight, lowUpperBound, - highLowerBound, logIncompleteSkipped - and showUncoveredFiles - n'ont pas d'options équivalentes pour le lanceur de tests TextUI. + Les attributs lowUpperBound, highLowerBound, + logIncompleteSkipped et + showUncoveredFiles n'ont pas d'options équivalentes pour le lanceur de + tests TextUI. - charset: encodage de caractères à utiliser pour les pages html générées - - yui: améliore le rapport de couverture html en utilisant la bibliothèque yui. - Par exemple, lorsque vous cliquez sur un numéro de ligne, un panneau YUI apparaît avec une liste de toutes les méthodes qui couvrent cette ligne. - - - - highlight: Quand mis à vrai, les rapports de couverture de code bénéficient de la coloration syntaxique. - lowUpperBound: pourcentage de couverture maximum considérée comme étant faible. highLowerBound: pourcentage de couverture minimum considérée comme étant forte. - - showUncoveredFiles: - Montre tous les fichiers en liste blanche dans la sortie --coverage-text et pas seulement ceux possédant des informations de couverture. - + showUncoveredFiles: Montre tous les fichiers en liste blanche dans la sortie --coverage-text et pas seulement ceux possédant des informations de couverture. + showOnlySummary: Montre seulement le résumé dans la sortie --coverage-text.
- Moniteurs de tests + Écouteurs de tests PHPUnit_Framework_TestListener - Moniteurs de tests + Écouteurs de tests - L'élément ]]> et ses fils + L'élément ]]> et ses enfants ]]> peuvent être utilisés pour brancher des - moniteurs de tests additionnels lors de l'exécution des tests. + écouteurs de tests additionnels lors de l'exécution des tests. - + @@ -286,16 +335,16 @@ La configuration XML ci-dessus revient à brancher l'objet - $moniteur (voir ci-dessous) à l'exécution des tests : + $listener (voir ci-dessous) à l'exécution des tests : -
@@ -307,7 +356,7 @@ Variable globale php.ini - L'élément ]]> et ses fils peuvent être utilisés + L'élément ]]> et ses enfants peuvent être utilisés pour configurer les réglages PHP, les constantes et les variables globales. Il peut également être utilisé pour préfixer l'include_path. @@ -341,43 +390,4 @@ $_SERVER['foo'] = 'bar'; $_FILES['foo'] = 'bar'; $_REQUEST['foo'] = 'bar';]]>
- -
- Configurer les navigateurs pour Selenium RC - - - Selenium RC - - L'élément ]]> et ses fils - ]]> peuvent être utilisés pour - configurer une liste de serveurs Selenium RC. - - - - -]]> - - - La configuration XML ci-dessus correspond au code PHP suivant : - - - 'Firefox sur Linux', - 'browser' => '*firefox /usr/lib/firefox/firefox-bin', - 'host' => 'ma.box.linux', - 'port' => 4444, - 'timeout' => 30000 - ) - ); - - // ... -}]]> -
diff --git a/src/6.1/fr/copyright.xml b/src/6.1/fr/copyright.xml index 69abb3899..a0a9ffbb1 100644 --- a/src/6.1/fr/copyright.xml +++ b/src/6.1/fr/copyright.xml @@ -8,7 +8,8 @@ Cette oeuvre est soumise à la licence Creative Commons Attribution 3.0 non transposée. -Un résumé de la licence est donné ci-dessous, suivi de la version intégrale. +Un résumé de la licence est donné ci-dessous, suivi de la version +intégrale. -------------------------------------------------------------------- @@ -19,14 +20,15 @@ Vous êtes libre de : Selon les conditions suivantes: -Attribution. Vous devez attribuer l'oeuvre de la manière indiquée par l'auteur de l'oeuvre ou le titulaire des droits (mais pas d'une manière qui suggérerait qu'ils vous soutiennent ou approuvent votre utilisation de l'oeuvre). +Attribution. Vous devez attribuer l'oeuvre de la manière indiquée par +l'auteur de l'oeuvre ou le titulaire des droits (mais pas d'une manière qui suggérerait qu'ils vous +soutiennent ou approuvent votre utilisation de l'oeuvre). - * A chaque réutilisation ou distribution de cette oeuvre, vous - devez faire apparaître clairement au public la licence selon - laquelle elle est mise à disposition. La meilleure manière - de l'indiquer est un lien vers cette page web. + * A chaque réutilisation ou distribution de cette oeuvre, vous devez faire apparaître clairement au public + la licence selon laquelle elle est mise à disposition. La meilleure manière de l'indiquer + est un lien vers cette page web. - * N'importe laquelle des conditions ci-dessus peut être waived + * N'importe laquelle des conditions ci-dessus peut être waived si vous avez l'autorisation du titulaire de droits. * Rien dans cette licence ne contrevient ou ne restreint les @@ -35,16 +37,22 @@ Attribution. Vous devez attribuer l'oeuvre de la manière indiquée par l'auteur Votre droit à l'utilisation équitable et vos autres droits ne sont en aucune manière affectés par ce qui précède. -Ceci est le résumé explicatif "lisible par les humains" du Code Juridique (la version intégrale de la licence) ci-dessous. +Ceci est le résumé explicatif "lisible par les humains" du Code Juridique (la version intégrale de +la licence) ci-dessous. ==================================================================== Creative Commons Legal Code -Attribution 3.0 non transposée +Attribution 3.0 Unported -Creative Commons n'est pas un cabinet d'avocats et ne fournit pas de services de conseil juridique. La distribution de la présente version de ce contrat ne crée aucune relation juridique entre les parties au contrat présenté ci-après et Creative Commons. Creative Commons fournit cette offre de contrat-type en l'état, à seule fin d'information. Creative Commons ne saurait être tenu responsable des éventuels préjudices résultant du contenu ou de l'utilisation de ce contrat. +CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE +LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN +ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS +INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO +WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS +LIABILITY FOR DAMAGES RESULTING FROM ITS USE. -Contrat +License THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS @@ -403,7 +411,7 @@ available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of this License. -Creative Commons peut être contacté à http://creativecommons.org/. +Creative Commons may be contacted at http://creativecommons.org/. ==================================================================== diff --git a/src/6.1/fr/database.xml b/src/6.1/fr/database.xml index 03fbf7f81..67cb8eefc 100644 --- a/src/6.1/fr/database.xml +++ b/src/6.1/fr/database.xml @@ -4,61 +4,64 @@ Tester des bases de données De nombreux exemples de tests unitaires de niveau débutant ou intermédiaire - dans de nombreux langages de programmation suggèrent qu'il est parfaitement - facile de tester la logique de votre application avec de simples tests. Pour - les applications centrées sur une base de données, c'est loin d'être la réalité. - Commencez à utiliser WordPress, TYPO3 ou Symfony avec Doctrine ou Propel, par + dans de nombreux langages de programmation suggèrent qu'il est parfaitement facile de tester la logique de votre application avec + de simples tests. Pour les applications centrées sur une base de données, c'est loin d'être la + réalité. Commencez à utiliser WordPress, TYPO3 ou Symfony avec Doctrine ou Propel, par exemple, et nous serez vite confrontés à des problèmes considérables avec PHPUnit : juste parce que la base de données est vraiment étroitement liée à ces bibliothèques. + + + Assurez-vous d'avoir l'extension PHP pdo et les extensions + spécifique à la base de données tel que pdo_mysql installées. + Sinon, les exemples ci-dessous ne fonctionneront pas. + + - Vous connaissez probablement ce scénario rencontré tous les jours - sur les projets, dans lequel vous voulez mettre à l'oeuvre votre savoir-faire tout neuf ou - déjà aguerri en matière de PHPUnit et où vous vous retrouvez bloqué par l'un des problèmes suivants : + Vous connaissez probablement ce scénario rencontré tous les jours sur les projets, + dans lequel vous voulez mettre à l'oeuvre votre savoir-faire tout neuf ou déjà aguerri en + PHPUnit et où vous vous retrouvez bloqué par l'un des problèmes suivants : - La méthode que vous voulez tester exécute une opération de jointure plutôt + La méthode que vous voulez tester exécute une opération JOIN plutôt vaste et utilise les données pour calculer certains résultats importants. - Votre logique métier exécute un mélange d'instructions SELECT, INSERT, UPDATE et + Votre logique métier exécute un mélange d'instructions SELECT, INSERT, UPDATE et DELETE. - Vous devez configurer les données de test dans (éventuellement beaucoup) plus - de deux tables pour obtenir des données initiales raisonnables pour les méthodes - que vous voulez tester. + Vous devez configurer les données de test dans (éventuellement beaucoup) plus + de deux tables pour obtenir des données initiales raisonnables pour les méthodes que vous voulez tester. - L'extension DbUnit simplifie considérablement la configuration d'une base - de données à des fins de test et vous permet de vérifier le contenu d'une - base de données après avoir réalisé une suite d'opérations. Elle peut être - installée comme ceci : + L'extension DbUnit simplifie considérablement la configuration d'une base de données à des fins + de test et vous permet de vérifier le contenu d'une base de données après avoir + réalisé une suite d'opérations. - pear install phpunit/DbUnit -
+
Systèmes gérés pour tester des bases de données - DbUnit gère actuellement MySQL, PostgreSQL, Oracle et SQLite. Via + DbUnit gère actuellement MySQL, PostgreSQL, Oracle et SQLite. Via l'intégration de Zend Framework ou de Doctrine 2 il est possible d'accéder à d'autres systèmes de base de données comme IBM DB2 ou Microsoft SQL Server.
-
+
Difficultés pour tester les bases de données Il y a une bonne raison pour laquelle les exemples concernant le test unitaire - n'inclut pas d'interaction avec une base de données : ces types de test sont à la + n'inclut pas d'interaction avec une base de données : ces types de test sont à la fois complexes à configurer et à maintenir. Quand vous faites des tests sur votre base de données, vous devez prendre soin des variables suivantes : @@ -87,7 +90,7 @@ Comme de nombreuses APIs de base de données comme PDO, MySQLi ou OCI8 sont lourdes à utiliser et verbeuses à écrire, réaliser ces étapes à la main - est un cauchemar absolu. + est un cauchemar absolu. Le code de test doit être aussi court et précis que possible pour plusieurs raisons : @@ -95,7 +98,7 @@ - Vous ne voulez pas modifier un volume considérable de code de test pour + Vous ne voulez pas modifier un volume considérable de code de test pour de petites modifications dans votre code de production. @@ -107,15 +110,13 @@ - De plus, vous devez prendre conscience que la base de données est - essentiellement une variable globale en entrée pour votre code. Deux - tests de votre série de tests peuvent être exécutés sur la même base - de données, potentiellement en réutilisant les données plusieurs fois. - Un échec dans un test peut facilement affecter le résultat des tests - suivants rendant votre expérimentation de test très difficile. L'étape - de nettoyage mentionnée précédemment est d'une importance majeure pour - résoudre le problème posé par le fait que la base de données est - une variable globale en entrée. + De plus, vous devez prendre conscience que la base de données est essentiellement + une variable globale pour votre code. Deux tests de votre série de tests + peuvent être exécutés sur la même base de données, potentiellement en réutilisant les données + plusieurs fois. Un échec dans un test peut facilement affecter le résultat des tests suivants + rendant votre expérimentation de test très difficile. L'étape de nettoyage mentionnée précédemment + est d'une importance majeure pour résoudre le problème posé par le fait que + la base de données est une variable globale. DbUnit aide à simplifier tous ces problèmes avec le test de base de données @@ -123,25 +124,25 @@ Là où PHPUnit ne peut pas vous aider c'est pour le fait que les tests - de base de données sont très lents comparés aux tests n'en utilisant pas. - Selon l'importance des interactions avec votre base de données, vos tests - peuvent s'exécuter sur une durée considérable. Cependant, si vous gardez - petit le volume de données utilisées pour chaque test et que vous essayez - de tester le plus de code possible en utilisant des tests qui ne font pas - appel à une base de données, vous pouvez facilement rester très en dessous + de base de données sont très lents comparés aux tests n'en utilisant pas. Selon + l'importance des interactions avec votre base de données, vos tests + peuvent s'exécuter sur une durée considérable. Cependant, si vous gardez petit le volume de + données utilisées pour chaque test et que vous essayez de tester le plus de code possible en utilisant + des tests qui ne font pas appel à une base de données, vous pouvez facilement rester très en dessous d'une minute, même pour de grandes séries de tests. La suite de test du projet Doctrine 2 , par exemple, possède actuellement une suite de tests d'environ 1000 tests dont presque la moitié accède à la base de données et continue à s'exécuter en 15 - secondes sur une base de données MySQL sur un ordinateur de bureau standard. + secondes sur une base de données MySQL sur un ordinateur de + bureau standard.
-
+
Les quatre phases d'un test de base de données - Dans son livre sur les canevas de tests xUnit, Gerard Meszaros liste les + Dans son livre sur les patterns de tests xUnit, Gerard Meszaros liste les quatre phases d'un test unitaire : @@ -176,14 +177,13 @@ - Tester la base de données nécessite au moins d'intervenir dans + Tester la base de données nécessite au moins d'intervenir dans setup et teardown pour nettoyer et écrire les données de fixture - nécessaires dans vos tables. Cependant, l'extension de base de données - possède une bonne raison de ramener les quatre phases dans un test - de base de données pour constituer le processus suivant qui est exécuté pour - chacun des tests : + nécessaires dans vos tables. Cependant, l'extension de base de données possède une bonne raison + de rétablir les quatre phases dans un test de base de données pour constituer le processus suivant + qui est exécuté pour chacun des tests : -
+
1. Nettoyer la base de données Puisqu'il y a toujours un premier test qui s'exécute en faisant @@ -192,14 +192,14 @@ les tables que vous avez indiquées pour les remettre à l'état vide.
-
+
2. Configurer les fixtures PHPUnit va parcourir toutes les lignes de fixture indiquées et les insérer dans leurs tables respectives.
-
+
3–5. Exécuter les tests, vérifier les résultats et nettoyer Une fois la base de données réinitialisée et remise dans son état de départ, @@ -215,40 +215,46 @@
-
+
Configuration d'un cas de test de base de données PHPUnit Habituellement quand vous utilisez PHPUnit, vos cas de tests devraient - hériter de la classe - PHPUnit_Framework_TestCase de la façon suivante : + hériter de la classe + PHPUnit\Framework\TestCase de la façon suivante : - -class MonTest extends PHPUnit_Framework_TestCase + assertEquals(2, 1 + 1); } } - +?>]]> - Si vous voulez tester du code qui fonctionne avec l'extension base de données, + Si vous voulez tester du code qui fonctionne avec l'extension base de données, le setup sera un peu plus complexe et vous devrez hériter d'un cas de test - abstrait différent qui nécessite que vous implémentiez deux méthodes - abstraites + abstrait différent qui nécessite que vous implémentiez deux méthodes abstraites getConnection() et getDataSet(): - -class MonLivreDOrTest extends PHPUnit_Extensions_Database_TestCase + createDefaultDBConnection($pdo, ':memory:'); } /** @@ -256,25 +262,26 @@ class MonLivreDOrTest extends PHPUnit_Extensions_Database_TestCase */ public function getDataSet() { - return $this->createFlatXMLDataSet(dirname(__FILE__).'/_files/guestbook-seed.xml'); + return $this->createFlatXMLDataSet(dirname(__FILE__).'/_files/guestbook-seed.xml'); } } - -
+?>]]> +
Implémenter getConnection() - Pour permettre aux fonctionnalités de nettoyage et de chargement des fixtures - de fonctionner, l'extension de base de données PHPUnit nécessite - d'accéder à une connexion de base de données abstraite pour les différents types - via la bibliothèque PDO. Il est important de noter que votre application - n'a pas besoin de s'appuyer sur PDO pour utiliser l'extension de base de données de PHPUnit, - la connexion est principalement utilisée pour le nettoyage et la configuration de setup. + Pour permettre aux fonctionnalités de nettoyage et de chargement des fixtures de fonctionner, + l'extension de base de données PHPUnit nécessite d'accéder à une connexion de base de données + abstraite pour les différents fournisseurs via la bibliothèque PDO. Il est important de noter + que votre application n'a pas besoin de s'appuyer sur PDO pour utiliser + l'extension de base de données de PHPUnit, la connexion est + principalement utilisée pour le nettoyage et la configuration de setup. Dans l'exemple précédent, nous avons créé une connexion Sqlite en mémoire et nous l'avons passé à la méthode createDefaultDBConnection - qui encapsule l'instance PDO et le second paramètre (le nom de la base de données) - dans une couche d'abstraction très simple pour connexion aux bases de données du type + qui encapsule l'instance PDO et le second paramètre (le + nom de la base de données) dans une couche d'abstraction très simple pour connexion + aux bases de données du type PHPUnit_Extensions_Database_DB_IDatabaseConnection. @@ -282,13 +289,14 @@ class MonLivreDOrTest extends PHPUnit_Extensions_Database_TestCase de cette interface et comment en faire le meilleur usage.
-
+
Implémenter getDataSet() La méthode getDataSet() définit à quoi doit ressembler - l'état initial de la base de données avant que chaque test ne soit exécuté. - L'état de la base de données est abstrait par les concepts DataSet et DataTable, - tous les deux représentés par les interfaces + l'état initial de la base de données avant que chaque test ne soit + exécuté. L'état de la base de données est abstrait par les + concepts DataSet et DataTable, tous les deux représentés par les + interfaces PHPUnit_Extensions_Database_DataSet_IDataSet et PHPUnit_Extensions_Database_DataSet_IDataTable. La prochaine section décrira en détail comment ces concepts fonctionnent @@ -296,14 +304,14 @@ class MonLivreDOrTest extends PHPUnit_Extensions_Database_TestCase Pour l'implémentation, nous avons seulement besoin de savoir que la méthode - getDataSet() est appelée une fois dans + getDataSet() est appelée une fois dans setUp() pour récupérer l'ensemble de données de la fixture et l'insérer dans la base de données. Dans l'exemple, nous utilisons une méthode fabrique createFlatXMLDataSet($filename) qui représente un ensemble de données à l'aide d'une représentation XML.
-
+
Qu'en est-il du schéma de base de données (DDL)? PHPUnit suppose que le schéma de base de données avec toutes ses tables, @@ -318,10 +326,9 @@ class MonLivreDOrTest extends PHPUnit_Extensions_Database_TestCase - Si vous utilisez une base de données persistante (pas Sqlite en mémoire) - vous pouvez facilement configure la base de données avec des outils tels - que phpMyAdmin pour MySQL et réutiliser la base de données pour chaque exécution - de test. + Si vous utilisez une base de données persistante (pas Sqlite en mémoire) vous pouvez + facilement configure la base de données avec des outils tels que phpMyAdmin pour + MySQL et réutiliser la base de données pour chaque exécution de test. @@ -330,101 +337,107 @@ class MonLivreDOrTest extends PHPUnit_Extensions_Database_TestCase Doctrine 2 ou Propel vous pouvez utiliser leurs APIs pour créer le schéma de base de données dont - vous avez besoin une fois avant de lancer vos tests. Vous pouvez utiliser - les possibilités apportées par + vous avez besoin une fois avant de lancer vos tests. Vous pouvez utiliser les possibilités apportées par l'amorce et la configuration de PHPUnit pour exécuter ce code à chaque fois que vos tests sont exécutés.
-
+
Astuce: utilisez votre propre cas de tests abstrait de base de données - En partant des exemples d'implémentation précédents, vous pouvez facilement - voir que la méthode + En partant des exemples d'implémentation précédents, vous pouvez facilement voir que la méthode getConnection() est plutôt statique et peut être réutilisée dans différents cas de test de base de données. Additionnellement - pour conserver de bonnes performances pour vos tests et maintenir la charge de la + pour conserver de bonnes performances pour vos tests et maintenir la charge de la base de données basse vous pouvez refactoriser un peu le code pour obtenir un cas de test abstrait générique pour votre application, qui vous permette encore d'indiquer des données de fixture différentes pour chaque cas de test : - -abstract class MyApp_Tests_DatabaseTestCase extends PHPUnit_Extensions_Database_TestCase + conn === null) { if (self::$pdo == null) { self::$pdo = new PDO('sqlite::memory:'); } - $this->conn = $this->createDefaultDBConnection(self::$pdo, ':memory:'); + $this->conn = $this->createDefaultDBConnection(self::$pdo, ':memory:'); } - return $this->conn; + return $this->conn; } } - +?>]]> Mais la connexion à la base de données reste codée en dur dans la connexion PDO. PHPUnit possède une autre fonctionnalité formidable qui peut rendre ce cas de test encore plus générique. Si vous utilisez - la configuration XML, + la configuration XML, vous pouvez rendre la connexion à la base de données configurable pour chaque exécution de test. Créons d'abord un fichier phpunit.xml dans le répertoire tests/ de l'application qui ressemble à ceci : - -<?xml version="1.0" encoding="UTF-8" ?> -<phpunit> - <php> - <var name="DB_DSN" value="mysql:dbname=myguestbook;host=localhost" /> - <var name="DB_USER" value="user" /> - <var name="DB_PASSWD" value="passwd" /> - <var name="DB_DBNAME" value="myguestbook" /> - </php> -</phpunit> - + + + + + + + + + +]]> Nous pouvons maintenant modifier notre cas de test pour qu'il ressemble à ça : - -abstract class Generic_Tests_DatabaseTestCase extends PHPUnit_Extensions_Database_TestCase + conn === null) { if (self::$pdo == null) { self::$pdo = new PDO( $GLOBALS['DB_DSN'], $GLOBALS['DB_USER'], $GLOBALS['DB_PASSWD'] ); } - $this->conn = $this->createDefaultDBConnection(self::$pdo, $GLOBALS['DB_DBNAME']); + $this->conn = $this->createDefaultDBConnection(self::$pdo, $GLOBALS['DB_DBNAME']); } - return $this->conn; + return $this->conn; } } - +?>]]> Nous pouvons maintenant lancer la suite de tests de la base de données en utilisant différentes configurations depuis l'interface en ligne de commandes: - -user@desktop> phpunit --configuration developer-a.xml MesTests/ -user@desktop> phpunit --configuration developer-b.xml MesTests/ - + user@desktop> phpunit --configuration developer-a.xml MyTests/ +user@desktop> phpunit --configuration developer-b.xml MyTests/ La possibilité de lancer facilement des tests de base de données sur différentes bases de données cibles est très important si vous développez sur une machine @@ -434,13 +447,13 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/
-
+
Comprendre DataSets et DataTables Un concept centre de l'extension de base de données PHPUnit sont les DataSets et les DataTables. Vous devez comprendre ce simple concept pour maîtriser les tests de bases de données avec PHPUnit. Les DataSets - et les DataTables constituent une couche d'abstraction sur les tables, + et les DataTables constituent une couche d'abstraction sur les tables, les lignes et les colonnes de la base de données. Une simple API cache le contenu de la base de données sous-jacente dans une structure objet, qui peut également être implémentée par d'autres sources qui ne sont pas des bases de données. @@ -482,7 +495,6 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/ dans la section précédente, ils décrivent également le contenu initial de la base de données. Vous êtes obligés de définir un ensemble de données fixture avec le cas de test Database, qui est ensuite utilisé pour : - @@ -496,7 +508,7 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/ -
+
Implémentations disponibles Il existe trois types différents de datasets/datatables: @@ -520,32 +532,31 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/ les datasets et les tables basés sur des fichiers sont généralement - utilisés pour la fixture initiale et pour décrire l'état attendu - d'une base de données. + utilisés pour la fixture initiale et pour décrire l'état attendu d'une base de données. -
+
DataSet en XML à plat Le dataset le plus commun est appelé XML à plat (flat XML). C'est un format xml très simple dans lequel une balise à l'intérieur d'un noeud racine - <dataset> représente exactement une ligne de la base + ]]> représente exactement une ligne de la base de données. Les noms des balises sont ceux des tables dans lesquelles insérer les lignes et un attribut représente la colonne. Un exemple pour une simple application de livre d'or pourrait ressembler à ceci : - -<?xml version="1.0" ?> -<dataset> - <livre_d_or id="1" contenu="Salut Poum!" utilisateur="joe" date_creation="2010-04-24 17:15:23" /> - <livre_d_or id="2" contenu="J'aime !" utilisateur="nancy" date_creation="2010-04-26 12:14:20" /> -</dataset> - + + + + + +]]> C'est à l'évidence facile à écrire. Ici, - <livre_d_or> est le nom de la table dans laquelle les deux + ]]> est le nom de la table dans laquelle les deux lignes sont insérées, chacune avec quatre colonnes id, - contenu, utilisateur et - date_creation et leurs valeurs respectives. + content, user et + created et leurs valeurs respectives. Cependant, cette simplicité a un coût. @@ -556,12 +567,12 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/ contenant le nom de la table vide. Un fichier XML à plat pour une table livre_d_or pourrait alors ressembler à ceci: - -<?xml version="1.0" ?> -<dataset> - <livre_d_or /> -</dataset> - + + + + +]]> La gestion des valeurs NULL avec le dataset en XML à plat est fastidieuse. Une valeur NULL est différente d'une chaîne vide dans la plupart des bases @@ -569,15 +580,16 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/ de décrire dans le format XML à plat. Vous pouvez représenter une valeur NULL en omettant d'attribut indiquant la ligne. Si votre livre d'or autorise les entrées anonymes représentées par une valeur NULL dans la colonne utilisateur, un état - hypothétique de la table livre_d_or pourrait ressembler à ceci: + hypothétique de la table guestbook pourrait r + essembler à ceci: - -<?xml version="1.0" ?> -<dataset> - <livre_d_or id="1" contenu="Hello Poum !" utilisateur="joe" date_creation="2010-04-24 17:15:23" /> - <livre_d_or id="2" contenu="J'aime !" date_creation="2010-04-26 12:14:20" /> -</dataset> - + + + + + +]]> Dans ce cas, la seconde entrée est postée anonymement. Cependant, ceci conduit à un sérieux problème pour la reconnaissance de la colonne. @@ -587,24 +599,23 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/ doit faire partie de la table ? - Le dataset en XML à plat fait maintenant une hypothèse cruciale en + Le dataset en XML à plat fait maintenant une hypothèse cruciale en décrétant que les attributs de la première ligne définie pour une table - définissent les colonnes de cette table. Dans l'exemple précédent, ceci - signifierait que - id, contenu, utilisateur et - date_creation sont les colonnes de la table livre_d_or. Pour la - seconde ligne dans laquelle utilisateur n'est pas défini, un NULL + définissent les colonnes de cette table. Dans l'exemple précédent, ceci signifierait que + id, content, user et + created sont les colonnes de la table guestbook. Pour la + seconde ligne dans laquelle user n'est pas défini, un NULL sera inséré dans la base de données. Quand la première entrée du livre d'or est supprimée du dataset, - seuls id, contenu et - date_creation seront des colonnes de la table livre_d_or, - puisque utilisateur n'est pas indiqué. + seuls id, content et + created seront des colonnes de la table guestbook, + puisque user n'est pas indiqué. Pour utiliser efficacement le dataset au format XML à plat quand des valeurs - NULL sont pertinentes, la première ligne de chaque table ne doit contenir aucune + NULL sont pertinentes, la première ligne de chaque table ne doit contenir aucune valeur NULL, seules les lignes suivantes pouvant omettre des attributs. Ceci peut s'avérer délicat, puisque l'ordre des lignes est un élément pertinent pour les assertions de base de données. @@ -624,166 +635,178 @@ user@desktop> phpunit --configuration developer-b.xml MesTests/ dans votre cas de test de base de données en appelant la méthode createFlatXmlDataSet($filename): - -class MonCasDeTest extends PHPUnit_Extensions_Database_TestCase + createFlatXmlDataSet('myFlatXmlFixture.xml'); } } - +?>]]>
-
+
DataSet XML Il existe un autre dataset XML davantage structuré, qui est un peu plus - verbeux à écrire mais qui évite les problèmes de NULL du dataset au - format XML à plat. Dans le noeud racine <dataset> vous - pouvez indiquer les balises <table>, - <column>, <row>, - <value> et - <null />. Un dataset équivalent à celui + verbeux à écrire mais qui évite les problèmes de NULL du dataset au + format XML à plat. Dans le noeud racine ]]> vous + pouvez indiquer les balises ]]>, + ]]>, ]]>, + ]]> et + ]]>. Un dataset équivalent à celui défini précédemment pour le livre d'or en format XML à plat ressemble à : - -<?xml version="1.0" ?> -<dataset> - <table name="livre_d_or"> - <column>id</column> - <column>contenu</column> - <column>utilisateur</column> - <column>date_creation</column> - <row> - <value>1</value> - <value>Hello Poum !</value> - <value>joe</value> - <value>2010-04-24 17:15:23</value> - </row> - <row> - <value>2</value> - <value>J'aime !</value> - <null /> - <value>2010-04-26 12:14:20</value> - </row> - </table> -</dataset> - + + + + id + content + user + created + + 1 + Hello buddy! + joe + 2010-04-24 17:15:23 + + + 2 + I like it! + + 2010-04-26 12:14:20 + +
+ +]]> - Tout <table> défini possède un nom et nécessite + Tout ]]> défini possède un nom et nécessite la définition de toutes les colonnes avec leurs noms. Il peut contenir zéro ou tout - nombre positif d'éléments <row> imbriqués. - Ne définir aucun élément <row> signifie que la table est vide. - Les balises <value> et - <null /> doivent être indiquées dans l'ordre des éléments - <column>précédemment donnés. - La balise <null /> signifie évidemment que la valeur est NULL. + nombre positif d'éléments ]]> imbriqués. + Ne définir aucun élément ]]> signifie que la table est vide. + Les balises ]]> et + ]]> doivent être indiquées dans l'ordre des éléments + ]]>précédemment donnés. + La balise ]]> signifie évidemment que la + valeur est NULL. Vous pouvez créer une instance de dataset xml dans votre cas de test de base de données en appelant la méthode createXmlDataSet($filename) : - -class MonCasdeTest extends PHPUnit_Extensions_Database_TestCase + createXMLDataSet('myXmlFixture.xml'); } } - +?>]]>
-
- XML DataSet XML MySQL +
+ DataSet XML MySQL Ce nouveau format XML est spécifique au serveur de bases de données MySQL. Sa gestion a été ajoutée dans PHPUnit 3.5. Les fichiers écrits ce format peuvent - être générés avec l'utilitaire + être générés avec l'utilitaire mysqldump. - Contrairement aux datasets CSV, que mysqldump + Contrairement aux datasets CSV, que mysqldump gère également, un unique fichier de ce format XML peut contenir des données pour de multiples tables. Vous pouvez créer un fichier dans ce format en invoquant mysqldump de cette façon : - -mysqldump --xml -t -u [nom_utilisateur] --password=[mot_de_passe] [base_de_donnees] > /chemin/vers/fichier.xml - + mysqldump --xml -t -u [username] --password=[password] [database] > /path/to/file.xml Ce fichier peut être utilisé dans votre case de test de base de données en appelant - la méthode createMySQLXMLDataSet($nomdefichier): + la méthode createMySQLXMLDataSet($filename): - -class MonCasDeTest extends PHPUnit_Extensions_Database_TestCase + createMySQLXMLDataSet('/path/to/file.xml'); } } - +?>]]>
-
+
DataSet YAML - Nouveau depuis PHUnit 3.4, la possibilité d'indiquer un dataset - via le format populaire YAML. Pour que cela fonctionne, vous devez - installer PHPUnit 3.4 avec PEAR ainsi que sa dépendance optionnelle - Symfony YAML. Vous pouvez ensuite écrire un dataset YAML pour l'exemple - du livre d'or: + Alternativement, vous pouvez utiliser un dataset YAML pour l'exemple du livre d'or: - -livre_d_or: + + content: "I like it!" + user: + created: 2010-04-26 12:14:20 +]]> - C'est simple, pratique et ça règle le problème de NULL que pose le dataset + C'est simple, pratique ET ça règle le problème de NULL que pose le dataset équivalent au format XML à plat. Un NULL en YAML s'exprime simplement - en donnant le nom de la colonne dans indiquer de valeur. Une chaîne vide - est indiquée par - colonne1: "". + en donnant le nom de la colonne sans indiquer de valeur. Une chaîne vide est indiquée par + . - Le dataset YAML ne possède pas actuellement de méthode de fabrique - pour le cas de tests de base de données, si bien que vous devez l'instancier - manuellement : + Le dataset YAML ne possède pas actuellement de méthode de fabrique + pour le cas de tests de base de données, si bien que vous devez l'instancier manuellement : - -class LivredOrYamlTest extends PHPUnit_Extensions_Database_TestCase + +?>]]>
-
+
DataSet CSV Un autre dataset au format fichier est basé sur les fichiers CSV. Chaque table du dataset est représenté par un fichier CSV. Pour notre exemple de livre d'or, - nous pourrions définir un fichier livre_d_or-table.csv: + nous pourrions définir un fichier guestbook-table.csv: - -id,contenu,utilisateur,date_creation -1,"Hello Poum !","joe","2010-04-24 17:15:23" -2,"J'aime !","nancy","2010-04-26 12:14:20" - + - Bien que ce soit très pratique à éditer avec Excel ou LibreOffice, + Bien que ce soit très pratique à éditer avec Excel ou OpenOffice, vous ne pouvez pas indiquer de valeurs NULL avec le dataset CSV. Une colonne vide conduira à ce que la valeur vide par défaut de la base de données soit insérée dans la colonne. @@ -791,41 +814,65 @@ id,contenu,utilisateur,date_creation Vous pouvez créer un dataset CSV en appelant : - -class CsvLivredOrTest extends PHPUnit_Extensions_Database_TestCase + addTable('guestbook', dirname(__FILE__)."/_files/guestbook.csv"); return $dataSet; } } - +?>]]>
-
+
DataSet tableau - Il n'existe pas (encore) de DataSet basé sur les tableau dans + Il n'existe pas (encore) de DataSet basé sur les tableau dans l'extension base de données de PHPUnit, mais vous pouvez implémenter facilement la vôtre. Notre exemple du Livre d'or devrait ressembler à : - -class LivredOrTableauTest extends PHPUnit_Extensions_Database_TestCase + [ + [ + 'id' => 1, + 'content' => 'Hello buddy!', + 'user' => 'joe', + 'created' => '2010-04-24 17:15:23' + ], + [ + 'id' => 2, + 'content' => 'I like it!', + 'user' => null, + 'created' => '2010-04-26 12:14:20' + ], + ], + ] + ); } } - +?>]]> - Un DataSet PHP possède des avantages évidents sur les autres datasets utilisant des fichiers : + Un DataSet PHP possède des avantages évidents sur les autres datasets utilisant des + fichiers : @@ -843,27 +890,29 @@ class LivredOrTableauTest extends PHPUnit_Extensions_Database_TestCase Pour que ce dataset ressemble aux DataSets au format XML à plat, CSV et YAML, les clefs de la première ligne spécifiée définissent les noms de colonne de la table, dans le cas - précédent, ce serait contenu, utilisateur et - date_creation. + précédent, ce serait id, + content, user and + created. - L'implémentation de ce DataSet tableau est simple et évidente: + L'implémentation de ce DataSet tableau est simple et + évidente: - + $rows) { + $columns = []; if (isset($rows[0])) { $columns = array_keys($rows[0]); } @@ -872,64 +921,63 @@ class MyApp_DbUnit_ArrayDataSet extends PHPUnit_Extensions_Database_DataSet_Abst $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($metaData); foreach ($rows AS $row) { - $table->addRow($row); + $table->addRow($row); } - $this->tables[$tableName] = $table; + $this->tables[$tableName] = $table; } } - protected function createIterator($reverse = FALSE) + protected function createIterator($reverse = false) { - return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse); + return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse); } public function getTable($tableName) { - if (!isset($this->tables[$tableName])) { - throw new InvalidArgumentException("$tableName ne correspond pas à une table dans la base de données actuelle."); + if (!isset($this->tables[$tableName])) { + throw new InvalidArgumentException("$tableName is not a table in the current database."); } - return $this->tables[$tableName]; + return $this->tables[$tableName]; } } - +?>]]>
-
+
Query (SQL) DataSet - Pour les assertions de base de données, vous n'avez pas seulement besoin - de datasets basés sur des fichiers mais aussi de Datasets basé sur des requêtes/du SQL - qui contiennent le contenu constaté de la base de données. C'est là que - le DataSet Query s'illustre : + Pour les assertions de base de données, vous n'avez pas seulement besoin + de datasets basés sur des fichiers mais aussi de Datasets basé sur des requêtes/du SQL + qui contiennent le contenu constaté de la base de données. C'est là que le DataSet Query s'illustre : - -$ds = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection()); -$ds->addTable('livre_d_or'); - + getConnection()); +$ds->addTable('guestbook'); +?>]]> Ajouter une table juste par son nom est un moyen implicite de définir la table de données avec la requête suivante : - -$ds = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection()); -$ds->addTable('livre_d_or', 'SELECT * FROM livre_d_or'); - + getConnection()); +$ds->addTable('guestbook', 'SELECT * FROM guestbook'); +?>]]> Vous pouvez utiliser ceci en indiquant des requêtes arbitraires pour vos tables, par exemple en restreignant les lignes, les colonnes ou en ajoutant des clauses ORDER BY: - -$ds = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection()); -$ds->addTable('livre_d_or', 'SELECT id, contenu FROM livre_d_or ORDER BY date_creation DESC'); - + getConnection()); +$ds->addTable('guestbook', 'SELECT id, content FROM guestbook ORDER BY created DESC'); +?>]]> La section relative aux assertions de base de données montrera plus en détails comment utiliser le Query DataSet.
-
- Dataset de base de données +
+ Dataset (DB) de base de données En accédant à la connexion de test, vous pouvez créer automatiquement un DataSet constitué de toutes les tables et de leur contenu de la base @@ -938,39 +986,46 @@ $ds->addTable('livre_d_or', 'SELECT id, contenu FROM livre_d_or ORDER BY date Vous pouvez, soit créer un dataset pour la base de données complète - comme montré dans la méthode testLivredOr(), soit le restreindre + comme montré dans la méthode testGuestbook(), soit le restreindre à un ensemble de noms de tables avec une liste blanche comme montré dans - la méthode testLivredOrFiltre(). + la méthode testFilteredGuestbook(). - -class MonLivredOrSqlTest extends PHPUnit_Extensions_Database_TestCase + createDefaultDBConnection($pdo, $database); } - public function testLivredOr() + public function testGuestbook() { - $dataSet = $this->getConnection()->createDataSet(); + $dataSet = $this->getConnection()->createDataSet(); // ... } - public function testLivredOrFiltre() + public function testFilteredGuestbook() { - $nomTables = array('livre_d_or'); - $dataSet = $this->getConnection()->createDataSet($nomTables); + $tableNames = ['guestbook']; + $dataSet = $this->getConnection()->createDataSet($tableNames); // ... } } - +?>]]>
-
+
DataSet de remplacement J'ai évoqué les problèmes de NULL avec les DataSet au format XML à @@ -983,169 +1038,170 @@ class MonLivredOrSqlTest extends PHPUnit_Extensions_Database_TestCase par une autre valeur de remplacement. Pour que notre exemple de livre d'or fonctionne avec des valeurs NULL nous indiquons le fichier comme ceci: - -<?xml version="1.0" ?> -<dataset> - <livre_d_or id="1" contenu="Hello Poum !" utilisateur="joe" date_creation="2010-04-24 17:15:23" /> - <livre_d_or id="2" contenu="J'aime !" utilisateur="##NULL##" date_creation="2010-04-26 12:14:20" /> -</dataset> - + + + + + +]]> - Nous enrobons le DataSet au format XML à plat dans le DataSet de remplacement : + Nous encapsulons le DataSet au format XML à plat dans le DataSet de remplacement : - -class ReplacementTest extends PHPUnit_Extensions_Database_TestCase + createFlatXmlDataSet('myFlatXmlFixture.xml'); $rds = new PHPUnit_Extensions_Database_DataSet_ReplacementDataSet($ds); - $rds->addFullReplacement('##NULL##', null); + $rds->addFullReplacement('##NULL##', null); return $rds; } } - +?>]]>
-
+
Filtre de DataSet Si vous avez un fichier de fixture conséquent vous pouvez utiliser le filtre de DataSet pour des listes blanches ou noires des tables et des colonnes qui peuvent être contenues dans un sous-dataset. C'est - particulièrement commode en combinaison avec le DataSet de base de données - pour filtrer les colonnes des datasets. + particulièrement commode en combinaison avec le DataSet de base de données pour filtrer les colonnes des datasets. - -class DataSetFilterTest extends PHPUnit_Extensions_Database_TestCase + getConnection()->createDataSet(); $filterDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet); - $filterDataSet->addIncludeTables(array('livre_d_or')); - $filterDataSet->setIncludeColumnsForTable('livre_d_or', array('id', 'contenu')); + $filterDataSet->addIncludeTables(['guestbook']); + $filterDataSet->setIncludeColumnsForTable('guestbook', ['id', 'content']); // .. } - public function testLivredOrAvecFiltredExclusion() + public function testExcludeFilteredGuestbook() { - $nomTables = array('livre_d_or'); - $dataSet = $this->getConnection()->createDataSet(); + $tableNames = ['guestbook']; + $dataSet = $this->getConnection()->createDataSet(); $filterDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet); - $filterDataSet->addExcludeTables(array('foo', 'bar', 'baz')); // ne garder que la table livre_d_or ! - $filterDataSet->setExcludeColumnsForTable('livre_d_or', array('utilisateur', 'date_creationd')); + $filterDataSet->addExcludeTables(['foo', 'bar', 'baz']); // only keep the guestbook table! + $filterDataSet->setExcludeColumnsForTable('guestbook', ['user', 'created']); // .. } } - +?>]]>
- NOTE Vous ne pouvez pas utiliser - en même temps le filtrage de colonne d'inclusion et d'exclusion sur - la même table, seulement sur des tables différentes. De plus, il est + NOTE Vous ne pouvez pas utiliser en même temps le filtrage de colonne d'inclusion + et d'exclusion sur la même table, seulement sur des tables différentes. De plus, il est seulement possible d'appliquer soit une liste blanche, soit une liste noire aux tables, mais pas les deux à la fois.
-
+
DataSet composite Le DataSet composite est très utile pour agréger plusieurs datasets déjà existants dans un unique dataset. Quand plusieurs - datasets contiennent la même table, les lignes sont ajoutées + datasets contiennent la même table, les lignes sont ajoutées dans l'ordre indiqué. Par exemple, si nous avons deux datasets fixture1.xml : - -<?xml version="1.0" ?> -<dataset> - <livre_d_or id="1" contenu="Hello Poum !" utilisateur="joe" date_creation="2010-04-24 17:15:23" /> -</dataset> - + + + + +]]> et fixture2.xml: - -<?xml version="1.0" ?> -<dataset> - <livre_d_or id="2" contenu="J'aime !" utilisateur="##NULL##" date_creation="2010-04-26 12:14:20" /> -</dataset> - + + + + +]]> En utiliser le DataSet composite, nous pouvons agréger les deux fichiers de fixture: - -class CompositeTest extends PHPUnit_Extensions_Database_TestCase + createFlatXmlDataSet('fixture1.xml'); + $ds2 = $this->createFlatXmlDataSet('fixture2.xml'); $compositeDs = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet(); - $compositeDs->addDataSet($ds1); - $compositeDs->addDataSet($ds2); + $compositeDs->addDataSet($ds1); + $compositeDs->addDataSet($ds2); return $compositeDs; } } - +?>]]>
-
+
Attention aux clefs étrangères Lors du SetUp de la fixture l'extension de base de données de PHPUnit insère les lignes dans la base de données dans l'ordre où elles sont indiquées dans votre fixture. Si votre schéma de base de données utilise des clefs étrangères, ceci signifie que vous devez indiquer - les tables dans un ordre qui ne provoquera pas une violation de - contrainte pour ces clefs étrangères. + les tables dans un ordre qui ne provoquera pas une violation de contrainte pour ces clefs étrangères.
-
+
Implementer vos propres DataSets/DataTables - Pour comprendre le fonctionnement interne des DataSets et des DataTables + Pour comprendre le fonctionnement interne des DataSets et des DataTables jetons un oeil sur l'interface d'un DataSet. Vous pouvez sauter cette partie si vous ne projetez pas d'implémenter votre propre DataSet ou DataTable. - + +?>]]> L'interface publique est utilisée en interne par l'assertion - assertDataSetsEqual() du cas de test de base de données - pour contrôler la qualité du dataset. De l'interface + assertDataSetsEqual() du cas de test de base de données + pour contrôler la qualité du dataset. De l'interface IteratorAggregate le IDataSet - hérite la méthode getIterator() pour parcourir toutes - les tables du dataset. La méthode additionnelle d'itérateur inverse est - nécessaire pour réussir à tronquer les tables dans l'ordre inverse à celui indiqué. + hérite la méthode getIterator() pour parcourir toutes + les tables du dataset. La méthode additionnelle d'itérateur inverse est + nécessaire pour réussir à tronquer les tables dans l'ordre inverse à celui indiqué pour satisfaire + les contraintes de clés étrangères. -
- - Pour comprendre le besoin d'un itérateur inverse, pensez deux tables - (TableA et TableB) avec - TableB qui contient une clef étrangère sur une colonne de - TableA. Si pour la configuration de la fixture une ligne - est insérée dans TableA puis un enregistrement dépendant dans - TableB, alors il est évident que pour détruire le contenu de toutes - les tables, l'ordre inverse va vous poser des problèmes avec les contraintes de clefs - étrangères. - -
En fonction de l'implémentation, différentes approches sont prises pour ajouter des instances de table dans un dataset. Par exemple, @@ -1156,7 +1212,7 @@ interface PHPUnit_Extensions_Database_DataSet_IDataSet extends IteratorAggregate Une table est également représentée par l'interface suivante : - + +?>]]> Mise à part la méthode getTableMetaData(), ça parle - plutôt de soi-même. Les méthodes utilisées sont toutes nécessaires pour + plutôt de soi-même. Les méthodes utilisées sont toutes nécessaires pour les différentes assertions de l'extension Base de données expliquées - dans le chapitre suivant. La méthode - getTableMetaData() doit retourner une implémentation de - l'interface PHPUnit_Extensions_Database_DataSet_ITableMetaData - qui décrit la structure de la table. Elle contient des informations sur: + dans le chapitre suivant. La méthode + getTableMetaData() doit retourner + une implémentation de l'interface + PHPUnit_Extensions_Database_DataSet_ITableMetaData + qui décrit la structure de la table. Elle contient des + informations sur: @@ -1200,14 +1258,14 @@ interface PHPUnit_Extensions_Database_DataSet_ITable
-
+
L'API de connexion Il y a trois méthodes intéressantes dans l'interface de connexion qui doit être retournée par la méthode getConnection() du cas de test de base de données : - + +?>]]> La méthode createDataSet() crée un DataSet de base de données (DB) comme décrit dans la section relative aux implémentations de DataSet. - -class ConnectionTest extends PHPUnit_Extensions_Database_TestCase + getConnection()->createDataSet(); } } - +?>]]> La méthode createQueryTable() peut être utilisée pour - créer des instances d'une QueryTable, en lui passant un nom de résultat et + créer des instances d'une QueryTable, en lui passant un nom de résultat et une requête SQL. C'est une méthode pratique quand elle est associée à des assertions résultats/table comme cela sera illustré dans la prochaine section - relative à l'API des assertions de base de données. + relative à l'API des assertions de base de données. - -class ConnectionTest extends PHPUnit_Extensions_Database_TestCase + getConnection()->createQueryTable('guestbook', 'SELECT * FROM guestbook'); } } - +?>]]> @@ -1260,53 +1328,62 @@ class ConnectionTest extends PHPUnit_Extensions_Database_TestCase clause where supplémentaire. Ceci peut être utilisé pour une simple assertion d'égalité : - -class ConnectionTest extends PHPUnit_Extensions_Database_TestCase + assertEquals(2, $this->getConnection()->getRowCount('guestbook')); } } - +?>]]>
-
+
API d'assertion de base de données - En tant qu'outil de test, l'extension base de données fournit + En tant qu'outil de test, l'extension base de données fournit certainement des assertions que vous pouvez utiliser pour vérifier l'état actuel de la base de données, des tables et du nombre de lignes des tables. Cette section décrit ces fonctionnalités en détail : -
+
Faire une assertion sur le nombre de lignes d'une table Il est souvent très utile de vérifier si une table contient un nombre déterminé de lignes. Vous pouvez facilement réaliser cela sans code - de liaison supplémentaire en utilisant l'API de connexion. Disons que + de liaison supplémentaire en utilisant l'API de connexion. Disons que nous voulons contrôler qu'après une insertion d'une ligne dans notre - livre d'or, nous n'avons plus seulement nos deux entrées initiales - qui nous ont accompagnées dans tous les exemples précédents, mais aussi - une troisième : + livre d'or, nous n'avons plus seulement nos deux entrées initiales + qui nous ont accompagnées dans tous les exemples précédents, mais aussi une troisième : - -class LivredorTest extends PHPUnit_Extensions_Database_TestCase + assertEquals(2, $this->getConnection()->getRowCount('guestbook'), "Pre-Condition"); - $livre_d_or = new Livredor(); - $livre_d_or->addEntry("suzy", "Hello world!"); + $guestbook = new Guestbook(); + $guestbook->addEntry("suzy", "Hello world!"); - $this->assertEquals(3, $this->getConnection()->getRowCount('livre_d_or'), "Insertion en échec"); + $this->assertEquals(3, $this->getConnection()->getRowCount('guestbook'), "Inserting failed"); } } - +?>]]>
-
+
Faire une assertion sur l'état d'une table L'assertion précédent est utile, mais nous voudrons certainement tester @@ -1316,139 +1393,160 @@ class LivredorTest extends PHPUnit_Extensions_Database_TestCase Pour cela, nous devons définir une instance de Query Table qui tire - son contenu d'un nom de table et d'une requête SQL et le compare + son contenu d'un nom de table et d'une requête SQL et le compare à un DataSet basé sur un fichier/tableau. - -class LivredorTest extends PHPUnit_Extensions_Database_TestCase + addEntry("suzy", "Hello world!"); - $requeteDeTable = $this->getConnection()->createQueryTable( - 'livre_d_or', 'SELECT * FROM livre_d_or' + $queryTable = $this->getConnection()->createQueryTable( + 'guestbook', 'SELECT * FROM guestbook' ); - $tableAttendue = $this->createFlatXmlDataSet("livreAttendu.xml") - ->getTable("livre_d_or"); - $this->assertTablesEqual($tableAttendue, $requeteDeTable); + $expectedTable = $this->createFlatXmlDataSet("expectedBook.xml") + ->getTable("guestbook"); + $this->assertTablesEqual($expectedTable, $queryTable); } } - +?>]]> - Maintenant, nous devons écrire le fichier XML à plat livreAttendu.xml + Maintenant, nous devons écrire le fichier XML à plat expectedBook.xml pour cette assertion : - -<?xml version="1.0" ?> -<dataset> - <livre_d_or id="1" contenu="Hello Poum !" utilisateur="joe" date_creation="2010-04-24 17:15:23" /> - <livre_d_or id="2" contenu="J'aime !" utilisateur="nancy" date_creation="2010-04-26 12:14:20" /> - <livre_d_or id="3" contenu="Hello world!" utilisateur="suzy" date_creation="2010-05-01 21:47:08" /> -</dataset> - + + + + + + +]]> Cette assertion ne réussira que si elle est lancée très exactement le 2010–05–01 21:47:08. Les dates posent un problème spécial - pour le test de base de données et nous pouvons contourner l'échec - en omettant la colonne date_creation de l'assertion. + pour le test de base de données et nous pouvons contourner l'échec + en omettant la colonne created de + l'assertion. - Le fichier au format XML à plat adapté livreAttendu.xml - devra probablement ressembler à ce qui suit pour que l'assertion réussisse. + Le fichier au format XML à plat adapté expectedBook.xml + devra probablement ressembler à ce qui suit pour que + l'assertion réussisse : - -<?xml version="1.0" ?> -<dataset> - <livre_d_or id="1" contenu="Hello Poum !" utilisateur="joe" /> - <livre_d_or id="2" contenu="J'aime !" utilisateur="nancy" /> - <livre_d_or id="3" contenu="Hello world!" utilisateur="suzy" /> -</dataset> - + + + + + + +]]> Nous devons corriger l'appel à Query Table: - -$queryTable = $this->getConnection()->createQueryTable( - 'livre_d_or', 'SELECT id, contenu, utilisateur FROM livre_d_or' + getConnection()->createQueryTable( + 'guestbook', 'SELECT id, content, user FROM guestbook' ); - +?>]]>
-
+
Faire une assertion sur le résultat d'une requête Vous pouvez également faire une assertion sur le résultat de requêtes complexes avec l'approche Query Table, simplement en indiquant le nom - d'un résultat avec une requête et en le comparant avec un ensemble de - données: + d'un résultat avec une requête et en le comparant avec un ensemble de données: - -class ComplexQueryTest extends PHPUnit_Extensions_Database_TestCase + getConnection()->createQueryTable( + 'myComplexQuery', 'SELECT complexQuery...' ); - $tableAttendue = $this->createFlatXmlDataSet("assertionDeRequeteComplexe.xml") - ->getTable("myComplexQuery"); - $this->assertTablesEqual($tableAttendue, $requeteTable); + $expectedTable = $this->createFlatXmlDataSet("complexQueryAssertion.xml") + ->getTable("myComplexQuery"); + $this->assertTablesEqual($expectedTable, $queryTable); } } - +?>]]>
-
+
Faire une assertion sur l'état de plusieurs tables - Evidemment, vous pouvez faire une assertion sur l'état de plusieurs - tables à la fois et comparer un ensemble de données obtenu par - une requête avec un ensemble de données basé sur un fichier. Il y a - deux façons différentes de faire des assertions de DataSet. + Evidemment, vous pouvez faire une assertion sur l'état de plusieurs tables à la fois + et comparer un ensemble de données obtenu par une requête avec un ensemble de données + basé sur un fichier. Il y a deux façons différentes de faire des assertions de DataSet. - Vous pouvez utiliser le Database (DB) Dataset à partir de la + Vous pouvez utiliser le Database (DB) Dataset à partir de la connexion et le comparer au DataSet basé sur un fichier. - -class DataSetAssertionsTest extends PHPUnit_Extensions_Database_TestCase + getConnection()->createDataSet(['guestbook']); + $expectedDataSet = $this->createFlatXmlDataSet('guestbook.xml'); + $this->assertDataSetsEqual($expectedDataSet, $dataSet); } } - +?>]]> Vous pouvez construire vous-même le DataSet: - -class DataSetAssertionsTest extends PHPUnit_Extensions_Database_TestCase + addTable('guestbook', 'SELECT id, content, user FROM guestbook'); // additional tables + $expectedDataSet = $this->createFlatXmlDataSet('guestbook.xml'); - $this->assertDataSetsEqual($dataSetAttendu, $dataSet); + $this->assertDataSetsEqual($expectedDataSet, $dataSet); } } - +?>]]>
-
+
Foire aux questions -
- PHPUnit va-t'il (re-)créer le schéma de base de données pour chaque test ? +
+ PHPUnit va-t'il (re-)créer le schéma de base de données pour chaque + test ? Non, PHPUnit exige que tous les objets de base de données soit disponible quand la suite démarre. La base de données, les tables, les séquences, les triggers et les @@ -1468,36 +1566,38 @@ class DataSetAssertionsTest extends PHPUnit_Extensions_Database_TestCase Une base de données disponible de façon permanente fonctionne parfaitement.
-
- Suis-je obligé d'utiliser PDO dans mon application pour que l'extension de base de données fonctionne ? +
+ Suis-je obligé d'utiliser PDO dans mon application pour que l'extension de base de + données fonctionne ? - Non, PDO n'est nécessaire que pour le nettoyage et la configuration de la fixture et - pour les assertions. Vous pouvez utiliser n'importe laquelle des abstractions de base de + Non, PDO n'est nécessaire que pour le nettoyage et la configuration de la fixture et + pour les assertions. Vous pouvez utiliser n'importe laquelle des abstractions de base de données que vous voulez dans votre propre code.
-
- Que puis-je faire quand j'obtiens une erreur <quote>Too much Connections (Trop de connexions)</quote> ? +
+ Que puis-je faire quand j'obtiens une erreur + <quote>Too much Connections (Trop de connexions)</quote> ? Si vous ne mettez pas en cache l'instance PDO qui est créée dans la méthode getConnection() du cas de test le nombre de connexions à la base de données est augmenté d'une unité ou plus pour chaque test de base de données. Avec la configuration par défaut, MySql - n'autorise qu'un maximum de 100 connexions concurrentes. Les autres moteurs - de bases de données possèdent également des limites du nombre maximum - de connexions. + n'autorise qu'un maximum de 100 connexions concurrentes. Les autres moteurs + de bases de données possèdent également des limites du nombre maximum de connexions. La sous-section - Utilisez votre propre cas de test de base de données abstrait illustre comment + Utilisez votre propre cas de test de base de données abstrait illustre comment vous pouvez empêcher cette erreur de survenir en utilisant une unique instance de PDO en cache dans tous vos tests.
-
+
Comment gérer les valeurs NULL avec les DataSets au format XML à plat / CSV ? - Ne le fait pas. Pour cela, vous devez utiliser des DataSets XML ou YAML. + Ne le fait pas. Pour cela, vous devez utiliser des + DataSets XML ou YAML.
diff --git a/src/6.1/fr/extending-phpunit.xml b/src/6.1/fr/extending-phpunit.xml index 14eb3a8b4..6a5465411 100644 --- a/src/6.1/fr/extending-phpunit.xml +++ b/src/6.1/fr/extending-phpunit.xml @@ -5,19 +5,18 @@ PHPUnit peut être étendu de multiples façon pour rendre l'écriture des - tests plus facile et personnaliser le retour que vous obtenez des tests + tests plus simple et personnaliser le retour que vous obtenez des tests exécutés. Voici les points de départs communs pour étendre PHPUnit.
- Sous-classe PHPUnit_Framework_TestCase + Sous-classe PHPUnit\Framework\TestCase - PHPUnit_Framework_TestCase + PHPUnit\Framework\TestCase - Ecrivez des assertions personnalisées et des méthodes utilitaires dans une - sous classe abstraite de - PHPUnit_Framework_TestCase et faites hériter vos classes + Ecrivez des assertions personnalisées et des méthodes utilitaires dans une sous classe abstraite de + PHPUnit\Framework\TestCase et faites hériter vos classes de cas de test de cette classe. C'est une des façon les plus faciles pour étendre PHPUnit. @@ -27,19 +26,20 @@ Ecrire des assertions personnalisées - Lorsqu'on écrit des assertions personnalisées, une bonne pratique - consiste à suivre la façon dont PHPUnit implémente ses propres assertions. - Comme vous pouvez le voir dans - , la méthode - assertTrue() n'est qu'un enrobeur des méthodes + Lorsqu'on écrit des assertions personnalisées, c'est une bonne pratique + de suivre la façon dont PHPUnit implémente ses propres assertions. Comme vous pouvez le voir dans + , la méthode + assertTrue() ne fait qu'encapsuler les méthodes isTrue() et assertThat(): - isTrue() crée un objet de correspondance qui est passé à + isTrue() crée un objet matcher qui est passé à assertThat() pour évaluation. Les méthodes assertTrue() et isTrue() de la classe PHPUnit_Framework_Assert montre comment PHPUnit_Framework_Constraint_IsTrue étend la classe - abstraite de base pour des objets de correspondance (ou des contraintes), + abstraite de base pour des objets matcher (ou des contraintes), PHPUnit_Framework_Constraint. La classe PHPUnit_Framework_Constraint_IsTrue L'effort d'implémentation des méthodes assertTrue() et isTrue() ainsi que la classe - PHPUnit_Framework_Constraint_IsTrue tire bénéfice du fait que + PHPUnit_Framework_Constraint_IsTrue tire bénéfice du fait que assertThat() prend automatiquement soin d'évaluer l'assertion et les tâches de suivi comme le décompte à des fins de statistique. Plus encore, la méthode isTrue() peut être utilisée comme un matcher @@ -127,12 +129,15 @@ class PHPUnit_Framework_Constraint_IsTrue extends PHPUnit_Framework_Constraint PHPUnit_Framework_TestListener - montre une implémentation simple de l'interface PHPUnit_Framework_TestListener. + montre une implémentation simple de l'interface + PHPUnit_Framework_TestListener. Un simple moniteur de test ]]> + + PHPUnit_Framework_BaseTestListener + + + montre comment étendre la classe abstraite + PHPUnit_Framework_BaseTestListener, qui permet de spécifier uniquement les méthodes d'interface + qui sont intéressantes pour votre cas d'utilisation, tout en fournissant des implémentations vides p + our tous les autres. + + + + Utiliser BaseTestListener + getName()); + } +} +?>]]> + + Dans vous pouvez voir - comment configurer PHPUnit pour brancher votre moniteur de test lors de l'exécution des tests. + comment configurer PHPUnit pour brancher votre moniteur de test lors de l'exécution + des tests.
- Sous classer PHPUnit_Extensions_TestDecorator + Hériter de PHPUnit_Extensions_TestDecorator PHPUnit_Extensions_TestDecorator @@ -198,30 +229,29 @@ class SimpleTestListener implements PHPUnit_Framework_TestListener Vous pouvez encapsuler des cas de test ou des séries de tests dans une sous-classe de PHPUnit_Extensions_TestDecorator et utiliser le Design Pattern Decorator pour réaliser certaines actions avant et après - que les tests sont exécutés. + que les tests soient exécutés. PHPUnit_Extensions_RepeatedTest - PHPUnit_Extensions_TestSetup - PHPUnit apporte deux décorateurs de test concrets: - PHPUnit_Extensions_RepeatedTest et - PHPUnit_Extensions_TestSetup. Le premier est utilisé pour + PHPUnit apporte un décorateur de test concrets : + PHPUnit_Extensions_RepeatedTest. Il est utilisé pour exécuter de manière répétée un test et ne le comptabiliser comme succès que si - toutes les itérations ont réussi. Le second est discuté dans . + toutes les itérations ont réussi. - montre une version raccourcie du décorateur de test - PHPUnit_Extensions_RepeatedTest qui illustre comment - écrire vos propres décorateurs de tests. + montre une version raccourcie du décorateur de test PHPUnit_Extensions_RepeatedTest + qui illustre comment écrire vos propres décorateurs de tests. Le décorateur RepeatedTest timesRepeat * $this->test->count(); } - public function run(PHPUnit_Framework_TestResult $result = NULL) + public function run(PHPUnit_Framework_TestResult $result = null) { - if ($result === NULL) { + if ($result === null) { $result = $this->createResult(); } @@ -267,18 +297,17 @@ class PHPUnit_Extensions_RepeatedTest extends PHPUnit_Extensions_TestDecorator PHPUnit_Framework_Test Tests dirigés par les données - L'interface PHPUnit_Framework_Test est restreinte et - facile à implémenter. Vous pouvez écrire une implémentation de - PHPUnit_Framework_Test qui est plus simple que - PHPUnit_Framework_TestCase et qui exécute + L'interface PHPUnit_Framework_Test est restreinte et + facile à implémenter. Vous pouvez écrire une implémentation de + PHPUnit_Framework_Test qui est plus simple que + PHPUnit\Framework\TestCase et qui exécute des tests dirigés par les données, par exemple. - montre une classe de cas de test dirigé par les tests qui compare les - valeurs d'un fichier contenant des valeurs séparées par des virgules (CSV). - Chaque ligne d'un tel fichier ressemble à + montre une classe de cas de test dirigé par les tests qui compare les valeurs d'un fichier contenant + des valeurs séparées par des virgules (CSV). Chaque ligne d'un tel fichier ressemble à foo;bar, où la première valeur est celle que nous attendons et la seconde valeur celle constatée. @@ -286,7 +315,9 @@ class PHPUnit_Extensions_RepeatedTest extends PHPUnit_Extensions_TestDecorator Un test dirigé par les données lines as $line) { $result->startTest($this); PHP_Timer::start(); - $stopTime = NULL; + $stopTime = null; list($expected, $actual) = explode(';', $line); @@ -329,7 +360,7 @@ class DirigeParLesDonneesTest implements PHPUnit_Framework_Test $result->addError($this, $e, $stopTime); } - if ($stopTime === NULL) { + if ($stopTime === null) { $stopTime = PHP_Timer::stop(); } @@ -340,8 +371,8 @@ class DirigeParLesDonneesTest implements PHPUnit_Framework_Test } } -$test = new DataDrivenTest('fichier_donnees.csv'); -$resultat = PHPUnit_TextUI_TestRunner::run($test); +$test = new DataDrivenTest('data_file.csv'); +$result = PHPUnit_TextUI_TestRunner::run($test); ?>]]> difference < x> got string -/home/sb/DirigeParLesDonneesTest.php:32 -/home/sb/DirigeParLesDonneesTest.php:53 +/home/sb/DataDrivenTest.php:32 +/home/sb/DataDrivenTest.php:53 FAILURES! Tests: 2, Failures: 1.]]> diff --git a/src/6.1/fr/fixtures.xml b/src/6.1/fr/fixtures.xml index 592a8d82f..24502cd0f 100644 --- a/src/6.1/fr/fixtures.xml +++ b/src/6.1/fr/fixtures.xml @@ -14,26 +14,26 @@ Dans , la - fixture était simplement le tableau sauvegardé dans la variable $fixture. + fixture était simplement le tableau sauvegardé dans la variable $stack. La plupart du temps, cependant, la fixture sera beaucoup plus complexe qu'un simple tableau, et le volume de code nécessaire pour la mettre en place croîtra dans les mêmes proportions. Le contenu effectif du test sera perdu - dans le bruit de configuration de la fixture. Ce problème s'aggrave quand + dans le bruit de configuration de la fixture. Ce problème s'aggrave quand vous écrivez plusieurs tests doté de fixtures similaires. Sans l'aide du framework de test, nous aurions à dupliquer le code qui configure la fixture pour chaque test que nous écrivons. - Méthode canevas + Méthode template setUp() tearDown() PHPUnit gère le partage du code de configuration. Avant qu'une méthode de test ne soit - lancée, une méthode canevas appelée setUp() est invoquée. + lancée, une méthode template appelée setUp() est invoquée. setUp() est l'endroit où vous créez les objets sur lesquels vous allez passer les tests. Une fois que la méthode de test est finie, qu'elle ait - réussi ou échoué, une autre méthode canevas appelée + réussi ou échoué, une autre méthode template appelée tearDown() est invoquée. tearDown() est l'endroit où vous nettoyez les objets sur lesquels vous avez passé les tests. @@ -42,65 +42,68 @@ Dans nous avons utilisé la relation producteur-consommateur entre les tests pour partager une fixture. Ce n'est pas toujours souhaitable ni même possible. - montre comme nous pouvons écrire les tests de PileTest de telle façon + montre comme nous pouvons écrire les tests de StackTest de telle façon que ce n'est pas la fixture elle-même qui est réutilisée mais le code qui l'a créée. - D'abord nous déclarons la variable d'instance, $pile, que nous + D'abord nous déclarons la variable d'instance, $stack, que nous allons utiliser à la place d'une variable locale à la méthode. Puis nous plaçons - la création de la fixture tableau dans la méthode + la création de la fixture tableau dans la méthode setUp(). Enfin, nous supprimons le code redondant des méthodes de test et nous utilisons la variable d'instance nouvellement introduite. - $this->pile, à la place de la variable locale à la méthode - $pile avec la méthode d'assertion assertEquals(). + $this->stack, à la place de la variable locale à la méthode + $stack avec la méthode d'assertion + assertEquals(). - Using setUp() to create the stack fixture + Utiliser setUp() pour créer les fixtures stack pile = array(); + $this->stack = []; } - public function testVide() + public function testEmpty() { - $this->assertTrue(empty($this->pile)); + $this->assertTrue(empty($this->stack)); } public function testPush() { - array_push($this->pile, 'foo'); - $this->assertEquals('foo', $this->pile[count($this->pile)-1]); - $this->assertFalse(empty($this->pile)); + array_push($this->stack, 'foo'); + $this->assertEquals('foo', $this->stack[count($this->stack)-1]); + $this->assertFalse(empty($this->stack)); } public function testPop() { - array_push($this->pile, 'foo'); - $this->assertEquals('foo', array_pop($this->pile)); - $this->assertTrue(empty($this->pile)); + array_push($this->stack, 'foo'); + $this->assertEquals('foo', array_pop($this->stack)); + $this->assertTrue(empty($this->stack)); } } ?>]]> - Méthode canevas + Méthode template setUpBeforeClass() setUp() tearDown() tearDownAfterClass() - Les méthodes canevas setUp() et tearDown() + Les méthodes template setUp() et tearDown() sont exécutées une fois pour chaque méthode de test (et pour les nouvelles instances) de la classe de cas de test. - Méthode canevas + Méthode template setUpBeforeClass() setUp() assertPreConditions() @@ -109,23 +112,25 @@ class PileTest extends PHPUnit_Framework_TestCase tearDownAfterClass() onNotSuccessfulTest() - De plus, les méthodes canevas setUpBeforeClass() et - tearDownAfterClass() sont appelées respectivement avant + De plus, les méthodes template setUpBeforeClass() et + tearDownAfterClass() sont appelées respectivement avant que le premier test de la classe de cas de test ne soit exécuté et après que le dernier test de la classe de test a été exécuté. - Méthode canevas + Méthode template - L'exemple ci-dessous montre toutes les méthodes canevas qui sont disponibles + L'exemple ci-dessous montre toutes les méthodes template qui sont disponibles dans une classe de cas de test. - Exemple montrant toutes les méthodes canevas disponibles + Exemple montrant toutes les méthodes template disponibles assertTrue(TRUE); + $this->assertTrue(true); } public function testTwo() { fwrite(STDOUT, __METHOD__ . "\n"); - $this->assertTrue(FALSE); + $this->assertTrue(false); } protected function assertPostConditions() @@ -210,16 +215,15 @@ Tests: 2, Assertions: 2, Failures: 1.]]> setUp() et tearDown() sont sympathiquement - symétriques en théorie mais pas en pratique. En pratique, vous n'avez besoin + symétriques en théorie mais pas en pratique. En pratique, vous n'avez besoin d'implémenter tearDown() que si vous avez alloué des ressources externes telles que des fichiers ou des sockets dans setUp(). Si votre setUp() ne crée simplement - que de purs objets PHP, vous pouvez généralement ignorer tearDown(). + que de purs objets PHP, vous pouvez généralement ignorer tearDown(). Cependant, si vous créez de nombreux objets dans votre setUp(), vous pourriez vouloir libérer (unset()) les variables pointant vers ces objets dans votre tearDown() de façon à ce qu'ils puissent être - récupérés par le ramasse-miettes. Le nettoyage des objets de cas de test n'est pas - prévisible. + récupérés par le ramasse-miettes. Le nettoyage des objets de cas de test n'est pas prévisible.
@@ -262,7 +266,7 @@ Tests: 2, Assertions: 2, Failures: 1.]]> Un bon exemple de fixture qu'il est raisonnable de partager entre plusieurs tests est une connexion à une base de données : vous vous connectez une fois - à la base de données et vous réutilisez cette connexion au lieu d'en créer + à la base de données et vous réutilisez cette connexion au lieu d'en créer une nouvelle pour chaque test. Ceci rend vos tests plus rapides. @@ -271,8 +275,8 @@ Tests: 2, Assertions: 2, Failures: 1.]]> tearDownAfterClass - utilise les méthodes canevas setUpBeforeClass() et - tearDownAfterClass() pour respectivement établir la connexion à la + utilise les méthodes template setUpBeforeClass() et + tearDownAfterClass() pour respectivement établir la connexion à la base de données avant le premier test de la classe de cas de test et pour de déconnecter de la base de données après le dernier test du cas de test. @@ -280,7 +284,9 @@ Tests: 2, Assertions: 2, Failures: 1.]]> Partager les fixtures entre les tests d'une série de tests ]]> @@ -300,10 +306,9 @@ class DatabaseTest extends PHPUnit_Framework_TestCase On n'insistera jamais assez sur le fait que partager les fixtures entre les tests réduit la valeur de ces tests. Le problème de conception - sous-jacent est que les objets ne sont pas faiblement couplés. Vous pourrez - obtenir de meilleurs résultats en résolvant le problème de conception - sous-jacent puis en écrivant des tests utilisant des bouchons - (voir ), plutôt qu'en créant + sous-jacent est que les objets ne sont pas faiblement couplés. Vous pourrez obtenir de meilleurs + résultats en résolvant le problème de conception sous-jacent puis en écrivant des tests + utilisant des bouchons (voir ), plutôt qu'en créant des dépendances entre les tests à l'exécution et en ignorant l'opportunité d'améliorer votre conception. @@ -315,7 +320,7 @@ class DatabaseTest extends PHPUnit_Framework_TestCase Il est difficile de tester du code qui utilise des singletons. La même chose est vraie pour le code qui utilise des variables globales. Typiquement, - le code que vous voulez tester est fortement couplé avec une variable globale et + le code que vous voulez tester est fortement couplé avec une variable globale et vous ne pouvez pas contrôler sa création. Un problème additionnel réside dans le fait qu'un test qui modifie une variable globale peut faire échouer un autre test. @@ -340,31 +345,39 @@ class DatabaseTest extends PHPUnit_Framework_TestCase Variables globales Indépendance des tests - Par défaut, PHPUnit exécute vos tests de façon à ce que des modifications - aux variables globales et super-globales ( - $GLOBALS, + Avant la version 6, par défaut, PHPUnit exécute vos tests de façon à ce que des modifications + aux variables globales et super-globales ($GLOBALS, $_ENV, $_POST, $_GET, $_COOKIE, $_SERVER, $_FILES, - $_REQUEST) n'affectent pas les autres tests. Optionnellement, - cette indépendance peut être étendue aux attributs statiques des classes. + $_REQUEST) n'affectent pas les autres tests. + + + + À partir de la version 6, PHPUnit n'effectue plus ces opérations de sauvegarde + et restauration pour les variables globales et super-globales par défaut. + Il peut être activé en utilisant l'option --globals-backup + ou le paramètre backupGlobals="true" dans le + fichier XML de configuration. + + + + En utilisant l'option --static-backup ou le paramètre + backupStaticAttributes="true" dans le + fichier XML de configuration, cet isolation peut être étendue aux attributs statiques + des classes. - - L'implémentation des opérations de sauvegarde et de restauration des attributs - statiques des classes nécessite PHP 5.3 (ou supérieur). - L'implémentation des opérations de sauvegarde et de restauration des variables - globales et des attributs statiques des classes utilise + globales et des attributs statiques des classes utilise serialize() et unserialize(). - Les objets de certaines classes qui sont fournis pas PHP lui-même, tel que - PDO par exemple, ne peuvent pas être sérialisés si bien que - l'opération de sauvegarde va échouer quand un tel objet sera enregistré dans le tableau - $GLOBALS, par exemple. + Les objets de certaines classes (tel que PDO par exemple), ne peuvent + pas être sérialisés si bien que l'opération de sauvegarde va échouer quand un tel objet sera e + nregistré dans le tableau $GLOBALS, par exemple. @@ -372,14 +385,14 @@ class DatabaseTest extends PHPUnit_Framework_TestCase @backupGlobals $backupGlobalsBlacklist - L'annotation @backupGlobals qui est discutée dans - peut être utilisée pour + L'annotation @backupGlobals qui est discutée dans + peut être utilisée pour contrôler les opérations de sauvegarde et de restauration des variables globales. Alternativement, vous pouvez fournir une liste noire des variables globales qui doivent être exclues des opérations de sauvegarde et de restauration comme ceci : - class MonTest extends PHPUnit_Framework_TestCase + class MyTest extends TestCase { - protected $backupGlobalsBlacklist = array('globalVariable'); + protected $backupGlobalsBlacklist = ['globalVariable']; // ... } @@ -387,7 +400,7 @@ class DatabaseTest extends PHPUnit_Framework_TestCase - Merci de noter que le réglage de l'attribut $backupGlobalsBlacklist + Paramétrer l'attribut $backupGlobalsBlacklist à l'intérieur de la méthode setUp(), par exemple, n'a aucun effet. @@ -396,24 +409,61 @@ class DatabaseTest extends PHPUnit_Framework_TestCase @backupStaticAttributes $backupStaticAttributesBlacklist - L'annotation @backupStaticAttributes qui est discutée dans - peut être utilisée pour - contrôler les opérations de sauvegarde et de restauration des attributs statiques. - Alternativement, vous pouvez fournir une liste noire des attributs statiques qui doivent - être exclus des opérations de sauvegarde et de restauration comme ceci : - class MonTest extends PHPUnit_Framework_TestCase + L'annotation @backupStaticAttributes qui est discutée dans + peut être utilisée pour + sauvegarder toutes les propriétés statiques dans toutes les classes déclarées + avant chaque test et les restaurer ensuite. + + + + Il traite toutes les classes déclarées au démarrage d'un test, et pas + seulement la classe de test elle-même. Cela s'applique uniquement aux propriétés + de classe statiques, pas aux variables statiques dans les fonctions. + + + + + L'opération @backupStaticAttributes est exécutée + avant une méthode de test, mais seulment si c'est activé. Si une valeur statique a été changée + par un test exécuté précédement qui n'as activé + @backupStaticAttributes, alors cette valeur sera + sauvegardée et restaurée — pas la valeur par défaut originale. + PHP n'enregistre pas la valeur par défaut déclarée à l'origine de + toute variable statique. + + + La même chose s'applique aux propriétés statiques des classes nouvellement + chargées/déclarées dans un test. Ils ne peuvent pas être réinitialisés à leur valeur par défaut + déclarée à l'origine après le test, puisque cette valeur est inconnue. + Quelle que soit la valeur définie, elle fuira dans les tests suivants. + + + Pour un test unitaire, il est recommandé de plutôt réinitialiser explicitement + les valeurs des propriétés statiques testées dans le code de setUp() + (et idéalement aussi tearDown(), de manière à ne pas affecter + les prochains tests executés). + + + + + Vous pouvez fournir une liste noire d'attributs statiques qui doivent être + exclus des opération de sauvegarde et de restauration: + + +class MyTest extends TestCase { - protected $backupStaticAttributesBlacklist = array( - 'className' => array('attributeName') - ); + protected $backupStaticAttributesBlacklist = [ + 'className' => ['attributeName'] + ]; // ... -} +} + - Merci de noter que le réglage de l'attribut $backupStaticAttributesBlacklist + Paramétrer l'attribut $backupStaticAttributesBlacklist à l'intérieur de la méthode setUp(), par exemple, n'a aucun effet. diff --git a/src/6.1/fr/incomplete-and-skipped-tests.xml b/src/6.1/fr/incomplete-and-skipped-tests.xml index 158299d1c..3945c9c2e 100644 --- a/src/6.1/fr/incomplete-and-skipped-tests.xml +++ b/src/6.1/fr/incomplete-and-skipped-tests.xml @@ -8,17 +8,17 @@ Quand vous travaillez sur une nouvelle classe de cas de test, vous pourriez vouloir - commencer en écrivant des méthodes de test vides comme - public function testQuelquechose() + commencer en écrivant des méthodes de test vides comme : public function testQuelquechose() { -} pour garder la trace des tests que vous avez à écrire. Le problème avec +} pour garder la trace des tests que vous avez à écrire. Le problème avec les méthodes de test vides est qu'elles sont interprétées comme étant réussies par le framework PHPUnit. Cette mauvaise interprétation fait que le rapport de tests devient inutile -- vous ne pouvez pas voir si un test est effectivement réussi ou s'il n'a tout - simplement pas été implémenté. Appeler + simplement pas été implémenté. Appeler $this->fail() dans une méthode de test non implémentée n'aide pas davantage, puisqu'alors le test sera interprété comme étant un échec. - Ce serait tout aussi faux que d'interpréter un test non implémenté comme étant réussi. + Ce serait tout aussi faux que d'interpréter un test non implémenté + comme étant réussi. @@ -30,16 +30,16 @@ comme à un feu rouge, nous avons besoin d'un feu orange additionnel pour signaler un test comme étant incomplet ou pas encore implémenté. PHPUnit_Framework_IncompleteTest est une interface de marquage - pour signaler une exception qui est levée par une méthode de test comme résultat - d'un test incomplet ou actuellement pas implémenté. - PHPUnit_Framework_IncompleteTestError est l'implémentation + pour signaler une exception qui est levée par une méthode de test comme résultat + d'un test incomplet ou pas encore implémenté. + PHPUnit_Framework_IncompleteTestError est l'implémentation standard de cette interface. - montre une classe de cas de tests, ExempleDeTest, qui contient une unique méthode de test, - method, testSomething(). En appelant la méthode pratique + montre une classe de cas de tests, SampleTest, qui contient une unique méthode de + test, testSomething(). En appelant la méthode pratique markTestIncomplete() (qui lève automatiquement une exception PHPUnit_Framework_IncompleteTestError) dans la méthode de test, nous marquons le test comme étant incomplet. @@ -48,16 +48,18 @@ Signaler un test comme incomplet assertTrue(TRUE, 'Ceci devrait toujours fonctionner.'); + // Optional: Test anything here, if you want. + $this->assertTrue(true, 'This should already work.'); - // Cesser ici et marquer ce test comme incomplet. + // Stop here and mark this test as incomplete. $this->markTestIncomplete( - 'Ce test n\'a pas encore été implémenté.' + 'This test has not been implemented yet.' ); } } @@ -67,10 +69,10 @@ class ExempleDeTest extends PHPUnit_Framework_TestCase Un test incomplet est signalé par un I sur la sortie écran du lanceur de test en ligne de commandes PHPUnit, comme montré dans l'exemple - suivant. + suivant : - phpunit --verbose ExempleDeTest + phpunit --verbose SampleTest PHPUnit 6.1.0 by Sebastian Bergmann and contributors. I @@ -79,10 +81,10 @@ Time: 0 seconds, Memory: 3.95Mb There was 1 incomplete test: -1) ExempleDeTest::testQuelquechose +1) SampleTest::testSomething This test has not been implemented yet. -/home/sb/ExempleDeTest.php:12 +/home/sb/SampleTest.php:12 OK, but incomplete or skipped tests! Tests: 1, Assertions: 1, Incomplete: 1. @@ -128,7 +130,7 @@ Tests: 1, Assertions: 1, Incomplete: 1. montre une classe de cas de tests, DatabaseTest, qui contient une méthode de tests - testConnection(). Dans la méthode canevas setUp() + testConnection(). Dans le patron de méthode setUp() de la classe du cas de test, nous pouvons contrôler si l'extension MySQLi est disponible et utiliser la méthode markTestSkipped() pour sauter le test si ce n'est pas le cas. @@ -137,13 +139,15 @@ Tests: 1, Assertions: 1, Incomplete: 1. Sauter un test markTestSkipped( - 'L\'extension MySQLi n\'est pas disponible.' + 'The MySQLi extension is not available.' ); } } @@ -239,6 +243,12 @@ Tests: 1, Assertions: 0, Skipped: 1. @requires PHPUnit 3.6.3 @requires PHPUnit 4.6 + + OS + Une expression regulière qui match PHP_OS + @requires OS Linux + @requires OS WIN32|WINNT + function Tout paramètre valide pour function_exists @@ -249,7 +259,7 @@ Tests: 1, Assertions: 0, Skipped: 1. extension Tout nom d'extension @requires extension mysqli - @requires extension curl + @requires extension redis 2.2.0 @@ -258,27 +268,29 @@ Tests: 1, Assertions: 0, Skipped: 1. Sauter des cas de tests en utilisant @requires = 5.3 + // Test requires the mysqli extension and PHP >= 5.3 } - // ... Tous les autres tests nécessitent l'extension mysqli + // ... All other tests require the mysqli extension } ?>]]> - - Si vous utilisez une syntaxe qui ne compile pas avec une version données de PHP, regardez - dans la configuration xml pour les inclusions dépendant de la version dans - + + + Si vous utilisez une syntaxe qui ne compile pas avec une version données de PHP, regardez + dans la configuration xml pour les inclusions dépendant de la version dans
diff --git a/src/6.1/fr/installation.xml b/src/6.1/fr/installation.xml index 6c88db394..67b265c6c 100644 --- a/src/6.1/fr/installation.xml +++ b/src/6.1/fr/installation.xml @@ -3,225 +3,364 @@ Installer PHPUnit - - PHPUnit doit être installé en utilisant l'installateur PEAR, la colonne vertébrale du - dépôt d'extensions et d'applications PHP (PHP Extension and Application - Repository) qui apporte un système de distribution pour les paquets PHP. - +
+ Pré-requis - - Selon votre distribution de système d'exploitation et/ou votre environnement PHP, - vous pouvez avoir besoin d'installer PEAR ou de mettre à jour votre installation - existante de PEAR avant de pouvoir suivre les instructions de ce chapitre. + PHPUnit 6.1 nécessite PHP 7; utiliser la dernière version de PHP est fortement + recommandé. - sudo pear upgrade PEAR suffit habituellement pour - mettre à jour une installation PEAR existante. Le manuel PEAR - explique comment réaliser une nouvelle installation de PEAR. + PHPUnit nécessite les extensions dom et json + qui sont traditionnellement activées par défaut. - - - PHPUnit 4.6 nécessite PHP 5.4.8 (ou ultérieur) mais PHP 5.5.0 (ou ultérieur) est - fortement recommandé. + PHPUnit nécessite aussi les extensions + pcre, + reflection, + et spl. + Ces extensions standard sont activées par défaut et ne peuvent être désactivées + sans patcher le système de construction de PHP ou/et les sources en C. - PHP_CodeCoverage, la bibliothèque qui est utilisée par PHPUnit pour rassembler et - traiter les informations de couverture de code, dépend de Xdebug 2.2.1 (ou ultérieure) mais - Xdebug 2.3.0 (ou ultérieur) est fortement recommandé. + La fonctionnalité de couverture de code nécessite l'extension + Xdebug (2.5.0 ou ultérieur) et + tokenizer. + + + La génération des rapports XML nécessite l'extension + xmlwriter. + + +
+ +
+ PHP Archive (PHAR) + + + La manière la plus simple d'obtenir PHPUnit est de téléchargerl'Archive PHP (PHAR) qui contient toutes les + dépendances requises (ainsi que certaines optionnelles) de PHPUnit archivées en un seul + fichier. + + + + L'extension phar + est requise pour utilisé les archives PHP (PHAR). + + + + Si l'extension Suhosin est + activé, vous devez autoriser l'exécution des PHAR dans votre + php.ini: + + +suhosin.executor.include.whitelist = phar + - - - - Les deux commandes suivantes (que vous aurez peut-être à exécuter en tant que - super-administrateur, i.e. root )sont tout ce qui est nécessaire - pour installer PHPUnit en utilisant l'installateur PEAR: - - - pear config-set auto_discover 1 -pear install pear.phpunit.de/PHPUnit - - - Les paquets facultatifs suivants sont disponibles : - - - - - DbUnit - - - Portage de DbUnit pour PHP/PHPUnit destiné à gérer les tests interagissant avec des bases de données. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/DbUnit - - - - - PHPUnit_Selenium - - - Intégration de Selenium RC pour PHPUnit. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_Selenium - - - - - PHPUnit_Story - - - Lanceur de tests basés sur des histoires pour les développements dirigés par le comportement (Behavior-Driven Development) avec PHPUnit. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_Story - - - - - PHPUnit_SkeletonGenerator - - - Outil qui permet de générer des squelettes de classes de test à partir des classes du code - de production et vice versa. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_SkeletonGenerator - - - - - PHPUnit_TestListener_DBUS - - - Un moniteur de tests qui envoie des événements à DBUS. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_TestListener_DBUS - - - - - PHPUnit_TestListener_XHProf - - - Un moniteur de tests qui utilise XHProf pour profiler automatiquement le code testé. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_TestListener_XHProf - - - - - PHPUnit_TicketListener_Fogbugz - - - Un moniteur de tickets qui interagit avec l'API d'incidents de FogBugz. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_TicketListener_Fogbugz - - - - - PHPUnit_TicketListener_GitHub - - - Un moniteur de tickets qui interagit avec l'API d'incidents de GitHub. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_TicketListener_GitHub - - - - - PHPUnit_TicketListener_GoogleCode - - - Un moniteur de tickets qui interagit avec l'API d'incidents de Google Code. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_TicketListener_GoogleCode - - - - - PHPUnit_TicketListener_Trac - - - Un moniteur de tickets qui interagit avec l'API d'incidents de Trac. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHPUnit_TicketListener_Trac - - - - - PHP_Invoker - - - Une classe utilitaire pour invoquer des appels avec un délai d'expiration. Ce paquet est - nécessaire pour mettre en oeuvre des dépassements de délais pour les tests en mode strict. - - - - Ce paquet peut être installé en utilisant la commande suivante : - - - pear install phpunit/PHP_Invoker - - - - - - Après l'installation, vous trouverez les fichiers du code source de PHPUnit dans votre - répertoire local PEAR; le chemin d'accès est habituellement - /usr/lib/php/PHPUnit. - + + + Pour installer le PHAR de manière globale : + + + +$ wget https://phar.phpunit.de/phpunit-6.1.phar +$ chmod +x phpunit-6.1.phar +$ sudo mv phpunit-6.1.phar /usr/local/bin/phpunit +$ phpunit --version +PHPUnit x.y.z by Sebastian Bergmann and contributors. + + + + Vous pouvez également utiliser directement le fichier PHAR téléchargé: + + + +$ wget https://phar.phpunit.de/phpunit-6.1.phar +$ php phpunit-6.1.phar --version +PHPUnit x.y.z by Sebastian Bergmann and contributors. + + +
+ Windows + + + L'installation globale du PHAR implique la même procédure que l'installation + + manuelle de Composer sous Windows: + + + + + + Créer un répertoire pour les binaires PHP; ex. : C:\bin + + + + + Ajouter ;C:\bin à votre variable d'environnement + PATH + (related help) + + + + + Télécharger et + sauvegarder le fichier sous C:\bin\phpunit.phar + + + + + Ouvrir une ligne de commande (par exemple, + appuyez WindowsR + » et tapez cmd + » ENTER) + + + + + Créer un script batch (dans + C:\bin\phpunit.cmd): + + +C:\Users\username> cd C:\bin +C:\bin> echo @php "%~dp0phpunit.phar" %* > phpunit.cmd +C:\bin> exit + + + + + Ouvrez une nouvelle ligne de commande et confirmez que vous pouvez exécuter PHPUnit à partir de n'importe + quel chemin: + + +C:\Users\username> phpunit --version +PHPUnit x.y.z by Sebastian Bergmann and contributors. + + + + + + Pour les environments shell Cygwin et/ou MingW32 (ex: TortoiseGit), vous + passer l'étape 5. ci-dessus, il suffit de sauvegarder le fichier + phpunit (sans l'extension .phar), + et de le rendre executable via + chmod 775 phpunit. + + +
+ +
+ Vérification des versions PHAR de PHPUnit + + + Toutes les versions officielles de code distribuées par le projet PHPUnit sont + signées par le responsable de publication de la version. Les signatures PGP et les hachages + SHA1 sont disponibles pour vérification sur phar.phpunit.de. + + + + L'exemple suivant détaille le fonctionnement de la vérification de version. Nous commençons + par tlécharger phpunit.phar ainsi que sa + signature PGP détachée phpunit.phar.asc: + + + wget https://phar.phpunit.de/phpunit.phar +wget https://phar.phpunit.de/phpunit.phar.asc + + + Nous voulons vérifier l'archive PHP Phar de PHPUnit (phpunit.phar) + par rapport à sa signature détachée (phpunit.phar.asc): + + + gpg phpunit.phar.asc +gpg: Signature made Sat 19 Jul 2014 01:28:02 PM CEST using RSA key ID 6372C20A +gpg: Can't check signature: public key not found + + + Nous n'avons pas la clé publique du responsable de la publication (6372C20A) + dans notre système local. Afin de procéder à la vérification, nous devons récupérer la clé + publique du gestionnaire de versions à partir d'un serveur de clés. Un de + ces serveurs est pgp.uni-mainz.de. Les serveurs de clés publiques + sont liés entre eux, vous devriez donc pouvoir vous connecter à n'importe quel serveur de clés. + + + gpg --keyserver pgp.uni-mainz.de --recv-keys 0x4AA394086372C20A" imported +gpg: Total number processed: 1 +gpg: imported: 1 (RSA: 1)]]> + + + Nous avons maintenant reçu une clé publique pour une entité appelée "Sebastian + Bergmann <sb@sebastian-bergmann.de>". Cependant, nous n'avons aucun moyen + de vérifier que cette clé a été créée par la personne connue sous le nom de Sebastian + Bergmann. Mais, essayons de vérifier à nouveau la signature de la version délivrée. + + + gpg phpunit.phar.asc" +gpg: aka "Sebastian Bergmann " +gpg: aka "Sebastian Bergmann " +gpg: aka "Sebastian Bergmann " +gpg: aka "Sebastian Bergmann " +gpg: aka "[jpeg image of size 40635]" +gpg: WARNING: This key is not certified with a trusted signature! +gpg: There is no indication that the signature belongs to the owner. +Primary key fingerprint: D840 6D0D 8294 7747 2937 7831 4AA3 9408 6372 C20A]]> + + + À ce stade, la signature est bonne, mais nous ne faisons pas confiance à cette clé. Une + bonne signature signifie que le fichier n'a pas été falsifié. Cependant, en raison + de la nature de la cryptographie à clé publique, vous devez également + vérifier que la clé 6372C20A a été créée par le vrai + Sebastian Bergmann. + + + + Tout attaquant peut créer une clé publique et l'uploader sur les serveurs de clés + publiques. Ils peuvent ensuite créer une version malveillante signée par cette fausse + clé. Ensuite, si vous essayiez de vérifier la signature de cette version corrompue, + cela réussirait car la clé n'était pas la "vraie" clé. Par conséquent, vous + devez valider l'authenticité de cette clé. La validation de + l'authenticité d'une clé publique est toutefois hors de la portée de cette + documentation. + + + + Il peut être prudent de créer un script shell pour gérer l'installation de PHPUnit + qui vérifie la signature de GnuPG avant d'exécuter votre suite de tests. Par + exemple: + + + + gpg --fingerprint D8406D0D82947747293778314AA394086372C20A + if [ $? -ne 0 ]; then + echo -e "\033[31mCould not download PGP public key for verification\033[0m" + exit + fi +fi + +if [ "$clean" -eq 1 ]; then + # Let's clean them up, if they exist + if [ -f phpunit.phar ]; then + rm -f phpunit.phar + fi + if [ -f phpunit.phar.asc ]; then + rm -f phpunit.phar.asc + fi +fi + +# Let's grab the latest release and its signature +if [ ! -f phpunit.phar ]; then + wget https://phar.phpunit.de/phpunit.phar +fi +if [ ! -f phpunit.phar.asc ]; then + wget https://phar.phpunit.de/phpunit.phar.asc +fi + +# Verify before running +gpg --verify phpunit.phar.asc phpunit.phar +if [ $? -eq 0 ]; then + echo + echo -e "\033[33mBegin Unit Testing\033[0m" + # Run the testing suite + `$after_cmd` + # Cleanup + if [ "$clean" -eq 1 ]; then + echo -e "\033[32mCleaning Up!\033[0m" + rm -f phpunit.phar + rm -f phpunit.phar.asc + fi +else + echo + chmod -x phpunit.phar + mv phpunit.phar /tmp/bad-phpunit.phar + mv phpunit.phar.asc /tmp/bad-phpunit.phar.asc + echo -e "\033[31mSignature did not match! PHPUnit has been moved to /tmp/bad-phpunit.phar\033[0m" + exit 1 +fi + ]]> +
+
+ +
+ Composer + + + Ajoutez simplement une dépendance (au développement) à + phpunit/phpunit au fichier + composer.json de votre projet si vous utilisez Composer pour gérer les + dépendances de votre projet : + + + composer require --dev phpunit/phpunit ^6.1 +
+ +
+ Paquets optionnels + + + Les packages optionnels suivants sont disponibles: + + + + + + PHP_Invoker + + + + + Une classe d'utilitaire pour invoquer des appelables avec un délai d'expiration. Ce package est + requis pour appliquer les délais d'attente de test en mode strict. + + + + Ce package est inclus dans la distribution PHAR de PHPUnit. Il peut + être installée via Composer en utilisant la commande suivate: + + + composer require --dev phpunit/php-invoker + + + + + + DbUnit + + + + + Portage DbUnit pour PHP/PHPUnit pour prendre en charge le test d'interaction de base de données. + + + + Ce package n'est pas inclus dans la distribution PHAR de PHPUnit. Il peut + être installée via Composer en utilisant la commande suivante: + + + composer require --dev phpunit/dbunit + + + +
diff --git a/src/6.1/fr/logging.xml b/src/6.1/fr/logging.xml index a7aae6893..fe1459c1c 100644 --- a/src/6.1/fr/logging.xml +++ b/src/6.1/fr/logging.xml @@ -6,39 +6,37 @@ Journalisation - PHPUnit peut produire plusieurs types de fichiers de journalisations (logs). + PHPUnit peut produire plusieurs types de fichiers de logs.
Résultats de test (XML) - Le fichier de journalisation XML pour les tests produits par PHPUnit est basé sur celui - qui est utilisé par la tâche - JUnit - de l'outil Apache Ant. L'exemple suivant montre que le fichier - de journalisation XML généré pour les tests dans - TestTableau: + Le fichier de log XML pour les tests produits par PHPUnit est basé sur celui + qui est utilisé par la tâche JUnit + de Apache Ant. L'exemple suivant montre que le fichier + de log XML généré pour les tests dans TestTableau : - - - @@ -46,138 +44,69 @@ ]]> - Le fichier de journalisation XML suivant a été généré pour deux tests, - testEchec et testErreur, - à partir d'une classe de cas de test nommée EchecErreurTest et + Le fichier de log XML suivant a été généré pour deux tests, + testFailure et testError, + à partir d'une classe de cas de test nommée FailureErrorTest et montre comment les échecs et les erreurs sont signalés. - -testFailure(EchecErreurTest) +testFailure(FailureErrorTest) Failed asserting that <integer:2> matches expected value <integer:1>. -/home/sb/EchecErreurTest.php:8 +/home/sb/FailureErrorTest.php:8 - testError(EchecErreurTest) + testError(FailureErrorTest) Exception: -/home/sb/EchecErreurTest.php:13 +/home/sb/FailureErrorTest.php:13 ]]>
-
- Résultats de test (TAP) - - - Le protocole Test Anything Protocol (TAP) - est une interface Perl simple au format texte entre les modules de test. L'exemple - suivant montre le fichier de journalisation TAP généré pour les tests de - TableauTest: - - - TAP version 13 -ok 1 - testNouveauTableauEstVide(TableauTest) -ok 2 - testTableauContientUnElement(TableauTest) -1..2 - - - Le fichier de journalisation TAP a été généré pour deux tests, - testEchec et testErreur - à partir d'une classe de cas de test nommée EchecErreurTest et - montre comme les échecs et les erreurs sont signalés. - - - matches expected value .' - severity: fail - data: - got: 2 - expected: 1 - ... -not ok 2 - Error: testErreur(EchecErreurTest) -1..2]]> -
- -
- Résultats de test (JSON) - - - La notation objet JavaScript (JavaScript Object Notation ou JSON) - est un format léger d'échange de données. L'exemple suivant montre les messages JSON - générés pour les tests dans TableauTest: - - - {"event":"suiteStart","suite":"TableauTest","tests":2} -{"event":"test","suite":"TableauTest", - "test":"testNouveauTableauEstVide(TableauTest)","status":"pass", - "time":0.000460147858,"trace":[],"message":""} -{"event":"test","suite":"TableauTest", - "test":"testTableauContientUnElement(TableauTest)","status":"pass", - "time":0.000422954559,"trace":[],"message":""} - - - Les messages JSON suivants ont été générés pour deux tests, - testEchec et testErreur, - d'une classe de cas de test nommée EchecErreurTest et - monte comment les échecs et les erreurs sont signalées. - - - is equal to ."} -{"event":"test","suite":"EchecErreurTest", - "test":"testErreur(EchecErreurTest)","status":"error", - "time":0.0083.90152893066,"trace":[],"message":""}]]> -
-
Couverture de code (XML) - La journalisation au format XML des informations de couverture de code produite par PHPUnit + Le format XML pour journaliser les informations de couverture de code produite par PHPUnit est faiblement basé sur celui utilisé par - Clover. L'exemple suivant montre le fichier de journalisation XML - généré pour les tests dans CompteBancaireTest: + Clover. L'exemple suivant montre le fichier de log XML + généré pour les tests dans BankAccountTest: - - - - + + + + - + @@ -210,32 +139,26 @@ not ok 2 - Error: testErreur(EchecErreurTest) Couverture de code (TEXTE) - Sortie de couverture de code humainement lisible pour la ligne de commandes ou un fichier texte. - + Un affichage de la couverture de code lisible pour la ligne de commandes ou un fichier texte. + Le but de ce format de sortie est de fournir un aperçu rapide de couverture en travaillant sur un petit ensemble de classes. Pour des projets plus grand - cette sortie peut être utile pour obtenir un aperçu rapide de la couverture - des projets ou quand il est utilisé avec la fonctionnalité - --filter. + cette sortie peut être utile pour obtenir un aperçu rapide de la couverture + des projets ou quand il est utilisé avec la fonctionnalité --filter. - Quand c'est utilisé à partir de la ligne de commande en écrivant sur - php://stdout, cela prend en compte le réglage - --colors. + Quand c'est utilisé à partir de la ligne de commande en écrivant sur php://stdout, + cela prend en compte le réglage --colors. - Ecrire sur la sortie standard est l'option par défaut quand on utilise la ligne - de commandes. + Ecrire sur la sortie standard est l'option par défaut quand on utilise la ligne de commandes. Par défaut, ceci ne montrera que les fichiers qui ont au moins une ligne couverte. - Ceci peut être modifié via l'option de configuration xml - showUncoveredFiles + Ceci peut uniquement être modifié via l'option de configuration xml showUncoveredFiles Voir . - -
- Sortie de couverture de code en couleurs sur la ligne de commandes + Par défaut, tous les fichier et leur status de couverture sont affichés dans le rapport détaillé. + Ceci peut être changé via l'option de configuration xml + showOnlySummary. + - -
-
diff --git a/src/6.1/fr/organizing-tests.xml b/src/6.1/fr/organizing-tests.xml index b224d5ae6..3efb79b77 100644 --- a/src/6.1/fr/organizing-tests.xml +++ b/src/6.1/fr/organizing-tests.xml @@ -6,9 +6,9 @@ Suite de tests - L'un des objectifs de PHPUnit est que les tests - soient combinables: nous voulons pouvoir exécuter n'importe quel nombre ou combinaison - de tests ensembles, par exemple tous les tests pour le projet entier, ou + L'un des objectifs de PHPUnit est que les tests + soient combinables : nous voulons pouvoir exécuter n'importe quel nombre ou combinaison + de tests ensembles, par exemple tous les tests pour le projet entier, ou les tests pour toutes les classes d'un composant qui constitue une partie du projet ou simplement les tests d'une seule classe particulière. @@ -22,141 +22,132 @@ Composer une suite de tests en utilisant le système de fichiers - La façon probablement la plus simple de composer une suite de tests est de conserver - tous les fichiers sources des cas de test dans un répertoire test. PHPUnit peut + La façon probablement la plus simple d'organiser une suite de tests est de mettre + tous les fichiers sources des cas de test dans un répertoire de tests. PHPUnit peut automatiquement trouver et exécuter les tests en parcourant récursivement le répertoire test. - Jetons un oeil à la suite de tests de la bibliothèque Object_Freezer. En regardant la structure des répertoires du projet, nous voyons que - les classes de cas de test dans le répertoire Tests reflètent la structure des - paquetages et des classes du système en cours de test (SCT, System Under Test ou SUT) dans le répertoire - Object: + Jetons un oeil à la suite de tests de la bibliothèque + sebastianbergmann/money. + En regardant la structure des répertoires du projet, nous voyons que + les classes des cas de test dans le répertoire tests reflètent la structure des + paquetages et des classes du système en cours de test (SCT, System Under Test ou SUT) dans le répertoire + src : - Object Tests -|-- Freezer |-- Freezer -| |-- HashGenerator | |-- HashGenerator -| | `-- NonRecursiveSHA1.php | | `-- NonRecursiveSHA1Test.php -| |-- HashGenerator.php | | -| |-- IdGenerator | |-- IdGenerator -| | `-- UUID.php | | `-- UUIDTest.php -| |-- IdGenerator.php | | -| |-- LazyProxy.php | | -| |-- Storage | |-- Storage -| | `-- CouchDB.php | | `-- CouchDB -| | | | |-- WithLazyLoadTest.php -| | | | `-- WithoutLazyLoadTest.php -| |-- Storage.php | |-- StorageTest.php -| `-- Util.php | `-- UtilTest.php -`-- Freezer.php `-- FreezerTest.php + src tests +`-- Currency.php `-- CurrencyTest.php +`-- IntlFormatter.php `-- IntlFormatterTest.php +`-- Money.php `-- MoneyTest.php +`-- autoload.php Pour exécuter tous les tests de la bibliothèque, nous n'avons qu'à faire - pointer le lanceur de tests en ligne de commandes de PHPUnit sur ce - répertoire test : + pointer le lanceur de tests en ligne de commandes de PHPUnit sur ce répertoire test : - phpunit Tests -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + phpunit --bootstrap src/autoload.php tests +PHPUnit 6.1.0 by Sebastian Bergmann. -............................................................ 60 / 75 -............... +................................. -Time: 0 seconds +Time: 636 ms, Memory: 3.50Mb -OK (75 tests, 164 assertions) +OK (33 tests, 52 assertions) - Si vous pointez le lanceur de tests en ligne de commandes de PHPUnit sur - un répertoire, il va chercher les fichiers - *Test.php. + Si vous pointez le lanceur de tests en ligne de commandes de PHPUnit sur + un répertoire, il va chercher les fichiers *Test.php. - Pour n'exécuter que les tests déclarés dans la classe de cas de test - Object_FreezerTest dans Tests/FreezerTest.php, + Pour n'exécuter que les tests déclarés dans la classe de cas de test + CurrencyTest dans tests/CurrencyTest, nous pouvons utiliser la commande suivante : - phpunit Tests/FreezerTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + phpunit --bootstrap src/autoload.php tests/CurrencyTest +PHPUnit 6.1.0 by Sebastian Bergmann. -............................ +........ -Time: 0 seconds +Time: 280 ms, Memory: 2.75Mb -OK (28 tests, 60 assertions) +OK (8 tests, 8 assertions) Pour un contrôle plus fin sur les tests à exécuter, nous pouvons utiliser - l'option --filter: + l'option --filter : - phpunit --filter testFreezingAnObjectWorks Tests -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. + phpunit --bootstrap src/autoload.php --filter testObjectCanBeConstructedForValidConstructorArgument tests +PHPUnit 6.1.0 by Sebastian Bergmann. -. +.. -Time: 0 seconds +Time: 167 ms, Memory: 3.00Mb -OK (1 test, 2 assertions) +OK (2 test, 2 assertions) Un inconvénient de cette approche est que nous n'avons pas de contrôle sur l'ordre dans lequel les tests sont exécutés. Ceci peut conduire à des problèmes - concernant les dépendances des tests, voir - . + concernant les dépendances des tests, voir . Dans la prochaine section, nous verrons comment nous pouvons rendre - l'ordre d'exécution des tests explicité en utilisant le fichier de - configuration XML. + l'ordre d'exécution des tests explicite en utilisant le fichier de configuration XML.
Composer une suite de tests en utilisant la configuration XML - XML Configuration + Configuration XML Le fichier de configuration XML de PHPUnit () peut aussi être utilisé pour composer une suite de tests. - montre un exemple minimaliste qui va ajouter toutes les classes *Test - trouvées dans les fichiers *Test.php quand - Tests est parcouru récursivement. + montre un exemple minimaliste d'un fichier phpunit.xml qui va ajouter toutes les classes + *Test trouvées dans les fichiers + *Test.php quand tests + est parcouru récursivement. Composer une suite de tests en utilisant la configuration XML - + - - Tests + + tests ]]> + + Si un fichier phpunit.xml ou + phpunit.xml.dist (dans cet ordre) existe dans + le répertoire de travail courant et que l'option --configuration n'est + pas utilisée, la configuration sera automatiquement + lue depuis ce fichier. + + L'ordre dans lequel les tests sont exécutés peut être rendu explicite : Composer une suite de tests en utilisant la configuration XML - + - - Tests/Freezer/HashGenerator/NonRecursiveSHA1Test.php - Tests/Freezer/IdGenerator/UUIDTest.php - Tests/Freezer/UtilTest.php - Tests/FreezerTest.php - Tests/Freezer/StorageTest.php - Tests/Freezer/Storage/CouchDB/WithLazyLoadTest.php - Tests/Freezer/Storage/CouchDB/WithoutLazyLoadTest.php + + tests/IntlFormatterTest.php + tests/MoneyTest.php + tests/CurrencyTest.php ]]> diff --git a/src/6.1/fr/other-uses-for-tests.xml b/src/6.1/fr/other-uses-for-tests.xml index 5d77811ea..28c4c9394 100644 --- a/src/6.1/fr/other-uses-for-tests.xml +++ b/src/6.1/fr/other-uses-for-tests.xml @@ -4,7 +4,7 @@ Autres utilisations des tests - Une fois que vous avez écrit des tests automatisés, vous découvrirez + Une fois que vous aurez l'habitude d'écrire des tests automatisés, vous découvrirez certainement davantage d'usages pour les tests. En voici quelques exemples. @@ -13,49 +13,45 @@ Documentation agile - Documentation générée automatiquement + Documentation automatisée Extreme Programming TestDox - Typiquement, dans un projet développé en utilisant un processus agile, + Typiquement, dans un projet développé en utilisant un processus agile, tel que l'Extreme Programming, la documentation ne peut pas suivre les changements fréquents de la conception et du code du projet. - l'Extreme Programming réclame la propriété collective du code, - donc tous les développeurs ont besoin de savoir comment fonctionne l'intégralité - du système. Si vous êtes suffisamment discipliné pour utiliser pour vos tests - des "noms parlant" qui décrivent ce qu'une classe doit faire, vous pouvez - utiliser la fonctionnalité TestDox de PHPUnit pour générer automatiquement - de la documentation pour votre projet en s'appuyant sur ses tests. - Cette documentation donne aux développeurs un aperçu de ce que chaque + l'Extreme Programming réclame la propriété collective du code, donc tous + les développeurs ont besoin de savoir comment fonctionne l'intégralité du système. Si vous êtes + suffisamment discipliné pour utiliser pour vos tests des "noms parlant" + qui décrivent ce qu'une classe doit faire, vous pouvez utiliser la fonctionnalité TestDox de PHPUnit + pour générer automatiquement de la documentation pour votre projet en s'appuyant + sur ses tests. Cette documentation donne aux développeurs un aperçu de ce que chaque classe du projet est supposée faire. La fonctionnalité TestDox de PHPUnit examine une classe de test et tous - les noms de méthode de test pour les convertir les noms au format Camel Case - PHP en phrases : - testBalanceEstInitialementAZéro() devient "Balance est - initialement a zero". S'il existe plusieurs méthodes de test dont les noms - ne diffèrent que par un suffixe constitué de un ou plusieurs chiffres, telles que - testBalanceNePeutPasEtreNégative() et - testBalanceNePeutPasEtreNégative2(), la phrase + les noms de méthode de test pour les convertir les noms PHP au format Camel Case en phrases : + testBalanceIsInitiallyZero() devient "Balance is + initially zero". S'il existe plusieurs méthodes de test dont les noms + ne diffèrent que par un suffixe constitué de un ou plusieurs chiffres, telles que + testBalanceCannotBecomeNegative() et + testBalanceCannotBecomeNegative2(), la phrase "Balance ne peut pas etre négative" n'apparaîtra qu'une seule fois, en supposant que tous ces tests ont réussi. - Jetons un oeil sur la documentation agile générée pour la classe - CompteBancaire (à partir de - ): + BankAccount - phpunit --testdox CompteBancaireTest + phpunit --testdox BankAccountTest PHPUnit 6.1.0 by Sebastian Bergmann and contributors. -CompteBancaire - [x] Balance est initialement a zéro - [x] Balance ne peut pas devenir négative +BankAccount + [x] Balance is initially zero + [x] Balance cannot become negative Alternativement, la documentation agile peut être générée en HTML ou au @@ -63,11 +59,6 @@ CompteBancaire --testdox-html et --testdox-text. - - Note du traducteur: les majuscules accentuées ne sont pas correctement gérées, il ne faut donc - pas les utiliser. - - Documenter les hypothèses @@ -85,12 +76,12 @@ CompteBancaire
- Tests transverses à l'équipe + Tests inter-équipes Quand vous documentez des hypothèses avec des tests, vous êtes - propriétaire des tests. Le fournisseur du paquet - sur lequel vous - faîtes des hypothèses - ne connaît rien de vos tests. Si vous voulez + propriétaire des tests. Le fournisseur du paquet -- sur lequel vous + faîtes des hypothèses -- ne connaît rien de vos tests. Si vous voulez avoir une relation plus étroite avec le fournisseur du paquet, vous pouvez utiliser les tests pour communiquer et coordonner vos activités. @@ -109,11 +100,10 @@ CompteBancaire En utilisant des bouchons (voir le chapitre relatif aux "objets simulacres", précédemment dans ce livre), vous pouvez créer un découplage plus grand entre vous - et le fournisseur: le boulot du fournisseur est de faire que les tests fonctionnent - avec l'implémentation réelle du paquet. Votre boulot est de faire que les tests fonctionnent + et le fournisseur: le travail du fournisseur est de faire fonctionner les tests + avec l'implémentation réelle du paquet. Votre travail est de faire que les tests fonctionnent sur votre propre code. Jusqu'à ce que vous ayez l'implémentation réelle du paquet fourni, - vous utilisez des objets bouchons. Suivant cette approche, deux équipes peuvent - développer indépendamment. + vous utilisez des objets bouchons. Suivant cette approche, deux équipes peuvent développer indépendamment.
diff --git a/src/6.1/fr/risky-tests.xml b/src/6.1/fr/risky-tests.xml new file mode 100644 index 000000000..47c1387cc --- /dev/null +++ b/src/6.1/fr/risky-tests.xml @@ -0,0 +1,114 @@ + + + + Tests risqués + + + PHPUnit peut effectuer les vérifications supplémentaires documentées ci-dessous pendant qu'il exécute + les tests. + + +
+ Tests inutiles + + + PHPUnit peut être strict sur les tests qui ne testent rien. Cette vérification + peut être activée en utilisant l'option --report-useless-tests + de la ligne de commande ou en définissant + beStrictAboutTestsThatDoNotTestAnything="true" dans + le fichier de configuration XML de PHPUnit. + + + + Un test qui n'effectue pas d'assertion sera marqué comme risqué + lorsque cette vérification est activée. Les attentes sur les objets bouchonnés ou les annotations + telles que @expectedException comptent comme une assertion. + +
+ +
+ Code non-intentionnellement couvert + + + PHPUnit peut être strict sur le code couvert non-intentionnellement. Cette vérification + peut être activée en utilisant l'option --strict-coverage + de la ligne de commande ou en définissant + checkForUnintentionallyCoveredCode="true" dans + le fichier de configuration XML de PHPUnit. + + + + Un test qui est annoté avec @covers et execute du code qui + n'est pas listé avec les annotations @covers ou @uses + sera marqué comme risqué quand cette vérification est activée. + +
+ +
+ Sortie d'écran lors de l'exécution d'un test + + + PHPUnit peut être strict sur la sortie écran pendant les tests. Cette vérification + peut être activée en utilisant l'option --disallow-test-output + de la ligne de commande ou en définissant + beStrictAboutOutputDuringTests="true" dans + le fichier de configuration XML de PHPUnit. + + + + Un test qui émet une sortie écran, par exemple en appelant print dans + dans le code du test ou dans le code testé, sera marqué comme risqué quand + cette vérification est activée. + +
+ +
+ Délai d'execution des tests + + + Une limite de temps peut être appliquée pour l'exécution d'un test si le + paquet PHP_Invoker est installé et que + l'extension pcntl est disponible. L'application de cette + limite de temps peut être activée en utilisant + l'option --enforce-time-limit sur la ligne de commande ou en + définissant beStrictAboutTestSize="true" dans le fichier de + configuration XML de PHPUnit. + + + + Un test annoté avec @large échouera s'il prend + plus de 60 secondes à s'executer. Ce délai d'execution est configurable via l'attribut + timeoutForLargeTests dans le fichier + de configuration XML. + + + + Un test annoté avec @medium échouera s'il prend + plus de 10 secondes à s'executer. Ce délai d'execution est configurable via l'attribut + timeoutForMediumTests dans le fichier + de configuration XML. + + + + Un test qui n'est pas annoté avec @medium ou + @large sera traité comme s'il était annoté avec + @small. Un test "small" échouera s'il prend + plus de 1 seconde à s'executer. Ce délai d'execution est configurable via + l'attribut timeoutForMediumTests dans le fichier de + configuration XML. + +
+ +
+ Manipulation d'états globaux + + + PHPUnit peut être strict sur les tests qui manipulent l'état global. Cette vérification + peut être activé en utilisant l'option --strict-global-state + de la ligne de commande ou en définissant + beStrictAboutChangesToGlobalState="true" dans le fichier de + configuration XML de PHPUnit. + +
+ + diff --git a/src/6.1/fr/selenium.xml b/src/6.1/fr/selenium.xml deleted file mode 100644 index c8851fb03..000000000 --- a/src/6.1/fr/selenium.xml +++ /dev/null @@ -1,483 +0,0 @@ - - - - PHPUnit et Selenium - -
- Selenium Server - - - Selenium Server - - Selenium Server est un - outil de test qui vous permet d'écrire des tests automatisés de - l'interface utilisateur d'applications web dans n'importe quel langage - et menés sur n'importe quel site web HTTP en utilisant n'importe quel - navigateur courant. Il réalise des tâches automatisée dans le navigateur - en pilotant le processus du navigateur via le système d'exploitation. - Les tests Selenium s'exécutent directement dans un navigateur, exactement - comme des utilisateurs réels le feraient. Ces tests peuvent être utilisés - à la fois comme tests de validation - (en exécutant des tests au plus haut niveau sur le système intégré au lieu - de simplement tester chaque unité du système indépendamment) et des - tests de compatibilité pour les navigateurs (en testant l'application - web sur différents systèmes d'exploitation et différents navigateurs). - - - - Le seul scénario géré par PHPUnit_Selenium est celui du serveur Selenium 2.x. - Le serveur peut être accédé via l'API classique Selenium RC déjà présente dans la version 1.x ou avec l'API serveur - WebDriver (partiellement implémentée) à partir de PHPUnit_Selenium 1.2. - - - La raison derrière cette décision est que Selenium 2 est rétro compatible et que Selenium RC n'est désormais plus - maintenu. - - -
- -
- Installation - - - Premièrement, installer Selenium Server: - - - - Télécharger une archive du Serveur Selenium. - Dézipper l'archive et copier selenium-server-standalone-2.20.0.jar (contrôler le suffixe de version) dans /usr/local/bin, par exemple. - Lancer le serveur Selenium en exécutant java -jar /usr/local/bin/selenium-server-standalone-2.20.0.jar. - - - - Deuxièmement, installer le paquet PHPUnit_Selenium, nécessaire pour accéder nativement au serveur Selenium depuis PHPUnit: - pear install phpunit/PHPUnit_Selenium - - - - Maintenant, nous pouvons envoyer des commandes au serveur Selenium en utilisant son protocole client/serveur. - -
- -
- PHPUnit_Extensions_Selenium2TestCase - - - PHPUnit_Extensions_Selenium2TestCase - - Le cas de test PHPUnit_Extensions_Selenium2TestCase vous permet d'utiliser l'API WebDriver (partiellement implémentée). - - - - montre - comment tester le contenu de l'élément ]]> - du site web http://www.example.com/. - - - Exemple d'utilisation de PHPUnit_Extensions_Selenium2TestCase - setBrowser('firefox'); - $this->setBrowserUrl('http://www.example.com/'); - } - - public function testTitle() - { - $this->url('http://www.example.com/'); - $this->assertEquals('Example WWW Page', $this->title()); - } - -} -?>]]> - phpunit WebTest - - - Les commandes de Selenium2TestCase sont implémentées via __call(). Merci de vous référer à the end-to-end test for PHPUnit_Extensions_Selenium2TestCase pour la liste de toutes les fonctionnalités prises en charge. - -
- -
- PHPUnit_Extensions_SeleniumTestCase - - - PHPUnit_Extensions_SeleniumTestCase - - L'extension de cas de test PHPUnit_Extensions_SeleniumTestCase - implémente le protocole client/serveur pour parler au serveur Selenium ainsi que - des méthodes de vérification spécialisées pour le test web. - - - - montre - comment tester le contenu de l'élément ]]> - du site web http://www.example.com/. - - - - Exemple d'utilisation de PHPUnit_Extensions_SeleniumTestCase - setBrowser('*firefox'); - $this->setBrowserUrl('http://www.example.com/'); - } - - public function testTitle() - { - $this->open('http://www.example.com/'); - $this->assertTitle('Example WWW Page'); - } -} -?>]]> - phpunit WebTest - - - - - Contrairement à la classe PHPUnit_Framework_TestCase, - les classes de cas de test qui héritent de PHPUnit_Extensions_SeleniumTestCase - doivent fournir une méthode setUp(). Cette méthode est utilisée - pour configurer la session du serveur Selenium. Voir - - pour la liste des méthodes qui sont disponibles pour cela. - - - - API de Selenium Server: configuration - - - - - Méthode - Signification - - - - - void setBrowser(string $navigateur) - Règle le navigateur que le serveur Selenium Server doit utiliser. - - - void setBrowserUrl(string $urlNavigateur) - Règle l'URL de base pour les tests. - - - void setHost(string $hote) - Règle le nom d'hôte pour la connexion au serveur Selenium Server. - - - void setPort(int $port) - Règle le port pour la connexion au serveur Selenium Server. - - - void setTimeout(int $delaiExpiration) - Règle le délai d'expiration pour la connexion au serveur Selenium Server server. - - - void setSleep(int $secondes) - Règle le nombre de secondes durant lesquelles le client Selenium Server client doit attendre entre l'envoi de commandes au serveur Selenium Server. - - - -
- - - PHPUnit peut facultativement faire une capture d'écran quand un test Selenium échoue. Pour - activer ceci, réglez $captureScreenshotOnFailure, - $screenshotPath et $screenshotUrl - dans votre classe de cas de test comme montré dans - . - - - - Faire une capture d'écran quand un test échoue - setBrowser('*firefox'); - $this->setBrowserUrl('http://www.example.com/'); - } - - public function testTitle() - { - $this->open('http://www.example.com/'); - $this->assertTitle('Example WWW Page'); - } -} -?>]]> - phpunit WebTest - - - - Vous pouvez exécuter chaque test en utilisant une série de navigateurs : au lieu - d'utiliser setBrowser() pour indiquer un seul navigateur, vous déclarez - un tableau public static nommé $browsers - dans votre classe de cas de test. Chaque élément de ce tableau décrit la configuration - d'un navigateur. Chacun de ces navigateurs peut être hébergé par différents serveurs - Selenium Server. - montre - un exemple. - - - - Régler la configuration de multiples navigateurs - 'Firefox sur Linux', - 'browser' => '*firefox', - 'host' => 'ma.box.linux', - 'port' => 4444, - 'timeout' => 30000, - ), - array( - 'name' => 'Safari sur MacOS X', - 'browser' => '*safari', - 'host' => 'ma.box.macosx', - 'port' => 4444, - 'timeout' => 30000, - ), - array( - 'name' => 'Safari sur Windows XP', - 'browser' => '*custom C:\Program Files\Safari\Safari.exe -url', - 'host' => 'ma.box.windowsxp', - 'port' => 4444, - 'timeout' => 30000, - ), - array( - 'name' => 'Internet Explorer sur Windows XP', - 'browser' => '*iexplore', - 'host' => 'ma.box.windowsxp', - 'port' => 4444, - 'timeout' => 30000, - ) - ); - - protected function setUp() - { - $this->setBrowserUrl('http://www.example.com/'); - } - - public function testTitle() - { - $this->open('http://www.example.com/'); - $this->assertTitle('Example Web Page'); - } -} -?>]]> - - - - PHPUnit_Extensions_SeleniumTestCase peut rassembler des informations - de couverture de code pour les tests lancés via Selenium: - - - - Copier PHPUnit/Extensions/SeleniumTestCase/phpunit_coverage.php dans le répertoire racine de votre serveur web. - Dans le fichier de configuration du serveur web php.ini, configurez PHPUnit/Extensions/SeleniumTestCase/prepend.php et PHPUnit/Extensions/SeleniumTestCase/append.php respectivement comme auto_prepend_file et auto_append_file. - Dans votre classe de cas de test qui hérite de PHPUnit_Extensions_SeleniumTestCase, utilisez protected $coverageScriptUrl = 'http://host/phpunit_coverage.php'; pour configurer l'URL pour le script phpunit_coverage.php. - - - - liste les diverses méthodes - de vérification que PHPUnit_Extensions_SeleniumTestCase - fournit. - - - - Assertions - - - - - Assertion - Signification - - - - - void assertElementValueEquals(string $localisateur, string $texte) - Rapporte une erreur si la valeur de l'élément identifié par $localisateur n'est pas égale au $texte donné. - - - void assertElementValueNotEquals(string $localisateur, string $texte) - Rapporte une erreur si la valeur de l'élément identifié par $localisateur est égale au $texte donné. - - - void assertElementValueContains(string $localisateur, string $texte) - Rapporte une erreur si la valeur de l'élément identifié par $localisateur ne contient pas le $texte donné. - - - void assertElementValueNotContains(string $localisateur, string $texte) - Rapporte une erreur si la valeur de l'élément identifié par $localisateur contient le $texte donné. - - - void assertElementContainsText(string $localisateur, string $texte) - Rapporte une erreur si l'élément identifié par $localisateur ne contient pas le $texte donné. - - - void assertElementNotContainsText(string $localisateur, string $texte) - Rapporte une erreur si l'élément identifié par $localisateur contient le $texte donné. - - - void assertSelectHasOption(string $localisateurDeSelect, string $option) - Rapporte une erreur si l'option de liste déroulante donnée n'est pas disponible. - - - void assertSelectNotHasOption(string $localisateurDeSelect, string $option) - Rapporte une erreur si l'option de liste déroulante donnée est disponible. - - - void assertSelected($localisateurDeSelect, $option) - Rapporte une erreur si l'étiquette de liste déroulante donnée n'est pas sélectionnée. - - - void assertNotSelected($localisateurDeSelect, $option) - Rapporte une erreur si l'étiquette de liste déroulante donnée est sélectionnée. - - - void assertIsSelected(string $localisateurDeSelect, string $valeur) - Rapporte une erreur si la valeur donnée n'est pas sélectionnée dans la liste déroulante. - - - void assertIsNotSelected(string $localisateurDeSelect, string $valeur) - Rapporte une erreur si la valeur donnée est sélectionnée dans la liste déroulante. - - - -
- - - montre - la méthode canevas de PHPUnit_Extensions_SeleniumTestCase: - - - - Méthodes canevas - - - - - Méthode - Signification - - - - - void defaultAssertions() - Surcharge pour exécuter des assertions qui sont partagées par tous les tests d'un cas de test. Cette méthode est appelée après chaque commande qui est envoyée au serveur Selenium Server. - - - -
- - - Merci de vous référer à la documentation des commandes Selenium - pour une référence des commandes disponibles et comment elles sont utilisées. - - - Les commandes de Selenium 1 sont implémentées dynamiquement via __call. Référez-vous également aux documents de l'API pour PHPUnit_Extensions_SeleniumTestCase_Driver::__call() pour une liste de toutes les méthodes gérées du côté PHP, avec les paramètres et le type de retourné quand ils sont disponibles. - - - - En utilisant la méthode runSelenese($filename), vous pouvez également - lancer un test Selenium à partir de ses spécifications Selenese/HTML. Plus encore, - en utilisant l'attribut statique $seleneseDirectory, vous pouvez - créer automatiquement des objets tests à partir d'un répertoire qui contient - des fichiers Selenese/HTML. Le répertoire indiqué est parcouru récursivement - à la recherche de fichiers .htm qui sont supposés contenir du Selenese/HTML. - montre un - exemple. - - - - Utiliser un répertoire de fichiers Selenese/HTML comme tests - ]]> - - - - A partir de Selenium 1.1.1, une fonctionnalité expérimentale est incluse permettant à un utilisateur de partager la session entre plusieurs tests. Le seul cas géré est le partage de session entre tous les tests quand un unique navigateur est utilisé. - Appelez PHPUnit_Extensions_SeleniumTestCase::shareSession(true) dans votre fichier amorce pour activer le partage de session. - La session sera réinitialisée dans le cas où un test échoue (en échec ou incomplet); c'est à la charge de l'utilisateur d'éviter les interactions entre des tests en réinitialisant des cookies ou en se déconnectant de l'application testée (avec une méthode tearDown()). - -
- diff --git a/src/6.1/fr/skeleton-generator.xml b/src/6.1/fr/skeleton-generator.xml deleted file mode 100644 index f1d4f9117..000000000 --- a/src/6.1/fr/skeleton-generator.xml +++ /dev/null @@ -1,320 +0,0 @@ - - - - Générateur de squelette - - - Le générateur de squelette de PHPUnit (Skeleton Generator) est un outil qui - peut générer des squelettes de classes de test à partir des classes de code - de production et vice versa. Il peut être installé en utilisant la commande - suivante : - - - pear install phpunit/PHPUnit_SkeletonGenerator - -
- Générer un squelettre de classe de cas de test - - - Générateur de squelette - - Quand vous écrivez des tests pour du code existant, vous avez à écrire - les mêmes fragments de code tels que public function testMethode() -{ -} encore et encore. Le générateur de squelette de PHPUnit peut vous aider - en analysant le code d'une classe existante et en générant pour elle un squelette de classe de cas - de test. - - - - La classe Calculateur - ]]> - - - - L'exemple suivant montre comment générer un squelette de classe de de test - pour une classe appelée Calculateur - (see ). - - - phpunit-skelgen --test Calculateur -PHPUnit Skeleton Generator 1.0.0 by Sebastian Bergmann. - -Wrote skeleton for "CalculateurTest" to "/home/sb/CalculateurTest.php". - - - Test incomplet - - Pour chaque méthode de la classe originelle, il y a aura un cas de - test incomplet (voir ) dans - la classe de cas de test générée. - - - - Classes sous espace de nom et le générateur de squelette - - - Lorsque vous utilisez le générateur de squelette pour générer du code basé sur - une classe qui est déclarée dans un espace de nommage (namespace) - vous devez fournir le nom qualifié de la classe ainsi que le chemin d'accès - au fichier source dans lequel elle est déclarée. - - - - Par exemple, pour une classe Calculateur qui est déclarée - dans l'espace de nommage projet, vous devez invoquer le - générateur de squelette comme ceci : - phpunit-skelgen --test -- "projet\Calculateur" Calculateur.php -PHPUnit Skeleton Generator 1.0.0 by Sebastian Bergmann. - -Wrote skeleton for "projet\CalculateurTest" to "/home/sb/CalculateurTest.php". - - - - - Ci-dessous se trouve la sortie écran produite par le lancement de la classe de cas de test générée. - - - phpunit --bootstrap Calculateur.php --verbose CalculateurTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -I - -Time: 0 seconds, Memory: 3.50Mb - -There was 1 incomplete test: - -1) CalculateurTest::testAdditionner -This test has not been implemented yet. - -/home/sb/CalculateurTest.php:38 -OK, but incomplete or skipped tests! -Tests: 1, Assertions: 0, Incomplete: 1. - - - Annotation - @assert - - Vous pouvez utiliser l'annotation @assert dans le bloc - de documentation d'une méthode pour générer automatiquement des tests - simples mais significatifs au lieu de cas de tests incomplets. - - montre un exemple. - - - - La classe Calculateur avec des annotations @assert - ]]> - - - - Chaque méthode de la classe originelle est contrôlée à la recherche d'annotations - @assert. Celles-ci sont transformées en code de test comme - /** - * Generated from @assert (0, 0) == 0. - */ - public function testAdditionner() { - $o = new Calculateur; - $this->assertEquals(0, $o->additionner(0, 0)); - } - - - - Ci-dessous se trouve la sortie écran produite par le lancement de la classe de cas de test générée. - - - phpunit --bootstrap Calculateur.php --verbose CalculateurTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -.... - -Time: 0 seconds, Memory: 3.50Mb - -OK (4 tests, 4 assertions) - - - - montre les variantes gérées par l'annotation @assert - et de quelle façon elles sont transformées en code de test. - - - - Variantes gérées par l'annotation @assert - - - - - Annotation - Transformée en - - - - - @assert (...) == X - assertEquals(X, methode(...)) - - - @assert (...) != X - assertNotEquals(X, methode(...)) - - - @assert (...) === X - assertSame(X, methode(...)) - - - @assert (...) !== X - assertNotSame(X, methode(...)) - - - @assert (...) > X - assertGreaterThan(X, methode(...)) - - - @assert (...) >= X - assertGreaterThanOrEqual(X, methode(...)) - - - @assert (...) < X - assertLessThan(X, methode(...)) - - - @assert (...) <= X - assertLessThanOrEqual(X, methode(...)) - - - @assert (...) throws X - @expectedException X - - - -
-
- -
- Générer un squelette de classe à partir d'une classe de cas de test - - - Lorsque vous pratiquez le développement dirigé par les tests (voir ) - et que vous écrivez vos tests avant le code que les tests vérifient, PHPUnit peut - vous aider à générer des squelettes de classe à partir des classes de cas de test. - - - - Suivant la convention selon laquelle les tests pour une classe Unit - sont écrit dans une classe nommée UnitTest, le source de la classe - de cas de test est inspecté à la recherche de variables qui référencent des objets - de la classe Unit puis est analysé pour savoir quelles méthodes - sont appelées sur ces objets. Par exemple, jetez un oeil à qui a été généré en se - basant sur l'analyse de . - - - - La classe JeuDeBowlingTest - jeu = new JeuDeBowling; - } - - protected function lancePlusieursEtRenverse($n, $quilles) - { - for ($i = 0; $i < $n; $i++) { - $this->jeu->renverse($quilles); - } - } - - public function testScorePourJeuDansLaRigoleEst0() - { - $this->lancePlusieursEtRenverse(20, 0); - $this->assertEquals(0, $this->jeu->score()); - } -} -?>]]> - - - phpunit-skelgen --class JeuDeBowlingTest -PHPUnit Skeleton Generator 1.0.0 by Sebastian Bergmann. - -Wrote skeleton for "JeuDeBowling" to "./JeuDeBowling.php". - - - Le squelette généré de la classe JeuDeBowling - ]]> - - - - Ci-dessous se trouve la sortie écran produite par le lancement de la classe de cas de test générée. - - - phpunit --bootstrap JeuDeBowling.php JeuDeBowlingTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -E - -Time: 0 seconds, Memory: 3.50Mb - -There was 1 error: - -1) JeuDeBowlingTest::testScorePourJeuDansLaRigoleEst0 -RuntimeException: Not yet implemented. - -/home/sb/JeuDeBowling.php:13 -/home/sb/JeuDeBowlingTest.php:14 -/home/sb/JeuDeBowlingTest.php:20 - -FAILURES! -Tests: 1, Assertions: 0, Errors: 1. -
- diff --git a/src/6.1/fr/test-doubles.xml b/src/6.1/fr/test-doubles.xml index fe5a4354b..ce216e682 100644 --- a/src/6.1/fr/test-doubles.xml +++ b/src/6.1/fr/test-doubles.xml @@ -11,16 +11,14 @@
Gerard Meszaros - Système à tester - - Parfois il est juste parfaitement difficile de tester un système en cours de test - (SCT) parce qu'il dépend d'autres composants qui ne peuvent pas - être utilisés dans l'environnement de test. Ceci peut provenir du fait - qu'ils ne sont pas disponibles, qu'ils ne retournent pas les résultats - nécessaires pour les tests ou parce que les exécuter pourrait avoir - des effets de bord indésirables. Dans d'autres cas, notre stratégie de test - nécessite que nous ayons plus de contrôle ou de visibilité sur le comportement - interne du SCT. + Système en cours de test + + Parfois il est parfaitement difficile de juste tester un système en cours de test (System Under Test : SUT) + parce qu'il dépend d'autres composants qui ne peuvent pas être utilisés dans l'environnement de test. + Ceci peut provenir du fait qu'ils ne sont pas disponibles, qu'ils ne retournent pas les résultats + nécessaires pour les tests ou parce que les exécuter pourrait avoir des effets de bord indésirables. + Dans d'autres cas, notre stratégie de test nécessite que nous ayons plus de contrôle ou de visibilité + sur le comportement interne du SUT. @@ -36,29 +34,41 @@
- La méthode getMock($nomClasse) fournit par PHPUnit peut être - utilisée dans un test pour générer automatiquement un objet qui peut agir comme une - doublure de test pour une classe originelle indiquée. Cette doublure de test peut être - utilisée dans tous les contextes où la classe originelle est attendue. + Les méthodes createMock($type) et + getMockBuilder($type) fourni par PHPUnit peuvent être + utilisées dans un test pour générer automatiquement un objet qui peut agir comme une + doublure de test pour une classe originelle indiquée (interface ou non de classe). + Cette doublure de test peut être utilisée dans tous les contextes où la classe + originelle est attendue ou requise. + + + + La méthode createMock($type) retourne immédiatement une doublure de + test pour le type spécifié (interface ou classe). La création de cette doublure est + effectuée en suivant par défaut les bonne pratiques (les méthodes __construct() + et __clone() de la classe originale ne sont pas executées + et les arguments passés à une méthode de la doublure de tests ne sont pas clonés. Si ce + comportement par défaut ne correspondent pas à ce don vous avez besoin vous pouvez + alors utiliser la méthode getMockBuilder($type) pour personnaliser la + génération de doublure de test en utilisant un interface souple (fluent interface). - Par défaut, toutes les méthodes de la classe originelle sont remplacées - par une implémentation fictive qui se contente de retourner - NULL (sans appeler la méthode originelle). - En utilisant la méthode will($this->returnValue()) + Par défaut, toutes les méthodes de la classe originelle sont remplacées par une + implémentation fictive qui se contente de retourner null (sans + appeler la méthode originelle). En utilisant la méthode will($this->returnValue()) par exemple, vous pouvez configurer ces implémentations fictives pour retourner une valeur donnée quand elles sont appelées. - Limitations + Limitations: méthodes final, private et static Merci de noter que les méthodes final, private - et static ne peuvent pas être remplacées par un bouchon (stub) ou un simulacre (mock). Elles seront - ignorées par la fonction de doublure de test de PHPUnit et conserveront leur comportement - initial. + et static ne peuvent pas être remplacées par un bouchon (stub) ou un simulacre (mock). + Elles seront ignorées par la fonction de doublure de test de PHPUnit et conserveront + leur comportement initial. @@ -72,9 +82,8 @@ retourne (de façon facultative) des valeurs de retour configurées est appelée bouchonnage. Vous pouvez utiliser un bouchon pour "remplacer un composant réel dont dépend le système testé de telle façon que - le test possède un point de contrôle sur les entrées indirectes dans le SCT. Ceci - permet au test de forcer le SCT à utiliser des chemins qu'il n'aurait pas - emprunté autrement". + le test possède un point de contrôle sur les entrées indirectes dans le SUT. Ceci + permet au test de forcer le SUT à utiliser des chemins qu'il n'aurait pas emprunté autrement". @@ -82,12 +91,12 @@ montre comment la méthode de bouchonnage appelle et configure des valeurs de retour. Nous utilisons - d'abord la méthode getMock() qui est fournie par la classe - PHPUnit_Framework_TestCase pour configurer un objet bouchon - qui ressemble à un objet de UneClasse + d'abord la méthode createMock() qui est fournie par la classe + PHPUnit\Framework\TestCase pour configurer un objet bouchon + qui ressemble à un objet de SomeClass (). Ensuite nous utilisons l'interface souple - que PHPUnit fournit pour indiquer le comportement de ce bouchon. En essence, + que PHPUnit fournit pour indiquer le comportement de ce bouchon. En substance, cela signifie que vous n'avez pas besoin de créer plusieurs objets temporaires et les relier ensemble ensuite. Au lieu de cela, vous chaînez les appels de méthode comme montré dans l'exemple. Ceci amène à un code plus lisible et "souple". @@ -96,112 +105,110 @@ La classe que nous voulons bouchonner ]]> - getMock() - expects() + createMock() method() - will() - returnValue() + willReturn() Bouchonner un appel de méthode pour retourner une valeur fixée getMock('UneClasse'); + // Créer un bouchon pour la classe SomeClass. + $stub = $this->createMock(SomeClass::class); // Configurer le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') - ->will($this->returnValue('foo')); + $stub->method('doSomething') + ->willReturn('foo'); - // Appeler $bouchon->faireQuelquechose() va maintenant retourner + // Appeler $stub->doSomething() va maintenant retourner // 'foo'. - $this->assertEquals('foo', $bouchon->faireQuelquechose()); + $this->assertEquals('foo', $stub->doSomething()); } } ?>]]> - - "Derrière la scène", PHPUnit génère automatiquement une nouvelle classe qui - implémente le comportement souhaité quand la méthode getMock() - est utilisée. La classe doublure de test peut être configurée via des - paramètres optionnels de la méthode getMock(). - + + Limitation: Méthodes nommées "method" - - Par défaut, toutes les méthodes d'une classe données sont remplacées par une doublure de test qui retourne simplement NULL à moins qu'une valeur de retour ne soit configurée en utilisant will($this->returnValue()), par exemple. - Quand le deuxième paramètre (facultatif) est fourni, seules les méthodes dont les noms sont dans le tableau sont remplacées par une doublure de test configurable. Le comportement des autres méthodes n'est pas modifié. - Le troisième paramètre (facultatif) peut contenir un tableau de paramètre qui est passé dans le constructeur de la classe originelle (qui n'est pas remplacé par une implémentation fictive par défaut). - Le quatrième paramètre (facultatif) peut être utilisé pour indiquer un nom de classe pour la classe de doublure de test générée. - Le cinquième paramètre (facultatif) peut être utilisée pour désactiver l'appel du constructeur de la classe originelle. - Le sixième paramètre (facultatif) peut être utilisé pour désactiver l'appel au constructeur du clone de la classe originelle. - Le septième paramètre (facultatif) peut être utilisé pour désactiver __autoload() lors de la génération de la classe de doublure de test. - + + L'exemple ci dessus ne fonctionne que si la classe originale ne déclare + pas de méthode appelé "method". + + + + Si la classe originale déclare une methode appelée "method" alors vous devez utiliser expects($this->any())->method('doSomething')->willReturn('foo');]]>. + + - Alternativement, l'API Mock Builder peut être utilisé pour configurer la classe - de doublure de test générée. - - montre un exemple. Ici, il y a une liste de méthodes qui peuvent être utilisées - avec l'interface de Mock Builder: + "Dans les coulisses", PHPUnit génère automatiquement une nouvelle classe qui + implémente le comportement souhaité quand la méthode createMock() + est utilisée. - - setMethods(array $methodes) peut être appelée sur l'objet Mock Builder pour indiquer les méthodes qui doivent être remplacées par une doublure de test configurable. Le comportement des autres méthodes n'est pas modifié. - setConstructorArgs(array $parametres) peut être appelé pour fournir un paramètre tableau qui est passé au constructeur de la classe originelle (qui n'est pas remplacé par une implémentation fictive par défaut). - setMockClassName($nom) peut être utilisée pour indiquer un nom de classe pour la classe de doublure de test générée. - disableOriginalConstructor() peut être utilisé pour désactiver l'appel au constructeur de la classe originelle. - disableOriginalClone() peut être utilisé pour désactiver l'appel au constructeur clone de la classe originelle. - disableAutoload() peut être utilisée pour désactiver __autoload() lors de la génération de la classe de doublure de test. - + + montre un exemple + de comment utiliser l'interface souple du créateur de mock pour configurer + la création d'une doublure de test. La configuration de cette doublure de test + utilise les même bonnes pratiques utilisées par défaut par createMock(). + - getMockBuilder() - expects() + createMock() method() - will() - returnValue() - Utiliser l'API Mock Builder pour configurer la classe de doublure de test générée. + willReturn() + L'API de construction des mocks peut-être utilisée pour configurer la doublure de test générée. getMockBuilder('UneClasse') + // Créer un bouchon pour la classe SomeClass. + $stub = $this->getMockBuilder($originalClassName) ->disableOriginalConstructor() + ->disableOriginalClone() + ->disableArgumentCloning() + ->disallowMockingUnknownTypes() ->getMock(); - // Configure le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') - ->will($this->returnValue('foo')); + // Configurer le bouchon. + $stub->method('doSomething') + ->willReturn('foo'); - // Appeler $bouchon->faireQuelquechose() retournera maintenant + // Appeler $stub->doSomething() retournera désormais // 'foo'. - $this->assertEquals('foo', $bouchon->faireQuelquechose()); + $this->assertEquals('foo', $stub->doSomething()); } } ?>]]> + + Dans les exemples précédents, nous avons retourné des valeurs simple en utilisant + willReturn($value). Cette syntaxe courte est identique à + will($this->returnValue($value)). Nous pouvons utiliser des variantes + de cette syntaxte plus longue pour obtenir un comportement de bouchonnement plus complexe. + + Parfois vous voulez renvoyer l'un des paramètres d'un appel de méthode (non modifié) comme résultat d'un appel méthode bouchon. @@ -211,69 +218,64 @@ class BouchonTest extends PHPUnit_Framework_TestCase - getMock() - expects() + createMock() method() will() returnArgument() Bouchonner un appel de méthode pour renvoyer un des paramètres getMock('UneClasse'); + // Créer un bouchon pour la classe SomeClass. + $stub = $this->createMock(SomeClass::class); // Configurer le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') + $stub->method('doSomething') ->will($this->returnArgument(0)); - // $bouchon->faireQuelquechose('foo') retourne 'foo' - $this->assertEquals('foo', $bouchon->faireQuelquechose('foo')); + // $stub->doSomething('foo') retourn 'foo' + $this->assertEquals('foo', $stub->doSomething('foo')); - // $bouchon->faireQuelquechose('bar') retourne 'bar' - $this->assertEquals('bar', $bouchon->faireQuelquechose('bar')); + // $stub->doSomething('bar') returns 'bar' + $this->assertEquals('bar', $stub->doSomething('bar')); } } ?>]]> - Quand on teste interface souple, il est parfois utile que la méthode bouchon retourne une référence à l'objet bouchon. - illustre comment vous - pouvez utiliser returnSelf() pour accomplir cela. + présente comment + utiliser returnSelf() pour accomplir cela. - getMock() - expects() + createMock() method() will() returnSelf() Bouchonner un appel de méthode pour renvoyer une référence de l'objet bouchon. getMock('UneClasse'); + // Créer un bouchon pour la classe SomeClass. + $stub = $this->createMock(SomeClass::class); // Configurer le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') + $stub->method('doSomething') ->will($this->returnSelf()); - // $bouchon->faireQuelquechose() retourne $bouchon - $this->assertSame($bouchon, $bouchon->faireQuelquechose()); + // $stub->doSomething() retourne $stub + $this->assertSame($stub, $stub->doSomething()); } } ?>]]> @@ -282,53 +284,49 @@ class BouchonTest extends PHPUnit_Framework_TestCase Parfois, une méthode bouchon doit retourner différentes valeurs selon une liste prédéfinie d'arguments. Vous pouvez utiliser - returnValueMap() pour créer un mappage qui associe des - paramètres aux valeurs de retour correspondantes. Voir + returnValueMap() pour créer une association entre les + paramètres et les valeurs de retour correspondantes. Voir pour un exemple. - getMock() - expects() + createMock() method() will() returnValueMap() - Bouchonner un appel de méthode pour retourner la valeur à partir d'un mappage + Bouchonner un appel de méthode pour retourner la valeur à partir d'une association getMock('UneClasse'); + // Créer un bouchon pour la classe SomeClass. + $stub = $this->createMock(SomeClass::class); - // Créer un mappage des arguments - // et des valeurs de retour. - $map = array( - array('a', 'b', 'c', 'd'), - array('e', 'f', 'g', 'h') - ); + // Créer une association entre arguments et valeurs de retour + $map = [ + ['a', 'b', 'c', 'd'], + ['e', 'f', 'g', 'h'] + ]; // Configurer le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') + $stub->method('doSomething') ->will($this->returnValueMap($map)); - // $bouchon->faireQuelquechose() retourne - // différentes valeurs selon les paramètres - // fournis. - $this->assertEquals('d', $bouchon->faireQuelquechose('a', 'b', 'c')); - $this->assertEquals('h', $bouchon->faireQuelquechose('e', 'f', 'g')); + // $stub->doSomething() retourne différentes valeurs selon + // les paramètres fournis. + $this->assertEquals('d', $stub->doSomething('a', 'b', 'c')); + $this->assertEquals('h', $stub->doSomething('e', 'f', 'g')); } } ?>]]> - Quand l'appel méthode bouchonné doit retourner une valeur calculée au lieu + Quand l'appel d'une méthode bouchonné doit retourner une valeur calculée au lieu d'une valeur fixée (voir returnValue()) ou un paramètre (non modifié) (voir returnArgument()), vous pouvez utiliser returnCallback() pour que la méthode retourne le résultat @@ -337,29 +335,27 @@ class BouchonTest extends PHPUnit_Framework_TestCase - getMock() - expects() + createMock() method() will() returnCallback() - Bouchonner un appel de méthode pour retourner une valeur à partir d'un rappel + Bouchonner un appel de méthode pour retourner une valeur à partir d'une fonction de rappel getMock('UneClasse'); + // Créer un bouchon pour la classe SomeClass. + $stub = $this->createMock(SomeClass::class); // Configurer le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') + $stub->method('doSomething') ->will($this->returnCallback('str_rot13')); - // $bouchon->faireQuelquechose($argument) retourne str_rot13($argument) - $this->assertEquals('fbzrguvat', $bouchon->faireQuelquechose('quelqueChose')); + // $stub->doSomething($argument) retourne str_rot13($argument) + $this->assertEquals('fbzrguvat', $stub->doSomething('something')); } } ?>]]> @@ -374,31 +370,30 @@ class BouchonTest extends PHPUnit_Framework_TestCase - getMock() - expects() + createMock() method() will() onConsecutiveCalls() - Bouchonner un appel de méthode pour retourner une liste de valeurs dans l'ordre indiqué + Bouchonner un appel de méthode pour retourner une liste de valeurs dans + l'ordre indiqué getMock('UneClasse'); + // Créer un bouchon pour la classe SomeClass. + $stub = $this->createMock(SomeClass::class); // Configurer le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') + $stub->method('doSomething') ->will($this->onConsecutiveCalls(2, 3, 5, 7)); - // $bouchon->faireQuelquechose() retourne une valeur différente à chaque fois - $this->assertEquals(2, $bouchon->faireQuelquechose()); - $this->assertEquals(3, $bouchon->faireQuelquechose()); - $this->assertEquals(5, $bouchon->faireQuelquechose()); + // $stub->doSomething() retourne une valeur différente à chaque fois + $this->assertEquals(2, $stub->doSomething()); + $this->assertEquals(3, $stub->doSomething()); + $this->assertEquals(5, $stub->doSomething()); } } ?>]]> @@ -412,40 +407,37 @@ class BouchonTest extends PHPUnit_Framework_TestCase - getMock() - expects() + createMock() method() will() throwException() Bouchonner un appel de méthode pour lever une exception getMock('UneClasse'); + // Créer un bouchon pour la classe SomeClass. + $stub = $this->createMock(SomeClass::class); // Configurer le bouchon. - $bouchon->expects($this->any()) - ->method('faireQuelquechose') + $stub->method('doSomething') ->will($this->throwException(new Exception)); - // $bouchon->faireQuelquechose() lance l'Exception - $bouchon->faireQuelquechose(); + // $stub->doSomething() throws Exception + $stub->doSomething(); } } ?>]]> - Alternativement, vous pouvez écrire le bouchon vous-même et améliorer - votre conception ce-faisant. Des ressources largement utilisées sont - accédées via une unique façade, de telle sorte que vous pouvez facilement - remplacer la ressource avec le bouchon. Par exemple, au lieu d'avoir - des appels directs à la base de données éparpillés dans tout le code, + Alternativement, vous pouvez écrire le bouchon vous-même et améliorer votre conception + en cours de route. Des ressources largement utilisées sont accédées via une unique façade, + de telle sorte que vous pouvez facilement remplacer la ressource avec le bouchon. Par exemple, + au lieu d'avoir des appels directs à la base de données éparpillés dans tout le code, vous avez un unique objet Database, une implémentation de l'interface IDatabase. Ensuite, vous pouvez créer une implémentation bouchon de IDatabase et l'utiliser pour @@ -464,137 +456,167 @@ class BouchonTest extends PHPUnit_Framework_TestCase
- Objets simulacres (Mock Objects) + Objets Mock La pratique consistant à remplacer un objet avec une doublure de test qui vérifie des attentes, par exemple en faisant l'assertion qu'une méthode - a été appelée, est appelée simulacre. + a été appelée, est appelée mock. - Objet simulacre - - Vous pouvez utiliser un objet simulacre "comme un point d'observation - qui est utilisé pour vérifier les sorties indirectes du système quand il est - testé. Typiquement, le simulacre inclut également la fonctionnalité - d'un bouchon de test, en ce sens qu'il doit retourner les valeurs du système - testé s'il n'a pas déjà fait échouer les tests mais l'accent est mis sur la - vérification des sorties indirectes. Ainsi, un simulacre est un beaucoup plus - qu'un simple bouchon avec des assertions; il est utilisé d'une manière - fondamentalement différente". + Objet mock + + Vous pouvez utiliser un objet mock "comme un point d'observation + qui est utilisé pour vérifier les sorties indirectes du système quand il est testé". + Typiquement, le mock inclut également la fonctionnalité d'un bouchon de test, + en ce sens qu'il doit retourner les valeurs du système testé s'il n'a pas déjà fait échouer + les tests mais l'accent est mis sur la vérification des sorties indirectes. + Ainsi, un mock est un beaucoup plus qu'un simple bouchon avec des assertions; + il est utilisé d'une manière fondamentalement différente" (Gerard Meszaros). + + Limitation: Vérification automatique des attentes + + + Seuls les objets mock générés dans le scope d'un test seront vérifiés + automatiquement par PHPUnit. Les mocks générés dans les fournisseurs de données, + par exemple, ou injectés dans les tests en utilisant l'annotation @depends + ne seront pas vérifiés automatiquement par PHPUnit. + + + Voici un exemple: supposons que vous voulez tester que la méthode correcte, update() dans notre exemple, est appelée d'un objet qui observe un autre objet. - illustre le code pour les classes Sujet et Observateur + illustre le code pour les classes Subject et Observer qui sont une partie du système testé (SUT). - Les classes Sujet et Observateur qui sont une partie du système testé + Les classes Subject et Observer qui sont une partie du système testé name = $name; + } + + public function getName() + { + return $this->name; + } - public function attache(Observateur $observateur) + public function attach(Observer $observer) { - $this->observateurs[] = $observateur; + $this->observers[] = $observer; } - public function faireQuelquechose() + public function doSomething() { // Faire quelque chose. // ... - // Avertir les observateurs que nous faisons quelque chose. - $this->notify('quelque chose'); + // Notify les observateurs que nous faisons quelque chose + $this->notify('something'); } - public function faireQuelquechoseMal() + public function doSomethingBad() { - foreach ($this->observateurs as $observateur) { - $observateur->reportError(42, 'Quelque chose de mal est arrivé', $this); + foreach ($this->observers as $observer) { + $observer->reportError(42, 'Something bad happened', $this); } } - protected function notify($paramètre) + protected function notify($argument) { - foreach ($this->observateurs as $observateur) { - $observateur->update($paramètre); + foreach ($this->observers as $observer) { + $observer->update($argument); } } // Autres méthodes. } -class Observateur +class Observer { - public function update($paramètre) + public function update($argument) { - // Faire quelque chose. + // Faire quelquechose } - public function reportError($codeErreur, $messageErreur, Sujet $sujet) + public function reportError($errorCode, $errorMessage, Subject $subject) { - // Faire quelque chose + // Faire quelquechose } - // Autres méthodes. + // Autre méthodes } ?>]]> - Objet simulacre + Objet mock illustre comment utiliser un simulacre pour tester l'interaction entre - les objets Sujet et Observateur. + les objets Subject et Observer. - Nous utilisons d'abord la méthode getMock() qui est fournie par - la classe PHPUnit_Framework_TestCase pour configurer un simulacre - pour l'Observateur. Puisque nous donnons un tableau comme second + Nous utilisons d'abord la méthode getMockBuilder() qui est fournie par + la classe PHPUnit\Framework\TestCase pour configurer un simulacre + pour Observer. Puisque nous donnons un tableau comme second paramètre (facultatif) pour la méthode getMock(), - seule la méthode update() de la classe Observateur est + seule la méthode update() de la classe Observer est remplacée par une implémentation d'un simulacre. + + Comme ce qui nous intéresse est de vérifier qu'une méthode soit appelée, + et avec quels arguments, nous introduisons les méthodes expects() + et with() pour spécifier comment cette interaction doit se présenter. + + Tester qu'une méthode est appelée une fois et avec un paramètre indiqué getMock('Observateur', array('update')); + $observer = $this->getMockBuilder(Observer::class) + ->setMethods(['update']) + ->getMock(); // Configurer l'attente de la méthode update() - // d'être appelée une seule fois et avec la chaîne 'quelquechose' + // d'être appelée une seule fois et avec la chaîne 'something' // comme paramètre. - $observateur->expects($this->once()) + $observer->expects($this->once()) ->method('update') - ->with($this->equalTo('quelque chose')); + ->with($this->equalTo('something')); - // Créer un objet Sujet et y attacher l'objet Observateur - // simulé - $sujet = new Sujet; - $sujet->attache($observateur); + // Créer un objet Subject et y attacher l'objet + // Observer simulé + $subject = new Subject('My subject'); + $subject->attach($observer); - // Appeler la méthode faireQuelquechose() sur l'objet $sujet + // Appeler la méthode doSomething() sur l'objet $subject // que nous attendons voir appeler la méthode update() de l'objet - // simulé Observateur avec la chaîne 'quelqueChose'. - $sujet->faireQuelquechose(); + // simulé Observer avec la chaîne 'something'. + $subject->doSomething(); } } ?>]]> @@ -603,44 +625,175 @@ class SujetTest extends PHPUnit_Framework_TestCase La méthode with() peut prendre n'importe quel nombre de paramètres, correspondant au nombre de paramètres des méthodes - étant simulées. Vous pouvez indiquer des contraintes plus avancées - sur les paramètres de méthode qu'une simple correspondance. + simulées. Vous pouvez indiquer des contraintes plus avancées qu'une simple + correspondance, sur les paramètres de méthode. - Tester qu'une méthode est appelée avec un nombre de paramètres contraints de différentes manières + Tester qu'une méthode est appelée avec un nombre de paramètres + contraints de différentes manières getMock('Observateur', array('rapportErreur')); + // Créer un mock pour la classe Observer, en simulant + // la méthode reportError() + $observer = $this->getMockBuilder(Observer::class) + ->setMethods(['reportError']) + ->getMock(); + + $observer->expects($this->once()) + ->method('reportError') + ->with( + $this->greaterThan(0), + $this->stringContains('Something'), + $this->anything() + ); - $observateur->expects($this->once()) - ->method('rapportErreur') + $subject = new Subject('My subject'); + $subject->attach($observer); + + // La méthode doSomethingBad() doit rapporter une erreur à l'observateur + // via la méthode reportError() + $subject->doSomethingBad(); + } +} +?>]]> + + + + La méthode withConsecutive() peut prendre n'importe quel + nombre de tableau de paramètres, selon les appels que vous souhaitez tester. + Chaque tableau est une liste de contraintes correspondant aux paramètres de la + méthode mockée, comme avec with(). + + + + Tester qu'une méthode est appelée deux fois avec des arguments spécifiques. + getMockBuilder(stdClass::class) + ->setMethods(['set']) + ->getMock(); + + $mock->expects($this->exactly(2)) + ->method('set') + ->withConsecutive( + [$this->equalTo('foo'), $this->greaterThan(0)], + [$this->equalTo('bar'), $this->greaterThan(0)] + ); + + $mock->set('foo', 21); + $mock->set('bar', 48); + } +} +?>]]> + + + + La contrainte callback() peut être utilisée pour une vérification + plus complexe d'un argument. Cette contrainte prend comme seul paramètre une fonction de + rappel PHP (callback). La fonctione de rappel PHP recevra l'argument à vérifier comme son seul + paramètre et devrait renvoyer true si l'argument + passe la vérification et false sinon. + + + + Vérification de paramètre plus complexe + getMockBuilder(Observer::class) + ->setMethods(['reportError']) + ->getMock(); + + $observer->expects($this->once()) + ->method('reportError') ->with($this->greaterThan(0), - $this->stringContains('Quelquechose'), - $this->anything()); + $this->stringContains('Something'), + $this->callback(function($subject){ + return is_callable([$subject, 'getName']) && + $subject->getName() == 'My subject'; + })); + + $subject = new Subject('My subject'); + $subject->attach($observer); + + // La méthode doSomethingBad() devrait rapporter une erreur a l'observeur + // via la methode reportError() + $subject->doSomethingBad(); + } +} +?>]]> + + + + Tester qu'une méthode est appelée une seule fois avec le même objet qui a été passé + getMockBuilder(stdClass::class) + ->setMethods(['foo']) + ->getMock(); + + $mock->expects($this->once()) + ->method('foo') + ->with($this->identicalTo($expectedObject)); + + $mock->foo($expectedObject); + } +} +?>]]> + - $sujet = new Subject; - $sujet->attach($observateur); + + Créer un OBJET mock avec les paramètres de clonnage activés + getMockBuilder(stdClass::class) + ->enableArgumentCloning() + ->getMock(); - // La méthode faireQuelquechoseDeMal doit rapporter une erreur à l'observateur - // via la méthode rapportErreur() - $sujet->faireQuelquechoseDeMal(); + // maintenant votre mock clone les paramètres, ainsi la contrainte identicalTo + // échouera. } } ?>]]> - + montre les contraintes qui peuvent être appliquées aux paramètres de méthode et - montre les matchers qui sont disponibles pour indiquer le nombre d' - invocations. + montre les matchers qui sont disponibles pour indiquer le nombre + d'invocations. @@ -671,8 +824,8 @@ class SubjectTest extends PHPUnit_Framework_TestCase Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est exécutée exactement une fois. - PHPUnit_Framework_MockObject_Matcher_InvokedCount exactly(int $nombre) - Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est exécutée exactement $nombre fois. + PHPUnit_Framework_MockObject_Matcher_InvokedCount exactly(int $count) + Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est exécutée exactement $count fois. PHPUnit_Framework_MockObject_Matcher_InvokedAtIndex at(int $index) @@ -682,42 +835,34 @@ class SubjectTest extends PHPUnit_Framework_TestCase
+ + + Le paramètre $index du matcher at() + fait référence à l'index, démarrant à zero, dans toutes les invocations de + la méthode pour un objet mock. Faites preuve de prudence + lors de l'utilisation de ce matcher car cela peut conduire à des tests + fragiles qui seront trop étroitement liés aux détails d'implémentation spécifiques. + + + - getMockForAbstractClass() + getMockBuilder() - La méthode getMockForAbstractClass() retourne un simulacre - pour une classe abstraite. Toutes les méthodes abstraites d'une classe simulacre - donnée sont simulées. Ceci permet de tester les méthodes concrètes d'une classe - abstraite. + Comme mentionné au début, quand le comportement par défaut utilisé par la méthode + createMock() pour générer la doublure de test ne + correspond pas a vos besoins alors vous pouvez utiliser la méthode getMockBuilder($type) + pour personnaliser la génération de la doublure de test en utilisant une interface souple. + Voici une liste des méthodes fournies par le constructeur de mock: - - Tester les méthodes concrêtes d'une classe abstraite - methodeAbstraite(); - } - - public abstract function methodeAbstraite(); -} - -class ClasseAbstraiteTest extends PHPUnit_Framework_TestCase -{ - public function testConcreteMethod() - { - $stub = $this->getMockForAbstractClass('ClasseAbstraite'); - $stub->expects($this->any()) - ->method('methodeAbstraite') - ->will($this->returnValue(TRUE)); - - $this->assertTrue($stub->methodeConcrete()); - } -} -?>]]> - + + setMethods(array $methods) peut être appelé sur l'objet Mock Builder pour spécifier les méthodes qui doivent être remplacées par une une doublure de test configurable. Le comportement des autres méthodes n'est pas changé. Si vous appelez setMethods(null), alors aucune méthode ne sera remplacé. + setConstructorArgs(array $args) peut être appeler pour fournir un tableau de paramètres qui est passé au constructeur de la classe originale (qui n'est pas remplacé par une implémentation factice par défaut). + setMockClassName($name) peut être utilisé pour spécifier un nom de classe pour la classe de la doublure de test générée. + disableOriginalConstructor() peut être utilisé pour désactiver l'appel au constructeur de la classe originale. + disableOriginalClone() peut être utilisé pour désactiver l'appel au constructeur de clonage de la classe originale. + disableAutoload() peut être utilisé pour désactiver __autoload() pendant la génération de la classe de la doublure de test. +
@@ -725,43 +870,46 @@ class ClasseAbstraiteTest extends PHPUnit_Framework_TestCase Prophecy est un - "framework de librairie de mock pour object PHP fortement arrêtée dans - ses options mais tout du moins très puissant et flexible. Créé en premier - lieu pour satisfaire les besoins de phpspec2, il est assez flexible pour - être utilisé dans n'importe quel framework de test, avec très peu - d'efforts". + "framework de simulation d'objets PHP fortement arrêtée dans ses options mais tout + du moins très puissant et flexible. Bien qu'il ait été initialement créé pour satisfaire les besoins de phpspec2, il est + suffisamment souple pour être utilisé dans n'importe quel framework de test avec un + minimum d'effort". - PHPUnit supporte nativement l'utilisation de Prophecy pour créer des - doublures depuis la version 4.5. - montre comment le même test peut écrit dans - en utilisant la philosophy des prophéties et des révélations: + PHPUnit dispose d'un support intégré pour utiliser Prophecy pour créer des doublures de test. + + montre comment le même test montré dans + peut être exprimé en utilisant la philosophie de Prophecy de prophéties et de + révélations: - Tester qu'une méthode est appelée une fois avec un argument spécifique + Tester qu'une méthode est appelée une fois et avec un paramètre indiqué prophesize('Observer'); + // Crée une prophecy pour la classe Observer. + $observer = $this->prophesize(Observer::class); - // Configurer le comportement attendu pour la méthode update() - // afin qu'elle soit appellée qu'une fois, avec la string 'something' - // comme paramètre. + // Configure l'attente pour que la méthode update() + // soit appelée une seule fois avec la chaine 'something' + // en paramètre. $observer->update('something')->shouldBeCalled(); - // Révéler la prophetie et attacher le mock à l'object Subject. + // Révèle la prophecie et attache l'objet mock + // à $subjet $subject->attach($observer->reveal()); - // Appeler la méthode doSomething() sur l'object $subject - // qui s'attend à appeler sur le mock d'objet Observer - // la méthod update() avec la string 'something'. + // Appelle la méthode doSomething() sur l'objet $subject + // dont on s'attend a ce qu'il appelle la méthode update()l'objet mocké Observer + // avec la chaine 'something'. $subject->doSomething(); } } @@ -769,13 +917,95 @@ class SubjectTest extends PHPUnit_Framework_TestCase - Référez-vous s'il vous plait à la documentation - pour Prophecy pour plus de détails concernant la création, la configuration, - et l'utilisation de stubs (doublures), spies (espions) et mocks (bouchons) - en utilisation cette alternative de framework de doublure de test. + Reportez-vous a la documentation + de Prophecy pour pour plus de détails sur la création, la configuration et l'utilisation de + stubs, espions, et mocks en utilisant ce framework alternatif de doublure de test.
+
+ Mocker les Traits et les classes abstraites + + + getMockForTrait() + + La méthode getMockForTrait() renvoie un objet mock + qui utilise un Trait spécifié. Toutes les méthodes abstraites du Trait donné + sont mockées. Cela permet de tester les méthodes concrètes d'un Trait. + + + + Tester les méthodes concrètes d'un trait + abstractMethod(); + } + + public abstract function abstractMethod(); +} + +class TraitClassTest extends TestCase +{ + public function testConcreteMethod() + { + $mock = $this->getMockForTrait(AbstractTrait::class); + + $mock->expects($this->any()) + ->method('abstractMethod') + ->will($this->returnValue(true)); + + $this->assertTrue($mock->concreteMethod()); + } +} +?>]]> + + + + getMockForAbstractClass() + + La méthode getMockForAbstractClass() retourne un mock + pour une classe abstraite. Toutes les méthodes abstraites d'une classe mock + donnée sont simulées. Ceci permet de tester les méthodes concrètes d'une classe + abstraite. + + + + Tester les méthodes concrêtes d'une classe abstraite + abstractMethod(); + } + + public abstract function abstractMethod(); +} + +class AbstractClassTest extends TestCase +{ + public function testConcreteMethod() + { + $stub = $this->getMockForAbstractClass(AbstractClass::class); + + $stub->expects($this->any()) + ->method('abstractMethod') + ->will($this->returnValue(true)); + + $this->assertTrue($stub->concreteMethod()); + } +} +?>]]> + +
+
Bouchon et simulacre pour Web Services @@ -784,10 +1014,9 @@ class SubjectTest extends PHPUnit_Framework_TestCase Quand votre application interagit avec un web service, vous voulez le tester sans vraiment interagir avec le web service. Pour rendre facile - la création de bouchon ou de simulacre de web services, - getMockFromWsdl() peut être utilisée de la même façon que - getMock() (voir plus haut). La seule différence est que - getMockFromWsdl() retourne un bouchon ou un simulacre + la création de bouchon ou de simulacre de web services, getMockFromWsdl() + peut être utilisée de la même façon que getMock() (voir plus haut). La seule + différence est que getMockFromWsdl() retourne un stub ou un basé basé sur la description en WSDL d'un web service tandis que getMock() retourne un bouchon ou un simulacre basé sur une classe ou une interface PHP. @@ -801,7 +1030,9 @@ class SubjectTest extends PHPUnit_Framework_TestCase Bouchonner un web service summary = ''; - $element->URL = 'http://www.phpunit.de/'; + $element->URL = 'https://phpunit.de/'; $element->snippet = '...'; $element->title = 'PHPUnit'; $element->cachedSize = '11k'; - $element->relatedInformationPresent = TRUE; - $element->hostName = 'www.phpunit.de'; + $element->relatedInformationPresent = true; + $element->hostName = 'phpunit.de'; $element->directoryCategory = $directoryCategory; $element->directoryTitle = ''; $result = new stdClass; - $result->documentFiltering = FALSE; + $result->documentFiltering = false; $result->searchComments = ''; $result->estimatedTotalResultsCount = 3.9000; - $result->estimateIsExact = FALSE; - $result->resultElements = array($element); + $result->estimateIsExact = false; + $result->resultElements = [$element]; $result->searchQuery = 'PHPUnit'; $result->startIndex = 1; $result->endIndex = 1; $result->searchTips = ''; - $result->directoryCategories = array(); + $result->directoryCategories = []; $result->searchTime = 0.248822; $googleSearch->expects($this->any()) @@ -842,8 +1073,8 @@ class GoogleTest extends PHPUnit_Framework_TestCase ->will($this->returnValue($result)); /** - * $googleSearch->doGoogleSearch() va maintenant retourner un result bouchon et - * la méthode doGoogleSearch() du web service ne sera pas invoquée. + * $googleSearch->doGoogleSearch() will now return a stubbed result and + * the web service's doGoogleSearch() method will not be invoked. */ $this->assertEquals( $result, @@ -852,9 +1083,9 @@ class GoogleTest extends PHPUnit_Framework_TestCase 'PHPUnit', 0, 1, - FALSE, + false, '', - FALSE, + false, '', '', '' @@ -878,19 +1109,20 @@ class GoogleTest extends PHPUnit_Framework_TestCase - Pour installer vfsStream, le canal PEAR - (pear.bovigo.org) qui est utilisé pour - sa distribution doit être enregistré dans l'environnement local PEAR: + Ajoutez simplement une dépendance a mikey179/vfsStream dans le + fichier composer.json de votre projet si vous utilisez + Composer pour gérer les + dépendances de votre project. Vous trouverez ci-dessous un exemple minimal de fichier + composer.json qui définie en dépendence de développement + PHPUnit 4.6 et vfsStream: - pear channel-discover pear.bovigo.org - - - Ceci ne doit être fait qu'une seule fois. Maintenant, l'installeur PEAR - peut être utilisé pour installer vfsStream. - - - pear install bovigo/vfsStream-beta + @@ -900,22 +1132,24 @@ class GoogleTest extends PHPUnit_Framework_TestCase Une classe qui interagit avec le système de fichiers id = $id; } - public function setRepertoire($repertoire) + public function setDirectory($directory) { - $this->repertoire = $repertoire . DIRECTORY_SEPARATOR . $this->id; + $this->directory = $directory . DIRECTORY_SEPARATOR . $this->id; - if (!file_exists($this->repertoire)) { - mkdir($this->repertoire, 0700, TRUE); + if (!file_exists($this->directory)) { + mkdir($this->directory, 0700, true); } } }?>]]> @@ -929,11 +1163,11 @@ class Exemple - Tester une classe qui interagoit avec le système de fichiers + Tester une classe qui interagit avec le système de fichiers assertFalse(file_exists(dirname(__FILE__) . '/id')); - $example->setRepertoire(dirname(__FILE__)); + $example->setDirectory(dirname(__FILE__)); $this->assertTrue(file_exists(dirname(__FILE__) . '/id')); } @@ -980,23 +1214,22 @@ class ExempleTest extends PHPUnit_Framework_TestCase Simuler le système de fichiers dans un test pour une classe qui interagit avec le système de fichiers assertFalse(vfsStreamWrapper::getRoot()->hasChild('id')); - $exemple->setRepertoire(vfsStream::url('exempleRepertoire')); + $example->setDirectory(vfsStream::url('exampleDir')); $this->assertTrue(vfsStreamWrapper::getRoot()->hasChild('id')); } } diff --git a/src/6.1/fr/testing-practices.xml b/src/6.1/fr/testing-practices.xml index 2782dc165..4601f39d9 100644 --- a/src/6.1/fr/testing-practices.xml +++ b/src/6.1/fr/testing-practices.xml @@ -6,14 +6,12 @@
Erich Gamma - Vous pouvez toujours écrire davantage de tests. Cependant, vous vous - rendrez rapidement compte que seule une fraction des tests auxquels vous - pensez est réellement utile. Ce que vous voulez, c'est écrire des tests - qui échouent même si vous pensez qu'ils devraient fonctionner, ou des - tests qui réussissent même si vous pensez qu'ils devraient échouer. - Une autre façon d'envisager cela consiste à le faire en terme de - coûts/bénéfices. Vous voulez écrire des tests qui vous paient en retour - avec des informations. + Vous pouvez toujours écrire davantage de tests. Cependant, vous vous rendrez rapidement compte que + seule une fraction des tests auxquels vous pensez est réellement utile. Ce + que vous voulez, c'est écrire des tests qui échouent même si vous pensez qu'ils devraient + fonctionner, ou des tests qui réussissent même si vous pensez qu'ils devraient échouer. + Une autre façon d'envisager cela consiste à le faire en terme de coûts/bénéfices. Vous voulez écrire + des tests qui vous paient en retour avec des informations.
@@ -24,10 +22,9 @@ Refactorisation Lorsque vous avez besoin de modifier la structure interne d'un logiciel sur - lequel vous êtes en train de travailler pour la rendre plus facile à comprendre - et moins chère à modifier sans modifier son comportement visible, une suite de tests - est inestimable pour appliquer de façon sure ces - refactorings + lequel vous êtes en train de travailler pour la rendre plus facile à comprendre et moins chère à modifier + sans modifier son comportement visible, une suite de tests est inestimable pour + appliquer de façon sûre ces refactorings comme on les appelle. Sans cela, vous ne pourrez pas vous détecter que vous avez cassé le système en réalisant la restructuration. @@ -60,8 +57,7 @@ Quand vous avez besoin d'ajouter de nouvelles fonctionnalités au système, écrivez d'abord les tests. Puis, vous aurez terminé quand les tests - s'exécuteront. Cette pratique sera discutée en détail dans le prochain - chapitre. + s'exécuteront. Cette pratique sera discutée en détail dans le prochain chapitre.
@@ -69,9 +65,9 @@ Pendant le débogage - Quand vous recevez un rapport de bug, vous pourriez être tenté de - le corriger aussi vite que possible. L'expérience prouve que cette - impulsion ne vous rendra pas service : il est probable que ce défaut en + Quand vous recevez un rapport de bug, vous pourriez être tenté de + le corriger aussi vite que possible. L'expérience prouve que cette + impulsion ne vous rendra pas service ; il est probable que ce défaut en provoque un autre. @@ -114,8 +110,7 @@ écrivez va améliorer les chances que lorsque vous corrigerez le défaut, vous le fassiez vraiment du fait que le nouveau test réduit la probabilité de défaire cette correction lors de futures modifications du code. Tous les tests - écrits avant réduisent la probabilité de causer par inadvertance un problème - différent. + écrits avant réduisent la probabilité de causer par inadvertance un problème différent.
diff --git a/src/6.1/fr/textui.xml b/src/6.1/fr/textui.xml index 55798762c..c00ecdb64 100644 --- a/src/6.1/fr/textui.xml +++ b/src/6.1/fr/textui.xml @@ -1,6 +1,5 @@ - Le lanceur de tests en ligne de commandes @@ -20,6 +19,13 @@ Time: 0 seconds OK (2 tests, 2 assertions) + + Lorsqu'il est appelé comme indiqué ci-dessus, le contrôleur de ligne de commande PHPUnit recherchera + un fichier source ArrayTest.php dans le répertoire de travail + courant, le chargera et s'attendra à trouver une classe de cas de test + ArrayTest. Il exécutera alors les tests de cette classe. + + Pour chaque test exécuté, l'outil en ligne de commandes de PHPUnit affiche un caractère pour indiquer l'avancement: @@ -53,6 +59,16 @@ OK (2 tests, 2 assertions) + + R + + + Affiché quand le test a été marqué comme risqué (voir + ). + + + + S @@ -104,75 +120,89 @@ Usage: phpunit [options] UnitTest [UnitTest.php] Code Coverage Options: - --coverage-clover Generate code coverage report in Clover XML format. - --coverage-crap4j Generate code coverage report in Crap4J XML format. - --coverage-html Generate code coverage report in HTML format. - --coverage-php Export PHP_CodeCoverage object to file. - --coverage-text= Generate code coverage report in text format. - Default: Standard output. - --coverage-xml Generate code coverage report in PHPUnit XML format. + --coverage-clover Generate code coverage report in Clover XML format. + --coverage-crap4j Generate code coverage report in Crap4J XML format. + --coverage-html Generate code coverage report in HTML format. + --coverage-php Export PHP_CodeCoverage object to file. + --coverage-text= Generate code coverage report in text format. + Default: Standard output. + --coverage-xml Generate code coverage report in PHPUnit XML format. + --whitelist Whitelist for code coverage analysis. + --disable-coverage-ignore Disable annotations for ignoring code coverage. Logging Options: - --log-junit Log test execution in JUnit XML format to file. - --log-tap Log test execution in TAP format to file. - --log-json Log test execution in JSON format. - --testdox-html Write agile documentation in HTML format to file. - --testdox-text Write agile documentation in Text format to file. + --log-junit Log test execution in JUnit XML format to file. + --log-teamcity Log test execution in TeamCity format to file. + --testdox-html Write agile documentation in HTML format to file. + --testdox-text Write agile documentation in Text format to file. + --testdox-xml Write agile documentation in XML format to file. + --reverse-list Print defects in reverse order Test Selection Options: - --filter Filter which tests to run. - --testsuite Filter which testsuite to run. - --group ... Only runs tests from the specified group(s). - --exclude-group ... Exclude tests from the specified group(s). - --list-groups List available test groups. - --test-suffix ... Only search for test in files with specified - suffix(es). Default: Test.php,.phpt + --filter Filter which tests to run. + --testsuite Filter which testsuite to run. + --group ... Only runs tests from the specified group(s). + --exclude-group ... Exclude tests from the specified group(s). + --list-groups List available test groups. + --list-suites List available test suites. + --test-suffix ... Only search for test in files with specified + suffix(es). Default: Test.php,.phpt Test Execution Options: - --report-useless-tests Be strict about tests that do not test anything. - --strict-coverage Be strict about unintentionally covered code. - --strict-global-state Be strict about changes to global state - --disallow-test-output Be strict about output during tests. - --enforce-time-limit Enforce time limit based on test size. - --disallow-todo-tests Disallow @todo-annotated tests. - - --process-isolation Run each test in a separate PHP process. - --no-globals-backup Do not backup and restore $GLOBALS for each test. - --static-backup Backup and restore static attributes for each test. - - --colors= Use colors in output ("never", "auto" or "always"). - --columns Number of columns to use for progress output. - --columns max Use maximum number of columns for progress output. - --stderr Write to STDERR instead of STDOUT. - --stop-on-error Stop execution upon first error. - --stop-on-failure Stop execution upon first error or failure. - --stop-on-risky Stop execution upon first risky test. - --stop-on-skipped Stop execution upon first skipped test. - --stop-on-incomplete Stop execution upon first incomplete test. - -v|--verbose Output more verbose information. - --debug Display debugging information during test execution. - - --loader TestSuiteLoader implementation to use. - --repeat Runs the test(s) repeatedly. - --tap Report test execution progress in TAP format. - --testdox Report test execution progress in TestDox format. - --printer TestListener implementation to use. + --dont-report-useless-tests Do not report tests that do not test anything. + --strict-coverage Be strict about @covers annotation usage. + --strict-global-state Be strict about changes to global state + --disallow-test-output Be strict about output during tests. + --disallow-resource-usage Be strict about resource usage during small tests. + --enforce-time-limit Enforce time limit based on test size. + --disallow-todo-tests Disallow @todo-annotated tests. + + --process-isolation Run each test in a separate PHP process. + --globals-backup Backup and restore $GLOBALS for each test. + --static-backup Backup and restore static attributes for each test. + + --colors= Use colors in output ("never", "auto" or "always"). + --columns Number of columns to use for progress output. + --columns max Use maximum number of columns for progress output. + --stderr Write to STDERR instead of STDOUT. + --stop-on-error Stop execution upon first error. + --stop-on-failure Stop execution upon first error or failure. + --stop-on-warning Stop execution upon first warning. + --stop-on-risky Stop execution upon first risky test. + --stop-on-skipped Stop execution upon first skipped test. + --stop-on-incomplete Stop execution upon first incomplete test. + --fail-on-warning Treat tests with warnings as failures. + --fail-on-risky Treat risky tests as failures. + -v|--verbose Output more verbose information. + --debug Display debugging information. + + --loader TestSuiteLoader implementation to use. + --repeat Runs the test(s) repeatedly. + --teamcity Report test execution progress in TeamCity format. + --testdox Report test execution progress in TestDox format. + --testdox-group Only include tests from the specified group(s). + --testdox-exclude-group Exclude tests from the specified group(s). + --printer TestListener implementation to use. Configuration Options: - --bootstrap A "bootstrap" PHP file that is run before the tests. - -c|--configuration Read configuration from XML file. - --no-configuration Ignore default configuration file (phpunit.xml). - --include-path Prepend PHP's include_path with given path(s). - -d key[=value] Sets a php.ini value. + --bootstrap A "bootstrap" PHP file that is run before the tests. + -c|--configuration Read configuration from XML file. + --no-configuration Ignore default configuration file (phpunit.xml). + --no-coverage Ignore code coverage configuration. + --no-extensions Do not load PHPUnit extensions. + --include-path Prepend PHP's include_path with given path(s). + -d key[=value] Sets a php.ini value. + --generate-configuration Generate configuration file with suggested settings. Miscellaneous Options: - -h|--help Prints this usage information. - --version Prints the version and exits.]]> + -h|--help Prints this usage information. + --version Prints the version and exits. + --atleast-version Checks that version is greater than min and exits.]]> @@ -186,7 +216,7 @@ Miscellaneous Options: UnitTest doit soit être une classe qui hérite - de PHPUnit_Framework_TestCase soit une classe qui + de PHPUnit\Framework\TestCase soit une classe qui fournit une méthode public static suite() retournant un objet PHPUnit_Framework_Test, par exemple une instance de la classe @@ -207,46 +237,26 @@ Miscellaneous Options: - Logfile - --log-junit - - - Génère un fichier de log au format JUnit XML pour les tests exécutés. - Voir pour plus de détails. - - - - - - Logfile - --log-tap + Couverture de code + --coverage-clover - Génère un fichier de log utilisant le format Test Anything Protocol (Protocol de test universel ou TAP) + Génère un fichier de log au format XML avec les informations de couverture de code pour les tests exécutés. Voir pour plus de détails. - - - - - JSON - --log-json - - Génère un fichier de log en utilisant le format - JSON. - Voir pour plus de détails. + Merci de noter que cette fonctionnalité n'est seulement disponible que + lorsque les extensions tokenizer et Xdebug sont installées. - Couverture de code - Rapport - --coverage-html + Code Coverage + --coverage-crap4j - Génère un rapport de couverture de code au format HTML. Voir + Génère un raport de couverture de code au format Crap4j. Voir pour plus de détails. @@ -258,11 +268,12 @@ Miscellaneous Options: Couverture de code - --coverage-clover + Rapport + --coverage-html - Génère un fichier de log au format XML avec les informations de couverture de code - pour les tests exécutés. Voir pour plus de détails. + Génère un rapport de couverture de code au format HTML. Voir + pour plus de détails. Merci de noter que cette fonctionnalité n'est seulement disponible que @@ -292,8 +303,7 @@ Miscellaneous Options: Génère un fichier de log ou une sortie écran sur la ligne de commandes - en format humainement lisible avec les informations de couverture de code - pour les tests exécutés. + dans un format lisible avec les informations de couverture de code pour les tests exécutés. Voir pour plus de détails. @@ -303,6 +313,17 @@ Miscellaneous Options: + + Logfile + --log-junit + + + Génère un fichier de log au format JUnit XML pour les tests exécutés. + Voir pour plus de détails. + + + + Documentation agile --testdox-html et --testdox-text @@ -319,10 +340,137 @@ Miscellaneous Options: --filter - Exécute seulement les tests dont le nom correspond au motif donné. Le motif - peut être soit le nom d'un test particulier, soit une - expression rationnelle - qui correspond à plusieurs noms de tests. + Exécute seulement les tests dont le nom correspond à l'expression régulière donnée. + Si le motif n'est pas entouré de délimiteurs, PHPUnit + inclura le motif dans les délimiteurs /. + + + + Les noms de test à faire correspondre seront dans l'un des formats suivant : + + + + + TestNamespace\TestCaseClass::testMethod + + + Le format de nom de test par défaut est l'équivalent de l'utilisation de + la constante magique __METHOD__ dans + la méthode de test. + + + + + + TestNamespace\TestCaseClass::testMethod with data set #0 + + + Lorsqu'un test a un fournisseur de données, chaque itération des + données a l'index courant ajouté à la fin + du nom de test par défaut. + + + + + + TestNamespace\TestCaseClass::testMethod with data set "my named data" + + + Lorsqu'un test a un fournisseur de données qui utilise des ensembles nommés, chaque + itération des données a le nom courant ajouté à la + du nom de test par défaut. Voir + pour un + exemple de fournisseurs de données avec des ensembles nommés. + + + + Ensembles de données nommés + assertTrue($data); + } + + public function provider() + { + return [ + 'my named data' => [true], + 'my data' => [true] + ]; + } +} +?>]]> + + + + + + /path/to/my/test.phpt + + + Le nom du test pour un test PHPT est le chemin du système de fichiers. + + + + + + + Voir pour des exemples + de motifs de filtre valide. + + + + Exemples de motif de filtre + + + --filter 'TestNamespace\\TestCaseClass::testMethod' + --filter 'TestNamespace\\TestCaseClass' + --filter TestNamespace + --filter TestCaseClass + --filter testMethod + --filter '/::testMethod .*"my named data"/' + --filter '/::testMethod .*#5$/' + --filter '/::testMethod .*#(5|6|7)$/' + + + + + Voir pour quelques + raccourcis supplémentaires disponibles pour faire correspondre + des fournisseurs de données. + + + + Raccourcis de filtre + + + --filter 'testMethod#2' + --filter 'testMethod#2-4' + --filter '#2' + --filter '#2-4' + --filter 'testMethod@my named data' + --filter 'testMethod@my.*data' + --filter '@my named data' + --filter '@my.*data' + + + + + + + --testsuite + + + Exécute uniquement la suite de test dont le nom correspond au modèle donné. @@ -336,12 +484,11 @@ Miscellaneous Options: Exécute seulement les tests appartenant à un/des groupe(s) indiqué(s). Un test - peut être signalé comme appartenant à un groupe en utilisant l'annotation - @group. + peut être signalé comme appartenant à un groupe en utilisant l'annotation @group. L'annotation @author est un alias pour - @group permettant de filtrer les tests en se basant + @group permettant de filtrer les tests en se basant sur leurs auteurs. @@ -373,64 +520,102 @@ Miscellaneous Options: - PHPUnit_Runner_TestSuiteLoader - --loader + --test-suffix - Indique l'implémentation de PHPUnit_Runner_TestSuiteLoader - à utiliser. + Recherche seulement les fichiers de test avec le(s) suffixe(s) spécifié(s). + + + + --report-useless-tests + - Le chargeur standard de suite de tests va chercher les fichiers source - dans le répertoire de travail actuel et dans chaque répertoire qui - est indiqué dans la directive de configuration PHP include_path. - Suivant les conventions de nommage PEAR, le nom d'une classe tel que - Projet_Paquetage_Classe est calqué sur le nom de fichier source - Projet/Paquetage/Classe.php. + Être strict sur les tests qui ne testent rien. Voir pour plus de détails. - PHPUnit_Framework_TestListener - PHPUnit_Util_Printer - --printer + --strict-coverage - Indique l'afficheur de résultats à utiliser. Cette classe d'afficheur doit - hériter de PHPUnit_Util_Printer et implémenter l'interface - PHPUnit_Framework_TestListener. + Être strict sur le code non-intentionnellemnt couvert. Voir pour plus de détails. - --repeat + --strict-global-state - Répéter l'exécution du(des) test(s) le nombre indiqué de fois. + Être strict sur la manipulation de l'état global. Voir pour plus de détails. - --tap + --disallow-test-output - Rapporte l'avancement des tests en utilisant le Test Anything Protocol (TAP). - Voir pour plus de détails. + Être strict sur les sorties écran pendant les tests. Voir pour plus de détails. - Documentation agile - --testdox + --disallow-todo-tests - Rapporte l'avancement des tests sous forme de documentation agile. Voir - pour plus de détails. + Ne pas executer les tests qui ont l'annotation @todo dans son docblock. + + + + + + --enforce-time-limit + + + Appliquer une limite de temps basée sur la taille du test. Voir pour plus de détails. + + + + + + Processus indépendants + Tests indépendants + --process-isolation + + + Exécute chaque test dans un processus PHP distinct. + + + + + + Isolation de test + --no-globals-backup + + + Ne pas sauvegarder et restaurer $GLOBALS. Voir + pour plus de détails. + + + + + + Tests indépendants + --static-backup + + + Sauvegarder et restaurer les attributs statiques des classes définies par l'utilisateur. + Voir pour plus de détails. @@ -439,7 +624,41 @@ Miscellaneous Options: --colors - Utilise des couleurs pour l'affichage. + Utiliser des couleurs pour la sortie écran. + Sur Windows, utiliser ANSICON ou ConEmu. + + + Il existe trois valeurs possible pour cette option: + + + + never : Ne jamais afficher de couleurs dans la sortie écran. Il s'agit de la valeur par défaut lorsque l'option --colors n'est pas utilisée. + + + + + auto : Afficher les couleurs dans la sortie à moins que le terminal actuel ne supporte pas les couleurs, + ou si la sortie est envoyée vers une commande ou redirigée vers un fichier. + + + + + always : Toujours affiche les couleurs dans la sortie écran, même lorsque le terminal en cours ne prend pas en charge les couleurs, + ou lorsque la sortie est envoyée vers une commande ou redirigée vers un fichier. + + + + Lorsque --colors est utilisée sans aucune valeur, auto est la valeur choisie. + + + + + + --columns + + + Définit le nombre de colonnes à utiliser pour la barre de progression. + Si la valeur définie est max, le nombre de colonnes sera le maximum du terminal courant. @@ -458,7 +677,7 @@ Miscellaneous Options: --stop-on-error - Arrête l'exécution à la première erreur. + Arrête l'execution à la première erreur. @@ -467,7 +686,16 @@ Miscellaneous Options: --stop-on-failure - Arrête l'exécution à la première erreur ou au premier échec. + Arrête l'execution à la première erreur ou au premier échec. + + + + + + --stop-on-risky + + + Arrête l'execution au premier test risqué. @@ -476,7 +704,7 @@ Miscellaneous Options: --stop-on-skipped - Arrête l'exécution au premier test sauté. + Arrête l'execution au premier test sauté. @@ -485,7 +713,7 @@ Miscellaneous Options: --stop-on-incomplete - Arrête l'exécution au premier test incomplet. + Arrête l'execution au premier test incomplet. @@ -501,34 +729,64 @@ Miscellaneous Options: - Processus indépendants - Tests indépendants - --process-isolation + --debug - Exécute chaque test dans un processus PHP distinct. + Affiche des informations de débogage telles que le nom d'un test quand + son exécution démarre. - Tests indépendants - --no-globals-backup + PHPUnit_Runner_TestSuiteLoader + --loader - Ne pas sauvegarder et restaurer $GLOBALS. Voir - pour plus de détails. + Indique l'implémentation de PHPUnit_Runner_TestSuiteLoader + à utiliser. + + + + Le chargeur standard de suite de tests va chercher les fichiers source + dans le répertoire de travail actuel et dans chaque répertoire qui + est indiqué dans la directive de configuration PHP include_path. + Le nom d'une classe tel que Projet_Paquetage_Classe est + calqué sur le nom de fichier source + Projet/Paquetage/Classe.php. - Tests indépendants - --static-backup + --repeat - Sauvegarde et restaure les attributs statiques des classes définies par l'utilisateur. - Voir pour plus de détails. + Répéter l'exécution du(des) test(s) le nombre indiqué de fois. + + + + + + Documentation agile + --testdox + + + Rapporte l'avancement des tests sous forme de documentation agile. Voir + pour plus de détails. + + + + + + PHPUnit_Framework_TestListener + PHPUnit_Util_Printer + --printer + + + Indique l'afficheur de résultats à utiliser. Cette classe d'afficheur doit + hériter de PHPUnit_Util_Printer et implémenter l'interface + PHPUnit_Framework_TestListener. @@ -566,8 +824,9 @@ Miscellaneous Options: --no-configuration - Ignorer phpunit.xml et - phpunit.xml.dist du répertoire de travail actuel. + Ignore phpunit.xml et + phpunit.xml.dist du répertoire de travail + actuel. @@ -590,16 +849,12 @@ Miscellaneous Options: - - - --debug - - - Affiche des informations de débogage telles que le nom d'un test quand - son exécution démarre. - - - + + + + Notez qu'à partir de 4.8, les options peuvent être placées après le(s) argument(s). + +
diff --git a/src/6.1/fr/writing-tests-for-phpunit.xml b/src/6.1/fr/writing-tests-for-phpunit.xml index 5e96c013e..c5f7a52bb 100755 --- a/src/6.1/fr/writing-tests-for-phpunit.xml +++ b/src/6.1/fr/writing-tests-for-phpunit.xml @@ -1,10 +1,10 @@ - Ecrire des tests pour PHPUnit + Écrire des tests pour PHPUnit - PHPUnit_Framework_TestCase + PHPUnit\Framework\TestCase montre comment nous pouvons écrire des tests en utilisant PHPUnit pour contrôler @@ -13,28 +13,30 @@ - Les tests pour une classe Classe vont dans une classe ClasseTest. - ClasseTest hérite (la plupart du temps) de PHPUnit_Framework_TestCase. - Annotation@testLes tests sont des méthodes publiques qui sont appelées test*.AnnotationAlternativement, vous pouvez utiliser l'annotation @test dans le bloc de documentation d'une méthode pour la marquer comme étant une méthode de test. - A l'intérieur des méthodes de test, des méthodes d'assertion telles que assertEquals() (voir ) sont utilisées pour affirmer qu'une valeur constatée correspond à une valeur attendue. + Les tests pour une classe Class vont dans une classe ClassTest. + ClassTest hérite (la plupart du temps) de PHPUnit\Framework\TestCase. + Les tests sont des méthodes publiques qui sont appelées test*.AnnotationAlternativement, vous pouvez utiliser l'annotation @test dans le bloc de documentation d'une méthode pour la marquer comme étant une méthode de test. + A l'intérieur des méthodes de test, des méthodes d'assertion telles que assertEquals() (voir ) sont utilisées pour affirmer qu'une valeur constatée correspond à une valeur attendue. Tester des opérations de tableau avec PHPUnit assertEquals(0, count($pile)); + $stack = []; + $this->assertEquals(0, count($stack)); - array_push($pile, 'foo'); - $this->assertEquals('foo', $pile[count($pile)-1]); - $this->assertEquals(1, count($pile)); + array_push($stack, 'foo'); + $this->assertEquals('foo', $stack[count($stack)-1]); + $this->assertEquals(1, count($stack)); - $this->assertEquals('foo', array_pop($pile)); - $this->assertEquals(0, count($pile)); + $this->assertEquals('foo', array_pop($stack)); + $this->assertEquals(0, count($stack)); } } ?>]]> @@ -44,8 +46,8 @@ class PileTest extends PHPUnit_Framework_TestCase Martin Fowler A chaque fois que vous avez la tentation de saisir quelque chose dans une - instruction print ou dans une expression de débogage, écrivez le - plutôt dans un test. + instruction print ou dans une expression de débogage, + écrivez le plutôt dans un test. @@ -55,29 +57,28 @@ class PileTest extends PHPUnit_Framework_TestCase
Adrian Kuhn et. al. - Les tests unitaires sont avant tout écrits comme étant une bonne pratique destinée - à aider les développeurs à identifier et corriger les bugs, à refactoriser le code et à - servir de documentation pour une unité du logiciel testé. Pour obtenir ces - avantages, les tests unitaires doivent idéalement couvrir tous les chemins possibles - du programme. Un test unitaire couvre usuellement un unique chemin particulier d'une - seule fonction ou méthode. Cependant, une méthode de test n'est pas obligatoirement - une entité encapsulée et indépendante. Souvent, il existe des dépendances implicites - entre les méthodes de test, cachées dans l'implémentation du scénario d'un test. + Les tests unitaires sont avant tout écrits comme étant une bonne pratique destinée à aider les développeurs + à identifier et corriger les bugs, à refactoriser le code et à servir de documentation + pour une unité du logiciel testé. Pour obtenir ces avantages, les tests unitaires + doivent idéalement couvrir tous les chemins possibles du programme. Un test unitaire + couvre usuellement un unique chemin particulier d'une seule fonction ou méthode. Cependant, une + méthode de test n'est pas obligatoirement une entité encapsulée et indépendante. Souvent, + il existe des dépendances implicites entre les méthodes de test, cachées + dans l'implémentation du scénario d'un test.
Dépendances des tests - PHPUnit gère la déclaration de dépendances explicites entre les méthodes - de test. De telles dépendances ne définissent pas l'ordre dans lequel les - méthodes de test doivent être exécutées, mais elles permettent l'envoi d'une - instance d'un composant de test par un producteur à des consommateurs qui - en dépendent. + PHPUnit gère la déclaration de dépendances explicites entre les + méthodes de test. De telles dépendances ne définissent pas l'ordre dans lequel les méthodes de test + doivent être exécutées mais elles permettent de renvoyer une instance de + la fixture de test par un producteur à des consommateurs qui en dépendent. - Un producteur est une méthode de test qui cède ses éléments testées comme valeur de sortie. + Un producteur est une méthode de test qui produit ses éléments testées comme valeur de retour. Un consommateur est une méthode de test qui dépend d'un ou plusieurs producteurs et de leurs valeurs de retour. @@ -93,74 +94,90 @@ class PileTest extends PHPUnit_Framework_TestCase Utiliser l'annotation <literal>@depends</literal> pour exprimer des dépendances assertEmpty($pile); + $stack = []; + $this->assertEmpty($stack); - return $pile; + return $stack; } /** - * @depends testVide + * @depends testEmpty */ - public function testPush(array $pile) + public function testPush(array $stack) { - array_push($pile, 'foo'); - $this->assertEquals('foo', $pile[count($pile)-1]); - $this->assertNotEmpty($pile); + array_push($stack, 'foo'); + $this->assertEquals('foo', $stack[count($stack)-1]); + $this->assertNotEmpty($stack); - return $pile; + return $stack; } /** * @depends testPush */ - public function testPop(array $pile) + public function testPop(array $stack) { - $this->assertEquals('foo', array_pop($pile)); - $this->assertEmpty($pile); + $this->assertEquals('foo', array_pop($stack)); + $this->assertEmpty($stack); } } ?>]]> - Dans l'exemple ci-dessus, le premier test, testVide(), + Dans l'exemple ci-dessus, le premier test, testEmpty(), crée un nouveau tableau et affirme qu'il est vide. Le test renvoie ensuite la fixture comme résultat. Le deuxième test, testPush(), - dépend de testVide() et reçoit le résultat de ce test + dépend de testEmpty() et reçoit le résultat de ce test dont il dépend comme argument. Enfin, testPop() dépend de testPush(). + + + Annotation + @depends + + La valeur de retour produite par un producteur est passée "telle quelle" à son + consommateur par défaut. Cela signifie que lorsqu'un producteur renvoie un objet, + une référence vers cet objet est passée a son consommateur. Lorsqu'une copie + doit être utilisée au lieu d'une référence, alors @depends clone + doit être utilisé au lieu de @depends. + + + Localisation des défauts Pour localiser rapidement les défauts, nous voulons que notre attention soit retenue par les tests en échecs pertinents. C'est pourquoi PHPUnit saute l'exécution d'un test quand un test dont il dépend a échoué. Ceci améliore la - localisation des défauts en exploitant les dépendances entre les tests comme - montré dans + localisation des défauts en exploitant les dépendances entre les tests comme montré dans . Exploiter les dépendances entre les tests assertTrue(FALSE); + $this->assertTrue(false); } /** - * @depends testUn + * @depends testOne */ - public function testDeux() + public function testTwo() { } } @@ -175,15 +192,15 @@ Time: 0 seconds, Memory: 5.00Mb There was 1 failure: -1) DependencyFailureTest::testUn +1) DependencyFailureTest::testOne Failed asserting that false is true. /home/sb/DependencyFailureTest.php:6 There was 1 skipped test: -1) DependencyFailureTest::testDeux -This test depends on "DependencyFailureTest::testUn" to pass. +1) DependencyFailureTest::testTwo +This test depends on "DependencyFailureTest::testOne" to pass. FAILURES! @@ -196,6 +213,56 @@ Tests: 1, Assertions: 1, Failures: 1, Skipped: 1.]]> devez donc vous assurer que les dépendances d'un test peuvent effectivement être utilisables avant que le test ne soit lancé. + + + Un test qui a plusieurs annotations @depends + prendra une fixture du premier producteur en premier argument, une fixture + du second producteur en second argument, et ainsi de suite. + Voir + + + + Test avec plusieurs dépendances + assertTrue(true); + return 'first'; + } + + public function testProducerSecond() + { + $this->assertTrue(true); + return 'second'; + } + + /** + * @depends testProducerFirst + * @depends testProducerSecond + */ + public function testConsumer() + { + $this->assertEquals( + ['first', 'second'], + func_get_args() + ); + } +} +?>]]> + + phpunit --verbose MultipleDependenciesTest +
@@ -205,40 +272,93 @@ Tests: 1, Assertions: 1, Failures: 1, Skipped: 1.]]> Annotation @dataProvider Une méthode de test peut recevoir des arguments arbitraires. Ces arguments doivent - être fournis par une méthode fournisseuse de données (fournisseur() dans + être fournis par une méthode fournisseuse de données (additionProvider() dans ). La méthode fournisseuse de données à utiliser est indiquée dans l'annotation - @dataProvider annotation. + @dataProvider. Une méthode fournisseuse de données doit être public et retourne, soit un tableau de tableaux, soit un objet qui implémente l'interface Iterator et renvoie un tableau pour chaque itération. Pour chaque tableau qui est une partie de - l'ensemble, la méthode de test sera appelée avec comme arguments le contenu du tableau. + l'ensemble, la méthode de test sera appelée avec comme arguments le contenu + du tableau. Utiliser un fournisseur de données qui renvoie un tableau de tableaux assertEquals($c, $a + $b); + $this->assertEquals($expected, $a + $b); } - public function fournisseur() + public function additionProvider() { - return array( - array(0, 0, 0), - array(0, 1, 1), - array(1, 0, 1), - array(1, 1, 3) - ); + return [ + [0, 0, 0], + [0, 1, 1], + [1, 0, 1], + [1, 1, 3] + ]; + } +} +?>]]> + + phpunit DataTest + + + + Lorsque vous utilisez un grand nombre de jeux de données, il est utile de nommer chacun avec une clé en chaine de caractère au lieu de la valeur numérique par défaut. + La sortie sera plus verbeuse car elle contiendra le nom du jeu de données qui casse un test. + + + + Utiliser un fournisseur de données avec des jeux de données nommés + assertEquals($expected, $a + $b); + } + + public function additionProvider() + { + return [ + 'adding zeros' => [0, 0, 0], + 'zero plus one' => [0, 1, 1], + 'one plus zero' => [1, 0, 1], + 'one plus one' => [1, 1, 3] + ]; } } ?>]]> @@ -252,7 +372,7 @@ Time: 0 seconds, Memory: 5.75Mb There was 1 failure: -1) DataTest::testAdditionne with data set #3 (1, 1, 3) +1) DataTest::testAdd with data set "one plus one" (1, 1, 3) Failed asserting that 2 matches expected 3. /home/sb/DataTest.php:9 @@ -264,19 +384,21 @@ Tests: 4, Assertions: 4, Failures: 1.]]> Utiliser un fournisseur de données qui renvoie un objet Iterator assertEquals($c, $a + $b); + $this->assertEquals($expected, $a + $b); } - public function fournisseur() + public function additionProvider() { return new CsvFileIterator('data.csv'); } @@ -292,7 +414,7 @@ Time: 0 seconds, Memory: 5.75Mb There was 1 failure: -1) DataTest::testAdditionne with data set #3 ('1', '1', '3') +1) DataTest::testAdd with data set #3 ('1', '1', '3') Failed asserting that 2 matches expected '3'. /home/sb/DataTest.php:11 @@ -304,27 +426,29 @@ Tests: 4, Assertions: 4, Failures: 1.]]> La classe CsvFileIterator fichier = fopen($fichier, 'r'); + public function __construct($file) { + $this->file = fopen($file, 'r'); } public function __destruct() { - fclose($this->fichier); + fclose($this->file); } public function rewind() { - rewind($this->fichier); - $this->current = fgetcsv($this->fichier); + rewind($this->file); + $this->current = fgetcsv($this->file); $this->key = 0; } public function valid() { - return !feof($this->fichier); + return !feof($this->file); } public function key() { @@ -336,24 +460,91 @@ class CsvFileIterator implements Iterator { } public function next() { - $this->current = fgetcsv($this->fichier); + $this->current = fgetcsv($this->file); $this->key++; } } ?>]]> - - - Annotation - @dataProvider - @depends + + Annotation + @dataProvider + @depends - Quand un test reçoit des entrées à la fois d'une méthode @dataProvider - et d'un ou plusieurs tests dont il @depends, les arguments provenant du - fournisseur de données arriveront avant ceux des tests dont il dépend. - - + Quand un test reçoit des entrées à la fois d'une méthode @dataProvider + et d'un ou plusieurs tests dont il @depends, + les arguments provenant du fournisseur de données arriveront avant + ceux des tests dont il dépend. Les arguments des tests dépendants seront les + mêmes pour chaque jeux de données + Voir + + + + Combinaison de @depends et @dataProvider dans le même test + assertTrue(true); + return 'first'; + } + + public function testProducerSecond() + { + $this->assertTrue(true); + return 'second'; + } + + /** + * @depends testProducerFirst + * @depends testProducerSecond + * @dataProvider provider + */ + public function testConsumer() + { + $this->assertEquals( + ['provider1', 'first', 'second'], + func_get_args() + ); + } +} +?>]]> + phpunit --verbose DependencyAndDataProviderComboTest 'provider1' ++ 0 => 'provider2' +1 => 'first' +2 => 'second' +) + +/home/sb/DependencyAndDataProviderComboTest.php:31 + +FAILURES! +Tests: 4, Assertions: 4, Failures: 1. +]]> + @@ -374,9 +565,11 @@ class CsvFileIterator implements Iterator { @dataProvider @depends - Tous les fournisseurs de données sont exécutés avant le premier appel - à la fonction setUp. De ce fait, vous ne pouvez accéder à - aucune variable créée à cet endroit depuis un fournisseur de données. + Tous les fournisseurs de données sont exécutés avant le premier appel à la méthode statique setUpBeforeClass + et le premier appel à la méthode setUp. + De ce fait, vous ne pouvez accéder à aucune variable créée à ces endroits + depuis un fournisseur de données. Ceci est requis pour que PHPUnit puisse + calculer le nombre total de tests.
@@ -385,24 +578,24 @@ class CsvFileIterator implements Iterator { Tester des exceptions - Annotation - @expectedException + Exception + expectException() - montre comment utiliser l'annotation @expectedException pour tester - si une exception est levée à l'intérieur du code testé. + montre comment utiliser la méthode expectException() pour tester + si une exception est levée par le code testé. - Utiliser l'annotation @expectedException + Utiliser la méthode expectException() expectException(InvalidArgumentException::class); } } ?>]]> @@ -418,186 +611,65 @@ There was 1 failure: 1) ExceptionTest::testException Expected exception InvalidArgumentException - FAILURES! Tests: 1, Assertions: 1, Failures: 1. + + expectExceptionCode() + expectExceptionMessage() + expectExceptionMessageRegExp() + + En complément à la méthode expectException() les méthodes + expectExceptionCode(), + expectExceptionMessage() et + expectExceptionMessageRegExp() existent pour établir + des attentes pour les exceptions levées par le code testé. + + Annotation @expectedException - @expectedExceptionMessage - @expectedExceptionCode - - Additionnellement, vous pouvez utiliser @expectedExceptionMessage - et @expectedExceptionCode en combinaison de - @expectedException pour tester le message d'exception et le code - d'exception comme montré dans - . + + Alternativement, vous pouvez utiliser les annotations @expectedException, + @expectedExceptionCode, + @expectedExceptionMessage et + @expectedExceptionMessageRegExp pour établir + des attentes pour les exceptions levées par le code testé. + + montre un exemple. - Utiliser les annotations @expectedExceptionMessage et @expectedExceptionCode + Utiliser l'annotation @expectedException ]]> - phpunit ExceptionTest - - - - Alternativement, vous pouvez utiliser la méthode setExpectedException() - pour indiquer l'exception attendue comme montré dans . - - - - Attendre une exception qui doit être levée par le code testé - setExpectedException('InvalidArgumentException'); - } - - public function testExceptionPossedeLeBonMessage() - { - $this->setExpectedException( - 'InvalidArgumentException', 'Message correct' - ); - throw new InvalidArgumentException('Un message', 10); - } - - public function testExceptionPossedeLeBonCode() - { - $this->setExpectedException( - 'InvalidArgumentException', 'Message correct', 20 - ); - throw new InvalidArgumentException('Message correct', 10); - } -}?>]]> - phpunit ExceptionTestphpunit ExceptionTest PHPUnit 6.1.0 by Sebastian Bergmann and contributors. -FFF +F -Time: 0 seconds, Memory: 3.00Mb +Time: 0 seconds, Memory: 4.75Mb -There were 3 failures: +There was 1 failure: 1) ExceptionTest::testException Expected exception InvalidArgumentException - -2) ExceptionTest::testExceptionPossedeLeBonMessage -Failed asserting that exception message 'Un message' contains 'Message correct'. - - -3) ExceptionTest::testExceptionPossedeLeBonCode -Failed asserting that expected exception code 20 is equal to 10. - - FAILURES! -Tests: 3, Assertions: 6, Failures: 3.]]> - - - - - montre les méthodes fournies pour tester des exceptions. - - - - Méthodes pour tester des exceptions - - - - - Méthode - Signification - - - - - void setExpectedException(string $nomDeLException[, string $messageDeLException = '', integer $codeDeLException = NULL]) - Indiquer le $nomDeLException attendue, le $messageDeLException et le $codeDeLException. - - - String getExpectedException() - Retourne le nom de l'exception attendue. - - - -
- - - Vous pouvez également utiliser l'approche montrée dans - - pour tester des exceptions. - - - - Approche alternative pour tester des exceptions - fail('Une exception attendue n'a pas été levée.'); - } -} -?>]]> +Tests: 1, Assertions: 1, Failures: 1. - - - Si le code qui devrait lever une exception dans - ne lève pas l'exception attendue, l'appel induit à - fail() va interrompre le test et signaler un problème pour ce test. - Si l'exception attendue est levée, le bloc catch - sera exécuté et le test s'achèvera avec succès. -
@@ -612,25 +684,35 @@ class ExceptionTest extends PHPUnit_Framework_TestCase { Par défaut, PHPUnit convertit les erreurs, avertissements et remarques PHP qui sont émises lors de l'exécution d'un test en exception. En utilisant ces exceptions, vous pouvez, par exemple, attendre d'un test qu'il produise une erreur - PHP comme montré dans - . + PHP comme montré dans . + + + La configuration d'exécution PHP error_reporting peut + limiter les erreurs que PHPUnit convertira en exceptions. Si vous rencontrez + des problèmes avec cette fonctionnalité, assurez-vous que PHP n'est pas configuré + pour supprimer le type d'erreurs que vous testez. + + + Attendre une erreur PHP en utilisant @expectedException ]]> - phpunit ExpectedErrorTest + phpunit -d error_reporting=2 ExpectedErrorTest PHPUnit 6.1.0 by Sebastian Bergmann and contributors. . @@ -669,18 +751,20 @@ OK (1 test, 1 assertion) Tester des valeurs de retour d'un code source qui utilise des erreurs PHP assertFalse(@$writer->ecrit('/non-accessible-en-ecriture/fichier', 'texte')); + $this->assertFalse(@$writer->write('/is-not-writeable/file', 'stuff')); } } class FileWriter { - public function ecrit($fichier, $contenu) { - $fichier = fopen($fichier, 'w'); - if($fichier == false) { + public function write($file, $content) { + $file = fopen($file, 'w'); + if($file == false) { return false; } // ... @@ -698,7 +782,7 @@ Time: 1 seconds, Memory: 5.25Mb OK (1 test, 1 assertion) Sans la suppression d'erreur, le test échouerait à rapporter - fopen(/non-accessible-en-ecriture/fichier): failed to open stream: + fopen(/is-not-writeable/file): failed to open stream: No such file or directory. @@ -708,12 +792,13 @@ OK (1 test, 1 assertion) Tester la sortie écran - Quelquefois, vous voulez affirmer que l'exécution d'une méthode, par + Quelquefois, vous voulez confirmer que l'exécution d'une méthode, par exemple, produit une sortie écran donnée (via echo ou print, par exemple). La classe - PHPUnit_Framework_TestCase utilise la fonctionnalité de - en tampon de PHP mise en tampon de la sortie écran - de PHP pour fournir la fonctionnalité qui est nécessaire pour cela. + PHPUnit\Framework\TestCase utilise la fonctionnalité de + mise en tampon de la sortie écran + de PHP pour fournir la fonctionnalité qui est + nécessaire pour cela. @@ -726,15 +811,17 @@ OK (1 test, 1 assertion) Tester la sortie écran d'une fonction ou d'une méthode expectOutputString('foo'); print 'foo'; } - public function testBarAttenduBazAttendu() + public function testExpectBarActualBaz() { $this->expectOutputString('bar'); print 'baz'; @@ -750,7 +837,7 @@ Time: 0 seconds, Memory: 5.75Mb There was 1 failure: -1) OutputTest::testBarAttenduBazObtenu +1) OutputTest::testExpectBarActualBaz Failed asserting that two strings are equal. --- Expected +++ Actual @@ -780,2234 +867,166 @@ Tests: 2, Assertions: 2, Failures: 1. - void expectOutputRegex(string $expressionRationnelle) - Indique que l'on s'attend à ce que la sortie écran corresponde à une $expressionRationnelle. + void expectOutputRegex(string $regularExpression) + Indique que l'on s'attend à ce que la sortie écran corresponde à une expression régulière $regularExpression. void expectOutputString(string $attenduString) - Indique que l'on s'attend que la sortie écran soit égale à une $chaineDeCaracteresAttendue. + Indique que l'on s'attend que la sortie écran soit égale à une chaine de caractère $expectedString. bool setOutputCallback(callable $callback) Configure une fonction de rappel (callback) qui est utilisée, par exemple, formater la sortie écran effective. + + string getActualOutput() + Renvoi la sortie écran courrante. + - Merci de noter que PHPUnit absorbe toutes les sorties écran qui sont - émises lors de l'exécution d'un test. En mode strict, un test qui - produit une sortie écran échouera. + En mode strict, un test qui produit une sortie écran échouera.
-
- Assertions +
+ Sortie d'erreur - Cette section liste les diverses méthodes d'assertion qui sont disponibles. + Chaque fois qu'un test échoue, PHPUnit essaie de vous fournir le plus + de contexte possible pour identifier le problème. -
- assertArrayHasKey() - assertArrayHasKey() - assertArrayNotHasKey() - assertArrayHasKey(mixed $clef, array $tableau[, string $message = '']) - Rapporte une erreur identifiée par un $message si le $tableau ne contient pas la $clef. - assertArrayNotHasKey() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertArrayHasKey() - + Sortie d'erreur générée lorsqu'un échec de comparaison de tableau + assertArrayHasKey('foo', array('bar' => 'baz')); + public function testEquality() { + $this->assertEquals( + [1, 2, 3, 4, 5, 6], + [1, 2, 33, 4, 5, 6] + ); } } ?>]]> - phpunit TableauPossedeUneClefTest + phpunit ArrayDiffTest 1 + 1 => 2 +- 2 => 3 ++ 2 => 33 + 3 => 4 + 4 => 5 + 5 => 6 + ) -/home/sb/TableauPossedeUneClefTest.php:6 +/home/sb/ArrayDiffTest.php:7 FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
+Tests: 1, Assertions: 1, Failures: 1.]]> + + + Dans cet exemple, une seule des valeurs du tableau diffère et les autres valeurs + sont affichées pour fournir un contexte sur l'endroit où l'erreur s'est produite. + -
- assertClassHasAttribute() - assertClassHasAttribute() - assertClassNotHasAttribute() - assertClassHasAttribute(string $nomAttribut, string $nomClasse[, string $message = '']) - Rapporte une erreur identifiée par un $message si $nomClasse::nomAttribut n'existe pas. - assertClassNotHasAttribute() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertClassHasAttribute() - + Lorsque la sortie générée serait longue à lire, PHPUnit la divisera + et fournira quelques lignes de contexte autour de chaque différence. + + + Sortie d'erreur quand une comparaison de long tableaux échoue + assertClassHasAttribute('foo', 'stdClass'); + public function testEquality() { + $this->assertEquals( + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 33, 4, 5, 6] + ); } } ?>]]> - phpunit ClassePossedeUnAttributTestphpunit LongArrayDiffTest - -
- -
- assertClassHasStaticAttribute() - assertClassHasStaticAttribute() - assertClassNotHasStaticAttribute() - assertClassHasStaticAttribute(string $nomAttribut, string $nomClasse[, string $message = '']) - Rapporte une erreur identifiée par un $message si $nomClasse::nomAttribut n'existe pas. - assertClassNotHasStaticAttribute() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertClassHasStaticAttribute() - assertClassHasStaticAttribute('foo', 'stdClass'); - } -} -?>]]> - phpunit ClassePossedeUnAttributStatiqueTest - -
- -
- assertContains() - assertContains() - assertNotContains() - assertAttributeContains() - assertAttributeNotContains() - assertContains(mixed $aiguille, Iterator|array $meuleDeFoin[, string $message = '']) - Rapporte une erreur identifiée par un $message si $aiguille n'est pas un élément de $meuleDeFoin. - assertNotContains() est l'inverse de cette assertion et prend les mêmes arguments. - assertAttributeContains() et assertAttributeNotContains() sont des enrobeurs de commodité qui utilisent l'attribut public, protected ou private d'une classe ou d'un objet comme meuleDeFoin. - - Utilisation de assertContains() - assertContains(4, array(1, 2, 3)); - } -} -?>]]> - phpunit ContainsTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) ContainsTest::testEchec -Failed asserting that an array contains 4. - -/home/sb/ContainsTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - - - assertContains(string $aiguille, string $meuleDeFoin[, string $message = '', boolean $ignorerLaCasse = FALSE]) - Rapporte une erreur identifiée par un $message si $aiguille n'est pas un sous chaîne de $meuleDeFoin. - Si $ignorerLaCasse est TRUE, le test sera insensible à la casse. - - Utilisation de assertContains() - assertContains('baz', 'foobar'); - } -} -?>]]> - phpunit ContainsTest - - - - Usage of assertContains() with $ignoreCase - assertContains('foo', 'FooBar'); - } - - public function testOK() - { - $this->assertContains('foo', 'FooBar', '', true); - } -} -?>]]> - phpunit ContainsTest - -
- -
- assertContainsOnly() - assertContainsOnly() - assertNotContainsOnly() - assertAttributeContainsOnly() - assertAttributeNotContainsOnly() - assertContainsOnly(string $type, Iterator|array $meuleDeFoin[, boolean $estUnTypeNatif = NULL, string $message = '']) - Rapporte une erreur identifiée par le $message si $meuleDeFoin ne contient pas que des variables du type $type. - $estUnTypeNatif est un drapeau qui indique si $type est un type natif de PHP ou pas. - assertNotContainsOnly() est l'inverse de cette assertion et prend les mêmes arguments. - assertAttributeContainsOnly() et assertAttributeNotContainsOnly() sont des enrobeurs de commodité qui utilisent un attribut public, protected ou private d'une classe ou d'un objet en tant que valeur constatée. - - Utilisation de assertContainsOnly() - assertContainsOnly('string', array('1', '2', 3)); - } -} -?>]]> - phpunit ContainsOnlyTest '1' - 1 => '2' - 2 => 3 -) contains only values of type "string". - -/home/sb/ContainsOnlyTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1.]]> - -
- -
- assertCount() - assertCount() - assertNotCount() - assertCount($nombreAttendu, $meuleDeFoin[, string $message = '']) - Rapporte une erreur identifiée par $message si le nombre d'éléments dans $meuleDeFoin n'est pas $nombreAttendu. - assertNotCount() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertCount() - assertCount(0, array('foo')); - } -} -?>]]> - phpunit CountTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 4.75Mb - -There was 1 failure: - -1) CountTest::testEchec -Failed asserting that actual size 1 matches expected size 0. - -/home/sb/CountTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertEmpty() - assertEmpty() - assertNotEmpty() - assertAttributeEmpty() - assertAttributeNotEmpty() - assertEmpty(mixed $constate[, string $message = '']) - Rapporte une erreur identifiée par $message si $constate n'est pas vide. - assertNotEmpty() est l'inverse de cette assertion et prend les mêmes arguments. - assertAttributeEmpty() et assertAttributeNotEmpty() sont des enrobeurs de commodité qui peuvent être appliqués à un attribut public, protected ou private d'une classe ou d'un objet. - - Utilisation de assertEmpty() - assertEmpty(array('foo')); - } -} -?>]]> - phpunit VideTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 4.75Mb - -There was 1 failure: - -1) VideTest::testEchec -Failed asserting that an array is empty. - -/home/sb/VideTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertEqualXMLStructure() - assertEqualXMLStructure() - assertEqualXMLStructure(DOMElement $elementAttendu, DOMElement $elementConstate[, boolean $verifieAttributs = FALSE, string $message = '']) - Rapporte une erreur identifiée par $message si la structure XML de l'élément DOMElement de $elementConstate n'est pas égale à la structure de l'élément DOMElement de $elementAttendu. - - Utilisation de assertEqualXMLStructure() - assertEqualXMLStructure($attendu, $constate); - } - - public function testEchecAvecDifferentsAttributsDeNoeud() - { - $attendu = new DOMDocument; - $attendu->loadXML(''); - - $constate = new DOMDocument; - $constate->loadXML(''); - - $this->assertEqualXMLStructure( - $attendu->firstChild, $constate->firstChild, TRUE - ); - } - - public function testEchecAvecDecompteDifferentdesNoeudsFils() - { - $attendu = new DOMDocument; - $attendu->loadXML(''); - - $constate = new DOMDocument; - $constate->loadXML(''); - - $this->assertEqualXMLStructure( - $attendu->firstChild, $constate->firstChild - ); - } - - public function testEchecAvecDesNoeudsFilsDifferents() - { - $attendu = new DOMDocument; - $attendu->loadXML(''); - - $constate = new DOMDocument; - $constate->loadXML(''); - - $this->assertEqualXMLStructure( - $attendu->firstChild, $constate->firstChild - ); - } -} -?>]]> - phpunit StructuresXMLSontEgalesTest - -
- -
- assertEquals() - assertEquals() - assertNotEquals() - assertAttributeEquals() - assertAttributeNotEquals() - assertEquals(mixed $attendu, mixed $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si les deux variables $attendu et $constate ne sont pas égales. - assertNotEquals() est l'inverse de cette assertion et prend les mêmes paramètres. - assertAttributeEquals() et assertAttributeNotEquals() sont des enrobeurs de commodité qui utilisent un attribut public, protected ou private d'une classe ou d'un objet comme valeur constatée. - - Utilisation de assertEquals() - assertEquals(1, 0); - } - - public function testEchec2() - { - $this->assertEquals('bar', 'baz'); - } - - public function testEchec3() - { - $this->assertEquals("foo\nbar\nbaz\n", "foo\nbah\nbaz\n"); - } -} -?>]]> - phpunit EqualsTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -FFF - -Time: 0 seconds, Memory: 5.25Mb - -There were 3 failures: - -1) EqualsTest::testEchec -Failed asserting that 0 matches expected 1. - -/home/sb/EqualsTest.php:6 - -2) EqualsTest::testEchec2 -Failed asserting that two strings are equal. ---- Expected -+++ Actual -@@ @@ --'bar' -+'baz' - -/home/sb/EqualsTest.php:11 - -3) EqualsTest::testEchec3 -Failed asserting that two strings are equal. ---- Expected -+++ Actual -@@ @@ - 'foo --bar -+bah - baz - ' - -/home/sb/EqualsTest.php:16 - -FAILURES! -Tests: 3, Assertions: 3, Failures: 3. - - - Des comparaisons plus spécifiques sont utilisées pour des types d'arguments $attendu et $constate plus spécifiques, voir ci-dessous. - - assertEquals(float $attendu, float $constate[, string $message = '', float $delta = 0]) - Rapporte une erreur identifiée par le $message si les deux nombres à virgule flottante $attendu et $constate ne sont pas à moins de $delta l'un de l'autre. - Merci de lire comparing floating-point numbers pour comprendre pourquoi $delta est indispensable. - - Utilisation de assertEquals() avec des nombres à virgule flottante - assertEquals(1.0, 1.1, '', 0.2); - } - - public function testEchec() - { - $this->assertEquals(1.0, 1.1); - } -} -?>]]> - phpunit EqualsTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -.F - -Time: 0 seconds, Memory: 5.75Mb - -There was 1 failure: - -1) EqualsTest::testEchec -Failed asserting that 1.1 matches expected 1.0. - -/home/sb/EqualsTest.php:11 - -FAILURES! -Tests: 2, Assertions: 2, Failures: 1. - - - assertEquals(DOMDocument $attendu, DOMDocument $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si la forme canonique non commentée des documents XML représentés par les deux objets DOMDocument objects $attendu et $constate ne sont pas égaux. - - Utilisation de assertEquals() avec des objets DOMDocument - loadXML(''); - - $constate = new DOMDocument; - $constate->loadXML(''); - - $this->assertEquals($attendu, $constate); - } -} -?>]]> - phpunit EqualsTest -- -- -- -+ -+ -+ - -/home/sb/EqualsTest.php:12 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1.]]> - - - assertEquals(object $attendu, object $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si les deux objets $attendu et $constate ne possède pas des valeurs d'attribut égales. - - Utilisation de assertEquals() avec des objets - foo = 'foo'; - $attendu->bar = 'bar'; - - $constate = new stdClass; - $constate->foo = 'bar'; - $constate->baz = 'bar'; - - $this->assertEquals($attendu, $constate); - } -} -?>]]> - phpunit EqualsTest 'foo' -- 'bar' => 'bar' -+ 'foo' => 'bar' -+ 'baz' => 'bar' - ) - -/home/sb/EqualsTest.php:14 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1.]]> - - - assertEquals(array $attendu, array $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si les deux tableaux $attendu et $constate ne sont pas égaux. - - - Utilisation de assertEquals() avec des tableaux - assertEquals(array('a', 'b', 'c'), array('a', 'c', 'd')); - } -} -?>]]> - phpunit EqualsTest 'a' -- 1 => 'b' -- 2 => 'c' -+ 1 => 'c' -+ 2 => 'd' - ) - -/home/sb/EqualsTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1.]]> - -
- -
- assertFalse() - assertFalse() - assertFalse(bool $condition[, string $message = '']) - Rapporte une erreur identifiée par le $message si la $condition est TRUE (VRAIE). - assertNotFalse() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertFalse() - assertFalse(TRUE); - } -} -?>]]> - phpunit FalseTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) FalseTest::testEchec -Failed asserting that true is false. - -/home/sb/FalseTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertFileEquals() - assertFileEquals() - assertFileNotEquals() - assertFileEquals(string $attendu, string $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si le fichier identifié par $attendu ne possède pas le même contenu que le fichier identifié par $constate. - assertFileNotEquals() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertFileEquals() - assertFileEquals('/home/sb/attendu', '/home/sb/constate'); - } -} -?>]]> - phpunit FileEqualsTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.25Mb - -There was 1 failure: - -1) FileEqualsTest::testEchec -Failed asserting that two strings are equal. ---- Expected -+++ Actual -@@ @@ --'contenu attendu -+'contenu constaté - ' - -/home/sb/FileEqualsTest.php:6 - -FAILURES! -Tests: 1, Assertions: 3, Failures: 1. - -
- -
- assertFileExists() - assertFileExists() - assertFileNotExists() - assertFileExists(string $nomfichier[, string $message = '']) - Rapporte une erreur identifiée par le $message si le fichier désigné par $nomfichier n'existe pas. - assertFileNotExists() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertFileExists() - assertFileExists('/chemin/vers/fichier'); - } -} -?>]]> - phpunit FileExistsTest - -
- -
- assertGreaterThan() - assertGreaterThan() - assertAttributeGreaterThan() - assertGreaterThan(mixed $attendu, mixed $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si la valeur de $constate n'est pas supérieure à la valeur de $attendu. - assertAttributeGreaterThan() est un enrobeur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet comme valeur constatée. - - Utilisation de assertGreaterThan() - assertGreaterThan(2, 1); - } -} -?>]]> - phpunit GreaterThanTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) GreaterThanTest::testEchec -Failed asserting that 1 is greater than 2. - -/home/sb/GreaterThanTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertGreaterThanOrEqual() - assertGreaterThanOrEqual() - assertAttributeGreaterThanOrEqual() - assertGreaterThanOrEqual(mixed $attendu, mixed $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si la valeur de $constate n'est pas supérieure ou égale à la valeur de $attendu. - assertAttributeGreaterThanOrEqual() est un enrobeur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet comme valeur constatée. - - Utilisation de assertGreaterThanOrEqual() - assertGreaterThanOrEqual(2, 1); - } -} -?>]]> - phpunit GreaterThanOrEqualTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.25Mb - -There was 1 failure: - -1) GreatThanOrEqualTest::testEchec -Failed asserting that 1 is equal to 2 or is greater than 2. - -/home/sb/GreaterThanOrEqualTest.php:6 - -FAILURES! -Tests: 1, Assertions: 2, Failures: 1. - -
- -
- assertInstanceOf() - assertInstanceOf() - assertNotInstanceOf() - assertAttributeInstanceOf() - assertAttributeNotInstanceOf() - assertInstanceOf($attendu, $constate[, $message = '']) - Rapporte une erreur identifiée par le $message si $constate n'est pas une instance de $attendu. - assertNotInstanceOf() est l'inverse de cette assertion et prend les mêmes arguments. - assertAttributeInstanceOf() et assertAttributeNotInstanceOf() sont des enrobeurs de commodité qui peuvent être appliqué à un attribut public, protected ou private d'une classe ou d'un objet. - - Utilisation de assertInstanceOf() - assertInstanceOf('RuntimeException', new Exception); - } -} -?>]]> - phpunit InstanceOfTest - -
- -
- assertInternalType() - assertInternalType() - assertNotInternalType() - assertAttributeInternalType() - assertAttributeNotInternalType() - assertInternalType($attendu, $constate[, $message = '']) - Rapporte une erreur identifiée par le $message si $constate n'est pas du type $attendu. - assertNotInternalType() est l'inverse de cette assertion et prend les mêmes arguments. - assertAttributeInternalType() et assertAttributeNotInternalType() sont des enrobeurs de commodité qui peuvent être appliqués à un attribut public, protected ou private d'une classe ou d'un objet. - - Utilisation de assertInternalType() - assertInternalType('string', 42); - } -} -?>]]> - phpunit InternalTypeTest - -
- -
- assertJsonFileEqualsJsonFile() - assertJsonFileEqualsJsonFile() - assertJsonFileNotEqualsJsonFile() - assertJsonFileEqualsJsonFile(mixed $fichierAttendu, mixed $fichierConstate[, string $message = '']) - - Rapporte une erreur identifiée par $message si la valeur de $fichierConstate correspond - à la valeur de $fichierAttendu. - - - Utilisation de assertJsonFileEqualsJsonFile() - assertJsonFileEqualsJsonFile( - 'chemin/vers/fixture/fichier', 'chemin/vers/constate/fichier'); - } -} -?>]]> - phpunit JsonFileEqualsJsonFile -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb -There was 1 failure: -1) JsonFileEqualsJsonFile::testFailure -Failed asserting that '{"Mascot":"Tux"}' matches JSON string "["Mascott", "Tux", "OS", "Linux"]". - -/lapistano/JsonFileEqualsJsonFile.php:5 - -FAILURES! -Tests: 1, Assertions: 3, Failures: 1. - -
- -
- assertJsonStringEqualsJsonFile() - assertJsonStringEqualsJsonFile() - assertJsonStringNotEqualsJsonFile() - assertJsonStringEqualsJsonFile(mixed $fichierAttendu, mixed $jsonConstate[, string $message = '']) - - Rapporte une erreur identifiée par $message si la valeur de $jsonConstate correspond à la valeur de - $fichierAttendu. - - - Utilisation de assertJsonStringEqualsJsonFile() - assertJsonStringEqualsJsonFile( - 'chemin/vers/fixture/fichier', json_encode(array("Mascot" => "ux")) - ); - } -} -?>]]> - phpunit JsonStringEqualsJsonFile -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) JsonStringEqualsJsonFile::testFailure -Failed asserting that '{"Mascot":"ux"}' matches JSON string "{"Mascott":"Tux"}". - -/lapistano/JsonStringEqualsJsonFile.php:5 - -FAILURES! -Tests: 1, Assertions: 3, Failures: 1. - -
- -
- assertJsonStringEqualsJsonString() - assertJsonStringEqualsJsonString() - assertJsonStringNotEqualsJsonString() - assertJsonStringEqualsJsonString(mixed $jsonAttendu, mixed $jsonConstate[, string $message = '']) - - Rapporte une erreur identifiée par $message si la valeur de $jsonConstate correspond à la valeur de - $jsonAttendu. - - - Utilisation de assertJsonStringEqualsJsonString() - assertJsonStringEqualsJsonString( - json_encode(array("Mascot" => "Tux")), json_encode(array("Mascott" => "ux")) - ); - } -} -?>]]> - phpunit JsonStringEqualsJsonString -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) JsonStringEqualsJsonString::testFailure -Failed asserting that two objects are equal. ---- Expected -+++ Actual -@@ @@ - stdClass Object ( - - 'Mascot' => 'Tux' - + 'Mascot' => 'ux' -) - -/lapistano/JsonStringEqualsJsonString.php:5 - -FAILURES! -Tests: 1, Assertions: 3, Failures: 1. - -
- -
- assertLessThan() - assertLessThan() - assertAttributeLessThan() - assertLessThan(mixed $attendu, mixed $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si la valeur de $constate n'est pas inférieure à la valeur de $attendu. - assertAttributeLessThan() est un enrobeur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet comme valeur constatée. - - Utilisation de assertLessThan() - assertLessThan(1, 2); - } -} -?>]]> - phpunit LessThanTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) LessThanTest::testEchec -Failed asserting that 2 is less than 1. - -/home/sb/LessThanTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertLessThanOrEqual() - assertLessThanOrEqual() - assertAttributeLessThanOrEqual() - assertLessThanOrEqual(mixed $attendu, mixed $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si la valeur de $constate n'est pas inférieure ou égale à la valeur de $attendu. - assertAttributeLessThanOrEqual() est un enrobeur de commodité qui utilise un attribut public, protected ou private d'une classe ou d'un objet comme valeur attendue. - - Utilisation de assertLessThanOrEqual() - assertLessThanOrEqual(1, 2); - } -} -?>]]> - phpunit LessThanOrEqualTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.25Mb - -There was 1 failure: - -1) LessThanOrEqualTest::testEchec -Failed asserting that 2 is equal to 1 or is less than 1. - -/home/sb/LessThanOrEqualTest.php:6 - -FAILURES! -Tests: 1, Assertions: 2, Failures: 1. - -
- -
- assertNull() - assertNull() - assertNotNull() - assertNull(mixed $variable[, string $message = '']) - Rapporte une erreur identifiée par le $message si $variable n'est pas NULL. - assertNotNull() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertNull() - assertNull('foo'); - } -} -?>]]> - phpunit NotNullTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) NullTest::testEchec -Failed asserting that 'foo' is null. - -/home/sb/NotNullTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertObjectHasAttribute() - assertObjectHasAttribute() - assertObjectNotHasAttribute() - assertObjectHasAttribute(string $nomAttribut, object $objet[, string $message = '']) - Rapporte une erreur identifiée par le $message si $objet->nomAttribut n'existe pas. - assertObjectNotHasAttribute() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertObjectHasAttribute() - assertObjectHasAttribute('foo', new stdClass); - } -} -?>]]> - phpunit ObjectHasAttributeTest - -
- -
- assertRegExp() - assertRegExp() - assertNotRegExp() - assertRegExp(string $motif, string $chaine[, string $message = '']) - Rapporte une erreur identifiée par le $message si $chaine ne correspond pas à l'expression rationnelle $motif. - assertNotRegExp() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertRegExp() - assertRegExp('/foo/', 'bar'); - } -} -?>]]> - phpunit RegExpTest - -
- -
- assertStringMatchesFormat() - assertStringMatchesFormat() - assertStringNotMatchesFormat() - assertStringMatchesFormat(string $format, string $chaine[, string $message = '']) - Rapporte une erreur identifiée par le $message si la chaîne $chaine ne correspond pas à la chaîne de $format. - assertStringNotMatchesFormat() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertStringMatchesFormat() - assertStringMatchesFormat('%i', 'foo'); - } -} -?>]]> - phpunit StringMatchesFormatTest - - La chaîne de format peut contenir les conteneurs suivants: - - %e: Représente un séparateur de répertoire, par exemple / sur Linux. - %s: Un ou plusieurs caractères quelconque (y compris des espaces) à l'exception du caractère fin de ligne. - %S: Zéro ou plusieurs caractères quelconque (y compris des espaces) à l'exception du caractère fin de ligne. - %a: Un ou plusieurs caractères quelconque (y compris des espaces) y compris les caractères fin de ligne. - %A: Zéro ou plusieurs caractères quelconque (y compris des espaces) y compris les caractères fin de ligne. - %w: Zéro ou plusieurs espaces. - %i: Une valeur entière signée, par exemple +3142, -3142. - %d: Une valeur entière non signée, par exemple 123456. - %x: Un ou plusieurs caractères hexadécimaux. C'est-à-dire des caractères dans la plage 0-9, a-f, A-F. - %f: Un nombre en virgule flottante, par exemple: 3.142, -3.142, 3.142E-10, 3.142e+10. - %c: Un unique caractère de n'importe quelle sorte. - -
- -
- assertStringMatchesFormatFile() - assertStringMatchesFormatFile() - assertStringNotMatchesFormatFile() - assertStringMatchesFormatFile(string $fichierFormat, string $chaine[, string $message = '']) - Rapporte une erreur identifiée par le $message si la chaîne $chaine ne correspond pas au contenu de $fichierFormat. - assertStringNotMatchesFormatFile() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertStringMatchesFormatFile() - assertStringMatchesFormatFile('/chemin/vers/attendu.txt', 'foo'); - } -} -?>]]> - phpunit StringMatchesFormatFileTest - -
- -
- assertSame() - assertSame() - assertNotSame() - assertAttributeSame() - assertAttributeNotSame() - assertSame(mixed $attendu, mixed $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si les deux variables $attendu et $constate n'ont pas le même type et la même valeur. - assertNotSame() est l'inverse de cette assertion et prend les mêmes arguments. - assertAttributeSame() et assertAttributeNotSame() sont des enrobeurs de commodité qui utilisent un attribut public, protected ou private d'une classe ou d'un objet comme valeur constatée. - - Utilisation de assertSame() - assertSame('2204', 2204); - } -} -?>]]> - phpunit SameTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) SameTest::testEchec -Failed asserting that 2204 is identical to '2204'. - -/home/sb/SameTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - - - assertSame(object $attendu, object $constate[, string $message = '']) - Rapporte une erreur identifiée par le $message si les deux variables $attendu et $constate ne référence pas le même objet. - - - Utilisation de assertSame() avec des objets - assertSame(new stdClass, new stdClass); - } -} -?>]]> - phpunit SameTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 4.75Mb - -There was 1 failure: - -1) SameTest::testEchec -Failed asserting that two variables reference the same object. - -/home/sb/SameTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertSelectCount() - assertSelectCount() - assertSelectCount(array $selecteur, integer $nombre, mixed $constate[, string $message = '', boolean $isHtml = TRUE]) - Rapporte une erreur identifiée par le $message si le sélecteur CSS $selecteur ne correspond pas à $nombre éléments du noeud DOM $constate. - $nombre peut avoir l'un des types suivants : - - booléen: présuppose la présence d'éléments correspondant au sélecteur (TRUE) ou l'absence d'éléments (FALSE). - nombre entier: présuppose le nombre d'éléments. - tableau: présuppose que le nombre sera dans la plage indiquée en utilisant <, >, <= et >= comme clefs. - - - Utilisation de assertSelectCount() - xml = new DomDocument; - $this->xml->loadXML(''); - } - - public function testAbsenceEchec() - { - $this->assertSelectCount('foo bar', FALSE, $this->xml); - } - - public function testPresenceEchec() - { - $this->assertSelectCount('foo baz', TRUE, $this->xml); - } - - public function testCompteExactEchec() - { - $this->assertSelectCount('foo bar', 5, $this->xml); - } - - public function testPlageEchec() - { - $this->assertSelectCount('foo bar', array('>'=>6, '<'=>8), $this->xml); - } -} -?>]]> - phpunit SelectCountTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -FFFF - -Time: 0 seconds, Memory: 5.50Mb - -There were 4 failures: - -1) SelectCountTest::testAbsenceEchec -Failed asserting that true is false. - -/home/sb/SelectCountTest.php:12 - -2) SelectCountTest::testPresenceEchec -Failed asserting that false is true. - -/home/sb/SelectCountTest.php:17 - -3) SelectCountTest::testCompteExactEchec -Failed asserting that 3 matches expected 5. - -/home/sb/SelectCountTest.php:22 - -4) SelectCountTest::testPlageEchec -Failed asserting that false is true. - -/home/sb/SelectCountTest.php:27 - -FAILURES! -Tests: 4, Assertions: 4, Failures: 4. - -
- -
- assertSelectEquals() - assertSelectEquals() - assertSelectEquals(array $selecteur, string $contenu, integer $nombre, mixed $constate[, string $message = '', boolean $isHtml = TRUE]) - Rapporte une erreur identifiée par le $message si le sélecteur CSS $selecteur ne correspond pas à $nombre éléments dans le noeud DOM $constate possédant la valeur $contenu. - $nombre peut avoir l'un des types suivants : - - booléen: présuppose la présence correspondant au sélecteur (TRUE) ou l'absence d'éléments (FALSE). - nombre entier: présuppose le nombre d'éléments. - tableau: présuppose que le nombre est dans une plage indiquée en utilisant <, >, <= et >= comme clefs. - - - Utilisation de assertSelectEquals() - xml = new DomDocument; - $this->xml->loadXML('BazBaz'); - } - - public function testAbsenceEchec() - { - $this->assertSelectEquals('foo bar', 'Baz', FALSE, $this->xml); - } - - public function testPresenceEchec() - { - $this->assertSelectEquals('foo bar', 'Bat', TRUE, $this->xml); - } - - public function testCompteExactEchec() - { - $this->assertSelectEquals('foo bar', 'Baz', 5, $this->xml); - } - - public function testPlageEchec() - { - $this->assertSelectEquals('foo bar', 'Baz', array('>'=>6, '<'=>8), $this->xml); - } -} -?>]]> - phpunit SelectEqualsTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -FFFF - -Time: 0 seconds, Memory: 5.50Mb - -There were 4 failures: - -1) SelectEqualsTest::testAbsenceEchec -Failed asserting that true is false. - -/home/sb/SelectEqualsTest.php:12 - -2) SelectEqualsTest::testPresenceEchec -Failed asserting that false is true. - -/home/sb/SelectEqualsTest.php:17 - -3) SelectEqualsTest::testCompteExactEchec -Failed asserting that 2 matches expected 5. - -/home/sb/SelectEqualsTest.php:22 - -4) SelectEqualsTest::testPlageEchec -Failed asserting that false is true. - -/home/sb/SelectEqualsTest.php:27 - -FAILURES! -Tests: 4, Assertions: 4, Failures: 4. - -
- -
- assertSelectRegExp() - assertSelectRegExp() - assertSelectRegExp(array $selecteur, string $motif, integer $nombre, mixed $constate[, string $message = '', boolean $isHtml = TRUE]) - Rapporte une erreur identifiée par le $message si le sélecteur CSS $selecteur ne correspond pas à $nombre éléments dans le noeud DOM $constate possédant une valeur qui correspond au $motif. - $nombre peut avoir l'un des types suivants : - - booléen: présuppose la présence d'éléments correspondant au sélecteur (TRUE) ou l'absence d'éléments (FALSE). - nombre entier: présuppose le nombre d'éléments. - tableau: présuppose que le nombre est dans une plage indiquée en utilisant <, >, <= et >= comme clefs. - - - Utilisation de assertSelectRegExp() - xml = new DomDocument; - $this->xml->loadXML('BazBaz'); - } - - public function testAbsenceEchec() - { - $this->assertSelectRegExp('foo bar', '/Ba.*/', FALSE, $this->xml); - } - - public function testPresenceEchec() - { - $this->assertSelectRegExp('foo bar', '/B[oe]z]/', TRUE, $this->xml); - } - - public function testCompteExactEchec() - { - $this->assertSelectRegExp('foo bar', '/Ba.*/', 5, $this->xml); - } - - public function testPlageEchec() - { - $this->assertSelectRegExp('foo bar', '/Ba.*/', array('>'=>6, '<'=>8), $this->xml); - } -} -?>]]> - phpunit SelectRegExpTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -FFFF - -Time: 0 seconds, Memory: 5.50Mb - -There were 4 failures: - -1) SelectRegExpTest::testAbsenceEchec -Failed asserting that true is false. - -/home/sb/SelectRegExpTest.php:12 - -2) SelectRegExpTest::testPresenceEchec -Failed asserting that false is true. - -/home/sb/SelectRegExpTest.php:17 - -3) SelectRegExpTest::testCompteExactEchec -Failed asserting that 2 matches expected 5. - -/home/sb/SelectRegExpTest.php:22 - -4) SelectRegExpTest::testPlageEchec -Failed asserting that false is true. - -/home/sb/SelectRegExpTest.php:27 - -FAILURES! -Tests: 4, Assertions: 4, Failures: 4. - -
- -
- assertStringEndsWith() - assertStringEndsWith() - assertStringEndsNotWith() - assertStringEndsWith(string $suffixe, string $chaine[, string $message = '']) - Rapporte une erreur identifiée par le $message si la $chaine ne se termine pas par $suffixe. - assertStringEndsNotWith() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertStringEndsWith() - assertStringEndsWith('suffixe', 'foo'); - } -} -?>]]> - phpunit StringEndsWithTest - -
- -
- assertStringEqualsFile() - assertStringEqualsFile() - assertStringNotEqualsFile() - assertStringEqualsFile(string $fichierAttendu, string $chaineConstatee[, string $message = '']) - Rapporte une erreur identifiée par le $message si le fichier indiqué par $fichierAttendu ne possède pas $chaineConstatee comme contenu. - assertStringNotEqualsFile() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertStringEqualsFile() - assertStringEqualsFile('/home/sb/attendu', 'constate'); - } -} -?>]]> - phpunit StringEqualsFileTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.25Mb - -There was 1 failure: - -1) StringEqualsFileTest::testEchec -Failed asserting that two strings are equal. +1) LongArrayDiffTest::testEquality +Failed asserting that two arrays are equal. --- Expected +++ Actual @@ @@ --'attendu --' -+'constate' - -/home/sb/StringEqualsFileTest.php:6 - -FAILURES! -Tests: 1, Assertions: 2, Failures: 1. - -
- -
- assertStringStartsWith() - assertStringStartsWith() - assertStringStartsNotWith() - assertStringStartsWith(string $prefixe, string $chaine[, string $message = '']) - Rapporte une erreur identifiée par le $message si la chaîne $chaine ne commence pas par $prefixe. - assertStringStartsNotWith() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertStringStartsWith() - assertStringStartsWith('prefixe', 'foo'); - } -} -?>]]> - phpunit StringStartsWithTest 2 +- 14 => 3 ++ 14 => 33 + 15 => 4 + 16 => 5 + 17 => 6 + ) -1) StringStartsWithTest::testEchec -Failed asserting that 'foo' starts with "prefixe". -/home/sb/StringStartsWithTest.php:6 +/home/sb/LongArrayDiffTest.php:7 FAILURES! Tests: 1, Assertions: 1, Failures: 1.]]> - -
- -
- assertTag() - assertTag() - assertNotTag() - assertTag(array $matcheur, string $constate[, string $message = '', boolean $isHtml = TRUE]) - Rapporte une erreur identifiée par le $message si $constate n'établit pas de correspondance avec le $matcheur. - $matcheur est un tableau associatif qui indique les critères de correspondance pour l'assertion: - - id: le noeud ayant l'attribut donné id doit correspondre à la valeur indiquée. - tags: le type du noeud doit correspondre à la valeur correspondante. - attributes: Les attributs du noeud doivent correspondre aux valeurs correspondantes dans le tableau associatif attributes. - content: le contenu du texte doit correspondre à la valeur donnée. - parent: le père du noeud doit correspondre au tableau associatif parent. - child: au moins un des fils directs du noeud doit satisfaire aux critères décrits dans le tableau associatif child. - ancestor: au moins l'un des ancêtres du noeud doit satisfaire aux critères décrits par le tableau associatif ancestor. - descendant: au moins l'un des descendants du noeud doit satisfaire les critères décrits dans le tableau associatif descendant. - children: tableau associatif pour compter les enfants d'un noeud. - - count: le nombre d'enfants correspondants doit être égal à ce nombre. - less_than: le nombre d'enfants correspondants doit être inférieur à ce nombre. - greater_than: le nombre d'enfants correspondants doit être supérieur à ce nombre. - only: un autre tableau associatif constitué de clefs à utiliser pour faire des correspondances avec les enfants, et seuls les enfants correspondants seront comptabilisés. - - - - assertNotTag() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertTag() - 'mon_id'); - -// Matcher qui présuppose qu'il existe un tag "span". -$matcher = array('tag' => 'span'); - -// Matcher qui présuppose qu'il existe un tag "span" contenant -// "Hello World". -$matcher = array('tag' => 'span', 'content' => 'Hello World'); - -// Matcher qui présuppose qu'il existe un tag "span" dont le contenu correspond au -// motif d'expression rationnelle -$matcher = array('tag' => 'span', 'content' => '/Essayez P(HP|erl)/'); - -// Matcher qui présuppose qu'il existe un "span"avec un attribut class class. -$matcher = array( - 'tag' => 'span', - 'attributes' => array('class' => 'list') -); - -// Matcher qui présuppose qu'il existe un "span" à l'intérieur d'un "div". -$matcher = array( - 'tag' => 'span', - 'parent' => array('tag' => 'div') -); - -// Matcher qui présuppose qu'il existe un "span" quelque part dans une "table". -$matcher = array( - 'tag' => 'span', - 'ancestor' => array('tag' => 'table') -); - -// Matcher qui présuppose qu'il existe un "span" avec au moins un fils "em". -$matcher = array( - 'tag' => 'span', - 'child' => array('tag' => 'em') -); - -// Matcher qui présuppose qu'il existe un "span" contenant un tag "strong" -// (éventuellement imbriqué) -$matcher = array( - 'tag' => 'span', - 'descendant' => array('tag' => 'strong') -); - -// Matcher qui présuppose qu'il existe un "span" contenant de 5 à 10 tags "em" comme -// fils directs -$matcher = array( - 'tag' => 'span', - 'children' => array( - 'less_than' => 11, - 'greater_than' => 4, - 'only' => array('tag' => 'em') - ) -); - -// Matcher qui présuppose qu'il existe un "div", avec un ancêtre "ul" et un "li" -// parent (avec class="enum"), et contenant un descendant "span" qui contient -// un élément avec id="mon_test" et le texte "Hello World". -$matcher = array( - 'tag' => 'div', - 'ancestor' => array('tag' => 'ul'), - 'parent' => array( - 'tag' => 'li', - 'attributes' => array('class' => 'enum') - ), - 'descendant' => array( - 'tag' => 'span', - 'child' => array( - 'id' => 'mon_test', - 'content' => 'Hello World' - ) - ) -); - -// Utilise assertTag() pour appliquer un $matcher à un morceau de $html. -$this->assertTag($matcher, $html); - -// Utilise assertTag() pour appliquer un matcher à un morceau de $xml. -$this->assertTag($matcher, $xml, '', FALSE); -?>]]> - -
- -
- assertThat() - assertThat() + +
+ Cas limite - Des assertions plus complexes peuvent être formulées en utilisant les classes - PHPUnit_Framework_Constraint. Elles peuvent être évaluées - en utilisant la méthode assertThat(). - montre comment - les contraintes logicalNot() et equalTo() - peuvent être utilisées pour exprimer la même assertion que - assertNotEquals(). + Quand une comparaison échoue, PHPUnit crée une représentation textuel des + valeurs d'entrées et les compare. A cause de cette implémentation un diff + peut montrer plus de problèmes qu'il n'en existe réellement. - assertThat(mixed $valeur, PHPUnit_Framework_Constraint $contrainte[, $message = '']) - Rapporte une erreur identifiée par le $message si la valeur $valeur ne correspond - pas à la $contrainte. - - Utilisation de assertThat() - assertThat( - $leBiscuit, - $this->logicalNot( - $this->equalTo($monBiscuit) - ) - ); - } -} -?>]]> - - - montre les - classes PHPUnit_Framework_Constraint disponibles. + Cela arrive seulement lors de l'utilisation de assetEquals ou d'autres fonction + de comparaison "faible" sur les tableaux ou les objets. - - Contraintes - - - - - Contrainte - Signification - - - - - attribute() - PHPUnit_Framework_Constraint_Attribute attribute(PHPUnit_Framework_Constraint $contrainte, $nomAttribut) - Contrainte qui applique une autre contrainte à l'attribut d'une classe ou d'un objet. - - - anything() - PHPUnit_Framework_Constraint_IsAnything anything() - Contrainte qui accepte n'importe quelle valeur en entrée. - - - arrayHasKey() - PHPUnit_Framework_Constraint_ArrayHasKey arrayHasKey(mixed $clef) - Contrainte qui présuppose que le tableau pour lequel elle est évaluée possède une clef donnée.. - - - contains() - PHPUnit_Framework_Constraint_TraversableContains contains(mixed $valeur) - Contrainte qui présuppose que le tableau ou l'objet qui implémente l'interface Iterator pour lequel elle est évaluée contient une valeur donnée.. - - - equalTo() - PHPUnit_Framework_Constraint_IsEqual equalTo($valeur, $delta = 0, $profondeurMax = 10) - Contrainte qui vérifie si une valeur est égale à une autre. - - - attributeEqualTo() - PHPUnit_Framework_Constraint_Attribute attributeEqualTo($nomAttribut, $valeur, $delta = 0, $profondeurMax = 10) - Contrainte qui vérifie si une valeur est égale à l'attribut d'une classe ou d'un objet. - - - fileExists() - PHPUnit_Framework_Constraint_FileExists fileExists() - Contrainte qui vérifie si le (nom de) fichier pour lequel elle est évaluée existe. - - - greaterThan() - PHPUnit_Framework_Constraint_GreaterThan greaterThan(mixed $valeur) - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée est supérieure à une valeur donnée. - - - greaterThanOrEqual() - PHPUnit_Framework_Constraint_Or greaterThanOrEqual(mixed $valeur) - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée et supérieure ou égale à une valeur donnée. - - - classHasAttribute() - PHPUnit_Framework_Constraint_ClassHasAttribute classHasAttribute(string $nomAttribut) - Contrainte qui présuppose que la classe pour laquelle elle est évaluée possède un attribut donné. - - - classHasStaticAttribute() - PHPUnit_Framework_Constraint_ClassHasStaticAttribute classHasStaticAttribute(string $nomAttribut) - Contrainte qui présuppose que la classe pour laquelle elle est évaluée possède un attribut statique donné. - - - hasAttribute() - PHPUnit_Framework_Constraint_ObjectHasAttribute hasAttribute(string $nomAttribut) - Contrainte qui présuppose que l'objet pour lequel elle est évaluée possède un attribut donné. - - - identicalTo() - PHPUnit_Framework_Constraint_IsIdentical identicalTo(mixed $valeur) - Contrainte qui présuppose qu'une valeur est identique à une autre. - - - isFalse() - PHPUnit_Framework_Constraint_IsFalse isFalse() - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée est FALSE. - - - isInstanceOf() - PHPUnit_Framework_Constraint_IsInstanceOf isInstanceOf(string $nomClasse) - Contrainte qui présuppose que l'objet pour lequel elle est évaluée est une instance d'une classe donnée. - - - isNull() - PHPUnit_Framework_Constraint_IsNull isNull() - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée est NULL. - - - isTrue() - PHPUnit_Framework_Constraint_IsTrue isTrue() - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée est TRUE. - - - isType() - PHPUnit_Framework_Constraint_IsType isType(string $type) - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée est du type indiqué. - - - lessThan() - PHPUnit_Framework_Constraint_LessThan lessThan(mixed $valeur) - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée est inférieure à la valeur donnée. - - - lessThanOrEqual() - PHPUnit_Framework_Constraint_Or lessThanOrEqual(mixed $valeur) - Contrainte qui présuppose que la valeur pour laquelle elle est évaluée est inférieure ou égale à une valeur donnée. - - - logicalAnd() - logicalAnd() - ET logique (AND). - - - logicalNot() - logicalNot(PHPUnit_Framework_Constraint $contrainte) - NON logique (NOT). - - - logicalOr() - logicalOr() - OU logique (OU). - - - logicalXor() - logicalXor() - OU exclusif logique (XOR). - - - matchesRegularExpression() - PHPUnit_Framework_Constraint_PCREMatch matchesRegularExpression(string $motif) - Contrainte qui présuppose que la chaîne pour laquelle elle est évaluée correspond à une expression rationnelle. - - - stringContains() - PHPUnit_Framework_Constraint_StringContains stringContains(string $chaine, bool $casse) - Contrainte qui présuppose que la chaîne pour laquelle elle est évaluée contient une chaîne donnée. - - - stringEndsWith() - PHPUnit_Framework_Constraint_StringEndsWith stringEndsWith(string $suffixe) - Contrainte qui présuppose que la chaîne pour laquelle elle est évaluée se termine avec un suffixe donné. - - - stringStartsWith() - PHPUnit_Framework_Constraint_StringStartsWith stringStartsWith(string $prefixe) - Contrainte qui présuppose que la chaîne pour laquelle elle est évaluée commence par un préfixe donné. - - - -
-
- -
- assertTrue() - assertTrue() - assertTrue(bool $condition[, string $message = '']) - Rapporte une erreur identifiée par le $message si la $condition est FALSE. - assertNotTrue() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertTrue() - assertTrue(FALSE); - } -} -?>]]> - phpunit TrueTest -PHPUnit 6.1.0 by Sebastian Bergmann and contributors. - -F - -Time: 0 seconds, Memory: 5.00Mb - -There was 1 failure: - -1) TrueTest::testEchec -Failed asserting that false is true. - -/home/sb/TrueTest.php:6 - -FAILURES! -Tests: 1, Assertions: 1, Failures: 1. - -
- -
- assertXmlFileEqualsXmlFile() - assertXmlFileEqualsXmlFile() - assertXmlFileNotEqualsXmlFile() - assertXmlFileEqualsXmlFile(string $fichierAttendu, string $fichierConstate[, string $message = '']) - Rapporte une erreur identifiée par le $message si le document XML dans $fichierConstate n'est pas égal au document XML dans $fichierAttendu. - assertXmlFileNotEqualsXmlFile() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertXmlFileEqualsXmlFile() + + Cas limite dans la génération de la différence lors de l'utilisation de comparaison faible assertXmlFileEqualsXmlFile( - '/home/sb/attendu.xml', '/home/sb/constate.xml'); - } -} -?>]]> - phpunit XmlFileEqualsXmlFileTest - -- -+ - - -/home/sb/XmlFileEqualsXmlFileTest.php:7 - -FAILURES! -Tests: 1, Assertions: 3, Failures: 1.]]> - -
+use PHPUnit\Framework\TestCase; -
- assertXmlStringEqualsXmlFile() - assertXmlStringEqualsXmlFile() - assertXmlStringNotEqualsXmlFile() - assertXmlStringEqualsXmlFile(string $fichierAttendu, string $xmlConstate[, string $message = '']) - Rapporte une erreur identifiée par le $message si le document XML dans $xmlConstate n'est pas égal au document XML dans $fichierAttendu. - assertXmlStringNotEqualsXmlFile() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertXmlStringEqualsXmlFile() - assertXmlStringEqualsXmlFile( - '/home/sb/attendu.xml', ''); + public function testEquality() { + $this->assertEquals( + [1, 2, 3, 4, 5, 6], + ['1', 2, 33, 4, 5, 6] + ); } } ?>]]> - phpunit XmlStringEqualsXmlFileTestphpunit ArrayWeakComparisonTest - -- -+ - - -/home/sb/XmlStringEqualsXmlFileTest.php:7 - -FAILURES! -Tests: 1, Assertions: 2, Failures: 1.]]> - -
- -
- assertXmlStringEqualsXmlString() - assertXmlStringEqualsXmlString() - assertXmlStringNotEqualsXmlString() - assertXmlStringEqualsXmlString(string $xmlAttendu, string $xmlConstateXml[, string $message = '']) - Rapporte une erreur identifiée par le $message si le document XML dans $xmlConstate n'est pas égal au document XML dans $xmlAttendu. - assertXmlStringNotEqualsXmlString() est l'inverse de cette assertion et prend les mêmes arguments. - - Utilisation de assertXmlStringEqualsXmlString() - assertXmlStringEqualsXmlString( - '', ''); - } -} -?>]]> - phpunit XmlStringEqualsXmlStringTest 1 ++ 0 => '1' + 1 => 2 +- 2 => 3 ++ 2 => 33 + 3 => 4 + 4 => 5 + 5 => 6 + ) -1) XmlStringEqualsXmlStringTest::testEchec -Failed asserting that two DOM documents are equal. ---- Expected -+++ Actual -@@ @@ - - -- -+ - -/home/sb/XmlStringEqualsXmlStringTest.php:7 +/home/sb/ArrayWeakComparisonTest.php:7 FAILURES! Tests: 1, Assertions: 1, Failures: 1.]]> + + + Dans cet exemple, la différence dans le premier indice entre + 1 et '1' + est signalée même si AssertEquals considère les valeurs comme une correspondance. + +