6. Listes des asserters

Pour écrire des tests plus explicites et moins verbeux, atoum fourni plusieurs asserters qui donnent accès a des assertions spécifiques aux types testés.

atoum possède différents asserters spécialisés permettant de manipuler différents éléments, les assertes héritent d’autres qu’ils spécialisent. Ceci permettant d’aider à garder une consistance entre les différents asserters et force à utiliser les même noms d’assertion.

Voici l’arbre d’héritage des asserters :

-- asserter (abstract)
    |-- error
    |-- mock
    |-- stream
    |-- variable
    |   |-- array
    |   |    `-- castToArray
    |   |-- boolean
    |   |-- class
    |   |    `-- testedClass
    |   |-- integer
    |   |   |-- float
    |   |   `-- sizeOf
    |   |-- object
    |   |   |-- dateInterval
    |   |   |-- dateTime
    |   |   |   `-- mysqlDateTime
    |   |   |-- exception
    |   |   `-- iterator
    |   |       `-- generator
    |   |-- resource
    |   `-- string
    |       |-- castToString
    |       |-- hash
    |       |-- output
    |       `-- utf8String
    `-- function

Note

La syntaxe générale des asserters/assertions est : $this->[asserter]($value)->[assertion];

Note

La plupart des assertions sont fluent, comme vous le verrez ci-dessous.

Note

A la fin du chapitre, vous trouverez plusieurs trucs & astuces relatif aux assertions et asserters, pensez à le lire!

6.1. afterDestructionOf

C’est l’assertion dédiée à la destruction des objets.

Cette assertion ne fait que prendre un objet, vérifier que la méthode __destruct() est bien définie puis l’appelle.

Si __destruct() existe bien et si son appel se passe sans erreur ni exception, alors le test passe.

<?php
$this
    ->afterDestructionOf($objectWithDestructor)     // passe
    ->afterDestructionOf($objectWithoutDestructor)  // échoue
;

6.2. array

C’est l’assertion dédiée aux tableaux.

Note

array étant un mot réservé en PHP, il n’a pas été possible de créer une assertion array. Elle s’appelle donc phpArray et un alias array a été créé. Vous pourrez donc rencontrer des ->phpArray() ou des ->array().

Il est conseillé d’utiliser exclusivement ->array() afin de simplifier la lecture des tests.

6.2.1. Sucre syntaxique

Il est à noter, qu’afin de simplifier l’écriture des tests sur les tableaux, du sucre syntaxique est disponible. Celui-ci permet d’effectuer diverses assertions directement sur les clefs du tableau testé.

$a = [
   'foo' => 42,
   'bar' => '1337'
];

$this
   ->array($a)
      ->integer['foo']->isEqualTo(42)
      ->string['bar']->isEqualTo('1337')
;

Note

This writing form is available from PHP 5.4.

6.2.2. child

Avec child vous pouvez faire une assertion sur un sous tableau.

<?php
$array = array(
   'ary' => array(
      'key1' => 'abc',
      'key2' => 123,
      'key3' => array(),
   ),
);

$this
   ->array($array)
      ->child['ary'](function($child)
      {
         $child
            ->hasSize(3)
            ->hasKeys(array('key1', 'key2', 'key3'))
            ->contains(123)
            ->child['key3'](function($child)
            {
               $child->isEmpty;
            });
      });

Note

Cette forme d’écriture n’est disponible qu’à partir de PHP 5.4.

6.2.3. contains

contains vérifie qu’un tableau contient une certaine donnée.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($fibonacci)
        ->contains('1')     // passe
        ->contains(1)       // passe, ne vérifie pas...
        ->contains('2')     // ... le type de la donnée
        ->contains(10)      // échoue
;

Note

contains ne fait pas de recherche récursive.

Avertissement

contains ne teste pas le type de la donnée.

Si vous souhaitez vérifier également son type, utilisez strictlyContains.

6.2.4. containsValues

containsValues vérifie qu’un tableau contient toutes les données fournies dans un tableau.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($array)
        ->containsValues(array(1, 2, 3))        // passe
        ->containsValues(array('5', '8', '13')) // passe
        ->containsValues(array(0, 1, 2))        // échoue
;

Note

containsValues ne fait pas de recherche récursive.

Avertissement

containsValues ne teste pas le type des données.

Si vous souhaitez vérifier également leurs types, utilisez strictlyContainsValues.

6.2.5. hasKey

hasKey vérifie qu’un tableau contient une certaine clef.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');
$atoum     = array(
    'name'        => 'atoum',
    'owner'       => 'mageekguy',
);

$this
    ->array($fibonacci)
        ->hasKey(0)         // passe
        ->hasKey(1)         // passe
        ->hasKey('1')       // passe
        ->hasKey(10)        // échoue

    ->array($atoum)
        ->hasKey('name')    // passe
        ->hasKey('price')   // échoue
;

Note

hasKey ne fait pas de recherche récursive.

Avertissement

hasKey ne teste pas le type des clefs.

6.2.6. hasKeys

hasKeys vérifie qu’un tableau contient toutes les clefs fournies dans un tableau.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');
$atoum     = array(
    'name'        => 'atoum',
    'owner'       => 'mageekguy',
);

$this
    ->array($fibonacci)
        ->hasKeys(array(0, 2, 4))           // passe
        ->hasKeys(array('0', 2))            // passe
        ->hasKeys(array('4', 0, 3))         // passe
        ->hasKeys(array(0, 3, 10))          // échoue

    ->array($atoum)
        ->hasKeys(array('name', 'owner'))   // passe
        ->hasKeys(array('name', 'price'))   // échoue
;

Note

hasKeys ne fait pas de recherche récursive.

Avertissement

hasKey ne teste pas le type des clefs.

6.2.7. hasSize

hasSize vérifie la taille d’un tableau.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($fibonacci)
        ->hasSize(7)        // passe
        ->hasSize(10)       // échoue
;

Note

hasSize n’est pas récursif.

6.2.8. isEmpty

isEmpty vérifie qu’un tableau est vide.

<?php
$emptyArray    = array();
$nonEmptyArray = array(null, null);

$this
    ->array($emptyArray)
        ->isEmpty()         // passe

    ->array($nonEmptyArray)
        ->isEmpty()         // échoue
;

6.2.9. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.2.10. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.2.11. isNotEmpty

isNotEmpty vérifie qu’un tableau n’est pas vide.

<?php
$emptyArray    = array();
$nonEmptyArray = array(null, null);

$this
    ->array($emptyArray)
        ->isNotEmpty()      // échoue

    ->array($nonEmptyArray)
        ->isNotEmpty()      // passe
;

6.2.12. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.2.13. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.2.14. keys

keys vous permet de récupérer un asserter de type array contenant les clefs du tableau testé.

<?php
$atoum = array(
    'name'  => 'atoum',
    'owner' => 'mageekguy',
);

$this
    ->array($atoum)
        ->keys
            ->isEqualTo(
                array(
                    'name',
                    'owner',
                )
            )
;

6.2.15. notContains

notContains vérifie qu’un tableau ne contient pas une donnée.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($fibonacci)
        ->notContains(null)         // passe
        ->notContains(1)            // échoue
        ->notContains(10)           // passe
;

Note

notContains ne fait pas de recherche récursive.

Avertissement

contains ne teste pas le type de la donnée.

Si vous souhaitez vérifier également son type, utilisez strictlyNotContains.

6.2.16. notContainsValues

notContainsValues vérifie qu’un tableau ne contient aucune des données fournies dans un tableau.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($array)
        ->notContainsValues(array(1, 4, 10))    // échoue
        ->notContainsValues(array(4, 10, 34))   // passe
        ->notContainsValues(array(1, '2', 3))   // échoue
;

Note

notContainsValues ne fait pas de recherche récursive.

Avertissement

notContainsValues ne teste pas le type des données.

Si vous souhaitez vérifier également leurs types, utilisez strictlyNotContainsValues.

6.2.17. notHasKey

notHasKey vérifie qu’un tableau ne contient pas une certaine clef.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');
$atoum     = array(
    'name'  => 'atoum',
    'owner' => 'mageekguy',
);

$this
    ->array($fibonacci)
        ->notHasKey(0)          // échoue
        ->notHasKey(1)          // échoue
        ->notHasKey('1')        // échoue
        ->notHasKey(10)         // passe

    ->array($atoum)
        ->notHasKey('name')     // échoue
        ->notHasKey('price')    // passe
;

Note

notHasKey ne fait pas de recherche récursive.

Avertissement

notHasKey ne teste pas le type des clefs.

6.2.18. notHasKeys

notHasKeys vérifie qu’un tableau ne contient aucune des clefs fournies dans un tableau.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');
$atoum     = array(
    'name'        => 'atoum',
    'owner'       => 'mageekguy',
);

$this
    ->array($fibonacci)
        ->notHasKeys(array(0, 2, 4))            // échoue
        ->notHasKeys(array('0', 2))             // échoue
        ->notHasKeys(array('4', 0, 3))          // échoue
        ->notHasKeys(array(10, 11, 12))         // passe

    ->array($atoum)
        ->notHasKeys(array('name', 'owner'))    // échoue
        ->notHasKeys(array('foo', 'price'))     // passe
;

Note

notHasKeys ne fait pas de recherche récursive.

Avertissement

notHasKey ne teste pas le type des clefs.

6.2.19. size

size vous permet de récupérer un asserter de type integer contenant la taille du tableau testé.

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($fibonacci)
        ->size
            ->isGreaterThan(5)
;

6.2.20. strictlyContains

strictlyContains vérifie qu’un tableau contient une certaine donnée (même valeur et même type).

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($fibonacci)
        ->strictlyContains('1')     // passe
        ->strictlyContains(1)       // échoue
        ->strictlyContains('2')     // échoue
        ->strictlyContains(2)       // passe
        ->strictlyContains(10)      // échoue
;

Note

strictlyContains ne fait pas de recherche récursive.

Avertissement

strictlyContains teste le type de la donnée.

Si vous ne souhaitez pas vérifier son type, utilisez contains.

6.2.21. strictlyContainsValues

strictlyContainsValues vérifie qu’un tableau contient toutes les données fournies dans un tableau (même valeur et même type).

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($array)
        ->strictlyContainsValues(array('1', 2, '3'))    // passe
        ->strictlyContainsValues(array(1, 2, 3))        // échoue
        ->strictlyContainsValues(array(5, '8', 13))     // passe
        ->strictlyContainsValues(array('5', '8', '13')) // échoue
        ->strictlyContainsValues(array(0, '1', 2))      // échoue
;

Note

strictlyContainsValues ne fait pas de recherche récursive.

Avertissement

strictlyContainsValues teste le type des données.

Si vous ne souhaitez pas vérifier leurs types, utilisez containsValues.

6.2.22. strictlyNotContains

strictlyNotContains vérifie qu’un tableau ne contient pas une donnée (même valeur et même type).

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($fibonacci)
        ->strictlyNotContains(null)         // passe
        ->strictlyNotContains('1')          // échoue
        ->strictlyNotContains(1)            // passe
        ->strictlyNotContains(10)           // passe
;

Note

strictlyNotContains ne fait pas de recherche récursive.

Avertissement

strictlyNotContains teste le type de la donnée.

Si vous ne souhaitez pas vérifier son type, utilisez notContains.

6.2.23. strictlyNotContainsValues

strictlyNotContainsValues vérifie qu’un tableau ne contient aucune des données fournies dans un tableau (même valeur et même type).

<?php
$fibonacci = array('1', 2, '3', 5, '8', 13, '21');

$this
    ->array($array)
        ->strictlyNotContainsValues(array('1', 4, 10))  // échoue
        ->strictlyNotContainsValues(array(1, 4, 10))    // passe
        ->strictlyNotContainsValues(array(4, 10, 34))   // passe
        ->strictlyNotContainsValues(array('1', 2, '3')) // échoue
        ->strictlyNotContainsValues(array(1, '2', 3))   // passe
;

Note

strictlyNotContainsValues ne fait pas de recherche récursive.

Avertissement

strictlyNotContainsValues teste le type des données.

Si vous ne souhaitez pas vérifier leurs types, utilisez notContainsValues.

6.2.24. values

keys vous permet de récupérer un asserter de type array contenant les clefs du tableau testé.

Exemple :

<?php
$this
    ->given($arr = [0 => 'foo', 2 => 'bar', 3 => 'baz'])
    ->then
      ->array($arr)->values
        ->string[0]->isEqualTo('foo')
        ->string[1]->isEqualTo('bar')
        ->string[2]->isEqualTo('baz')
;

Nouveau dans la version 2.9.0: assertion values ajouté

6.3. boolean

C’est l’assertion dédiée aux booléens.

Si vous essayez de tester une variable qui n’est pas un booléen avec cette assertion, cela échouera.

Note

null n’est pas un booléen. Reportez-vous au manuel de PHP pour savoir ce que is_bool considère ou non comme un booléen.

6.3.1. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.3.2. isFalse

isFalse vérifie que le booléen est strictement égal à false.

<?php
$true  = true;
$false = false;

$this
    ->boolean($true)
        ->isFalse()     // échoue

    ->boolean($false)
        ->isFalse()     // passe
;

6.3.3. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.3.4. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.3.5. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.3.6. isTrue

isTrue vérifie que le booléen est strictement égal à true.

<?php
$true  = true;
$false = false;

$this
    ->boolean($true)
        ->isTrue()      // passe

    ->boolean($false)
        ->isTrue()      // échoue
;

6.4. castToArray

C’est l’assertion dédiée aux tests sur le transtypage d’objets en tableaux.

<?php
class AtoumVersions {
    private $versions = ['1.0', '2.0', '2.1'];

    public function __toArray() {
        return $this->versions;
    }
}

$this
    ->castToArray(new AtoumVersions())
        ->contains('1.0')
;

Voir aussi

L’asserter castToArray retourne une instance de l’asserter array. Vous pouvez donc utiliser toutes les assertions de l’asserter array

6.5. castToString

C’est l’assertion dédiée aux tests sur le transtypage d’objets en chaîne de caractères.

<?php
class AtoumVersion {
    private $version = '1.0';

    public function __toString() {
        return 'atoum v' . $this->version;
    }
}

$this
    ->castToString(new AtoumVersion())
        ->isEqualTo('atoum v1.0')
;

6.5.1. contains

Voir aussi

contains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::contains

6.5.2. notContains

Voir aussi

notContains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::notContains

6.5.3. hasLength

Voir aussi

hasLength est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLength

6.5.4. hasLengthGreaterThan

Voir aussi

hasLengthGreaterThan est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLengthGreaterThan

6.5.5. hasLengthLessThan

Voir aussi

hasLengthLessThan est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLengthLessThan

6.5.6. isEmpty

Voir aussi

isEmpty est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isEmpty

6.5.7. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.5.8. isEqualToContentsOfFile

Voir aussi

isEqualToContentsOfFile est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isEqualToContentsOfFile

6.5.9. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.5.10. isNotEmpty

Voir aussi

isNotEmpty est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isNotEmpty

6.5.11. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.5.12. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.5.13. matches

Voir aussi

matches est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::matches

6.6. class

C’est l’assertion dédiée aux classes.

<?php
$object = new \StdClass;

$this
    ->class(get_class($object))

    ->class('\StdClass')
;

Note

Le mot-clef class étant réservé en PHP, il n’a pas été possible de créer une assertion class. Elle s’appelle donc phpClass et un alias class a été créé. Vous pourrez donc rencontrer des ->phpClass() ou des ->class().

Il est conseillé d’utiliser exclusivement ->class().

6.6.1. hasConstant

hasConstant vérifie que la classe possède bien la constante testée.

<?php
$this
    ->class('\StdClass')
        ->hasConstant('FOO')       // échoue

    ->class('\FilesystemIterator')
        ->hasConstant('CURRENT_AS_PATHNAME')       // passe
;

6.6.2. hasInterface

hasInterface vérifie que la classe implémente une interface donnée.

<?php
$this
    ->class('\ArrayIterator')
        ->hasInterface('Countable')     // passe

    ->class('\StdClass')
        ->hasInterface('Countable')     // échoue
;

6.6.3. hasMethod

hasMethod vérifie que la classe contient une méthode donnée.

<?php
$this
    ->class('\ArrayIterator')
        ->hasMethod('count')    // passe

    ->class('\StdClass')
        ->hasMethod('count')    // échoue
;

6.6.4. hasNoParent

hasNoParent vérifie que la classe n’hérite d’aucune classe.

<?php
$this
    ->class('\StdClass')
        ->hasNoParent()     // passe

    ->class('\FilesystemIterator')
        ->hasNoParent()     // échoue
;

Avertissement

Une classe peut implémenter une ou plusieurs interfaces et n’hériter d’aucune classe.

hasNoParent ne vérifie pas les interfaces, uniquement les classes héritées.

6.6.5. hasParent

hasParent vérifie que la classe hérite bien d’une classe.

<?php
$this
    ->class('\StdClass')
        ->hasParent()       // échoue

    ->class('\FilesystemIterator')
        ->hasParent()       // passe
;

Avertissement

Une classe peut implémenter une ou plusieurs interfaces et n’hériter d’aucune classe.

hasParent ne vérifie pas les interfaces, uniquement les classes héritées.

6.6.6. isAbstract

isAbstract vérifie que la classe est abstraite.

<?php
$this
    ->class('\StdClass')
        ->isAbstract()       // échoue
;

6.6.7. isFinal

isFinal vérifie que la classe est finale.

Dans le cas suivant, nous testons une classe non final (StdClass) :

<?php
$this
        ->class('\StdClass')
                ->isFinal()             // échoue
;

Dans le cas suivant, la classe testée est une classe final

<?php
$this
        ->testedClass
                ->isFinal()             // passe
;

$this
        ->testedClass
                ->isFinal               // passe aussi
;

6.6.8. isSubclassOf

isSubclassOf vérifie que la classe hérite de la classe donnée.

<?php
$this
    ->class('\FilesystemIterator')
        ->isSubclassOf('\DirectoryIterator')    // passe
        ->isSubclassOf('\SplFileInfo')          // passe
        ->isSubclassOf('\StdClass')             // échoue
;

6.7. dateInterval

C’est l’assertion dédiée à l’objet DateInterval.

Si vous essayez de tester une variable qui n’est pas un objet DateInterval (ou une classe qui l’étend) avec cette assertion, cela échouera.

6.7.1. isCloneOf

Voir aussi

isCloneOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isCloneOf

6.7.2. isEqualTo

isEqualTo vérifie que la durée de l’objet DateInterval est égale à la durée d’un autre objet DateInterval.

<?php
$di = new DateInterval('P1D');

$this
    ->dateInterval($di)
        ->isEqualTo(                // passe
            new DateInterval('P1D')
        )
        ->isEqualTo(                // échoue
            new DateInterval('P2D')
        )
;

6.7.3. isGreaterThan

isGreaterThan vérifie que la durée de l’objet DateInterval est supérieure à la durée d’un autre objet DateInterval.

<?php
$di = new DateInterval('P2D');

$this
    ->dateInterval($di)
        ->isGreaterThan(            // passe
            new DateInterval('P1D')
        )
        ->isGreaterThan(            // échoue
            new DateInterval('P2D')
        )
;

6.7.4. isGreaterThanOrEqualTo

isGreaterThanOrEqualTo vérifie que la durée de l’objet DateInterval est supérieure ou égale à la durée d’un autre objet DateInterval.

<?php
$di = new DateInterval('P2D');

$this
    ->dateInterval($di)
        ->isGreaterThanOrEqualTo(   // passe
            new DateInterval('P1D')
        )
        ->isGreaterThanOrEqualTo(   // passe
            new DateInterval('P2D')
        )
        ->isGreaterThanOrEqualTo(   // échoue
            new DateInterval('P3D')
        )
;

6.7.5. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isIdenticalTo

6.7.6. isInstanceOf

Voir aussi

isInstanceOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isInstanceOf

6.7.7. isLessThan

isLessThan vérifie que la durée de l’objet DateInterval est inférieure à la durée d’un autre objet DateInterval.

<?php
$di = new DateInterval('P1D');

$this
    ->dateInterval($di)
        ->isLessThan(               // passe
            new DateInterval('P2D')
        )
        ->isLessThan(               // échoue
            new DateInterval('P1D')
        )
;

6.7.8. isLessThanOrEqualTo

isLessThanOrEqualTo vérifie que la durée de l’objet DateInterval est inférieure ou égale à la durée d’un autre objet DateInterval.

<?php
$di = new DateInterval('P2D');

$this
    ->dateInterval($di)
        ->isLessThanOrEqualTo(      // passe
            new DateInterval('P3D')
        )
        ->isLessThanOrEqualTo(      // passe
            new DateInterval('P2D')
        )
        ->isLessThanOrEqualTo(      // échoue
            new DateInterval('P1D')
        )
;

6.7.9. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotEqualTo

6.7.10. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotIdenticalTo

6.7.11. isZero

isZero vérifie que la durée de l’objet DateInterval est égale à 0.

<?php
$di1 = new DateInterval('P0D');
$di2 = new DateInterval('P1D');

$this
    ->dateInterval($di1)
        ->isZero()      // passe
    ->dateInterval($di2)
        ->isZero()      // échoue
;

6.8. dateTime

C’est l’assertion dédiée à l’objet DateTime.

Si vous essayez de tester une variable qui n’est pas un objet DateTime (ou une classe qui l’étend) avec cette assertion, cela échouera.

6.8.1. hasDate

hasDate vérifie la partie date de l’objet DateTime.

<?php
$dt = new DateTime('1981-02-13');

$this
    ->dateTime($dt)
        ->hasDate('1981', '02', '13')   // passe
        ->hasDate('1981', '2',  '13')   // passe
        ->hasDate(1981,   2,    13)     // passe
;

6.8.2. hasDateAndTime

hasDateAndTime vérifie la partie date et heure de l’objet DateTime.

<?php
$dt = new DateTime('1981-02-13 01:02:03');

$this
    ->dateTime($dt)
        // passe
        ->hasDateAndTime('1981', '02', '13', '01', '02', '03')
        // passe
        ->hasDateAndTime('1981', '2',  '13', '1',  '2',  '3')
        // passe
        ->hasDateAndTime(1981,   2,    13,   1,    2,    3)
;

6.8.3. hasDay

hasDay vérifie le jour de l’objet DateTime.

<?php
$dt = new DateTime('1981-02-13');

$this
    ->dateTime($dt)
        ->hasDay(13)        // passe
;

6.8.4. hasHours

hasHours vérifie l’heure de l’objet DateTime.

<?php
$dt = new DateTime('01:02:03');

$this
    ->dateTime($dt)
        ->hasHours('01')    // passe
        ->hasHours('1')     // passe
        ->hasHours(1)       // passe
;

6.8.5. hasMinutes

hasMinutes vérifie les minutes de l’objet DateTime.

<?php
$dt = new DateTime('01:02:03');

$this
    ->dateTime($dt)
        ->hasMinutes('02')  // passe
        ->hasMinutes('2')   // passe
        ->hasMinutes(2)     // passe
;

6.8.6. hasMonth

hasMonth vérifie le mois de l’objet DateTime.

<?php
$dt = new DateTime('1981-02-13');

$this
    ->dateTime($dt)
        ->hasMonth(2)       // passe
;

6.8.7. hasSeconds

hasSeconds vérifie les secondes de l’objet DateTime.

<?php
$dt = new DateTime('01:02:03');

$this
    ->dateTime($dt)
        ->hasSeconds('03')    // passe
        ->hasSeconds('3')     // passe
        ->hasSeconds(3)       // passe
;

6.8.8. hasTime

hasTime vérifie le temps de l’objet DateTime.

<?php
$dt = new DateTime('01:02:03');

$this
    ->dateTime($dt)
        ->hasTime('01', '02', '03')     // passe
        ->hasTime('1',  '2',  '3')      // passe
        ->hasTime(1,    2,    3)        // passe
;

6.8.9. hasTimezone

hasTimezone vérifie le fuseau horaire de l’objet DateTime.

<?php
$dt = new DateTime();

$this
    ->dateTime($dt)
        ->hasTimezone('Europe/Paris')
;

6.8.10. hasYear

hasYear vérifie l’année de l’objet DateTime.

<?php
$dt = new DateTime('1981-02-13');

$this
    ->dateTime($dt)
        ->hasYear(1981)     // passe
;

6.8.11. isCloneOf

Voir aussi

isCloneOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isCloneOf

6.8.12. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isEqualTo

6.8.13. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isIdenticalTo

6.8.14. isImmutable

isImmutable vérifie que qu’un objet DateTime est immuable.

<?php
$dt = new DateTime('1981-02-13');

$this
    ->dateTime($dt)
        ->isImmutable(1981)     // rate
;

$dt = new DateTimeImmutable('1981-02-13');

$this
    ->dateTime($dt)
        ->isImmutable(1981)     // réussit
;

6.8.15. isInstanceOf

Voir aussi

isInstanceOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isInstanceOf

6.8.16. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotEqualTo

6.8.17. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotIdenticalTo

6.9. error

C’est l’assertion dédiée aux erreurs.

<?php
$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
        ->error()
            ->exists() // or notExists
;

Note

La syntaxe utilise les fonctions anonymes (aussi appelées fermetures ou closures) introduites en PHP 5.3. Pour plus de précision, lisez la documentation PHP sur les fonctions anonymes.

Avertissement

Les types d’erreur E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR, E_COMPILE_WARNING ainsi que la plupart des E_STRICT ne peuvent pas être gérés avec cette fonction.

6.9.1. exists

exists vérifie qu’une erreur a été levée lors de l’exécution du code précédent.

<?php
$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
        ->error()
            ->exists()      // pass

    ->when(
        function() {
            // code without error
        }
    )
        ->error()
            ->exists()      // failed
;

6.9.2. notExists

notExists vérifie qu’aucune erreur n’a été levée lors de l’exécution du code précédent.

<?php
$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
        ->error()
            ->notExists()   // fails

    ->when(
        function() {
            // code without error
        }
    )
        ->error()
            ->notExists()   // pass
;

6.9.3. withType

withType vérifie le type de l’erreur levée.

<?php
$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withType(E_USER_NOTICE)   // pass
        ->exists()

    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withType(E_USER_WARNING)  // failed
        ->exists()
;

6.9.4. withAnyType

withAnyType ne vérifie pas le type de l’erreur. C’est le comportement par défaut de l’asserter. Donc ->error()->withAnyType()->exists() est l’équivalent de ->error()->exists(). Cette méthode existe pour ajouter de la sémantique dans vos tests.

<?php
$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withAnyType() // pass
        ->exists()
    ->when(
        function() {
        }
    )
    ->error()
        ->withAnyType()
        ->exists() // fails
;

6.9.5. withMessage

withMessage vérifie le contenu du message de l’erreur levée.

<?php
$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withMessage('message')
        ->exists() // passes
;

$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withMessage('MESSAGE')
        ->exists() // fails
;

6.9.6. withAnyMessage

withAnyMessage ne vérifie pas le message de l’erreur. C’est le comportement par défaut de l’asserter. Donc ->error()->withAnyMessage()->exists() est l’équivalent de ->error()->exists(). Cette méthode existe pour ajouter de la sémantique dans vos tests.

<?php
$this
    ->when(
        function() {
            trigger_error();
        }
    )
    ->error()
        ->withAnyMessage()
        ->exists() // passes
;

$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withAnyMessage()
        ->exists() // passes
;

$this
    ->when(
        function() {
        }
    )
    ->error()
        ->withAnyMessage()
        ->exists() // fails
;

6.9.7. withPattern

withPattern vérifie le contenu du message de l’erreur soulevée par l’expression régulière.

<?php
$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withPattern('/^mess.*$/')
        ->exists() // passes
;

$this
    ->when(
        function() {
            trigger_error('message');
        }
    )
    ->error()
        ->withPattern('/^mess$/')
        ->exists() // fails
;

6.10. exception

C’est l’assertion dédiée aux exceptions.

<?php
$this
    ->exception(
        function() use($myObject) {
            // ce code lève une exception: throw new \Exception;
            $myObject->doOneThing('wrongParameter');
        }
    )
;

Note

La syntaxe utilise les fonctions anonymes (aussi appelées fermetures ou closures) introduites en PHP 5.3. Pour plus de précision, lisez la documentation PHP sur les fonctions anonymes.

Nous pouvons même facilement récupérer la dernière exception via $this->exception.

<?php
$this
    ->exception(
        function() use($myObject) {
            // ce code lève une exception: throw new \Exception('erreur', 42);
            $myObject->doOneThing('wrongParameter');
        }
    )->isIdenticalTo($this->exception) // passes
;

$this->exception->hasCode(42); // passes
$this->exception->hasMessage('erreur'); // passes

Note

Avant atoum 3.0.0, si vous avez besoin d’effectuer des assertions, vous aviez besoin d’ajouter atoum\test $test en argument de la closure. Après la version 3.0.0, vous pouvez simplement utiliser $this à l’intérieur de la closure, afin d’effectuer des assertions.

6.10.1. hasCode

hasCode vérifie le code de l’exception.

<?php
$this
    ->exception(
        function() use($myObject) {
            // ce code lève une exception: throw new \Exception('erreur', 42);
            $myObject->doOneThing('wrongParameter');
        }
    )
        ->hasCode(42)
;

6.10.2. hasDefaultCode

hasDefaultCode vérifie que le code de l’exception est la valeur par défaut, c’est-à-dire 0.

<?php
$this
    ->exception(
        function() use($myObject) {
            // ce code lève une exception: throw new \Exception;
            $myObject->doOneThing('wrongParameter');
        }
    )
        ->hasDefaultCode()
;

Note

hasDefaultCode is equivalent to hasCode(0).

6.10.3. hasMessage

hasMessage vérifie le message de l’exception.

<?php
$this
    ->exception(
        function() use($myObject) {
            // ce code lève une exception: throw new \Exception('Message');
            $myObject->doOneThing('wrongParameter');
        }
    )
        ->hasMessage('Message')     // passes
        ->hasMessage('message')     // fails
;

6.10.4. hasNestedException

hasNestedException vérifie que l’exception contient une référence vers l’exception précédente. Si le type d’exception est fournie, cela va aussi vérifier la classe de l’exception.

<?php
$this
    ->exception(
        function() use($myObject) {
            // ce code lève une exception: throw new \Exception('Message');
            $myObject->doOneThing('wrongParameter');
        }
    )
        ->hasNestedException()      // fails

    ->exception(
        function() use($myObject) {
            try {
                // ce code lève une exception: throw new \FirstException('Message 1', 42);
                $myObject->doOneThing('wrongParameter');
            }
            // ... l'exception est attrapée...
            catch(\FirstException $e) {
                // ... puis relancée, encapsulée dans une seconde exception
                throw new \SecondException('Message 2', 24, $e);
            }
        }
    )
        ->isInstanceOf('\FirstException')           // fails
        ->isInstanceOf('\SecondException')          // passes

        ->hasNestedException()                      // passes
        ->hasNestedException(new \FirstException)   // passes
        ->hasNestedException(new \SecondException)  // fails
;

6.10.5. isCloneOf

Voir aussi

isCloneOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isCloneOf

6.10.6. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isEqualTo

6.10.7. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isIdenticalTo

6.10.8. isInstanceOf

Voir aussi

isInstanceOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isInstanceOf

6.10.9. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotEqualTo

6.10.10. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotIdenticalTo

6.10.11. message

message vous permet de récupérer un asserter de type string contenant le message de l’exception testée.

<?php
$this
    ->exception(
        function() {
            throw new \Exception('My custom message to test');
        }
    )
        ->message
            ->contains('message')
;

6.11. extension

C’est l’assertion dédiée aux extensions PHP.

6.11.1. isLoaded

Vérifie si l’extension est chargée (installée et activée).

<?php
$this
        ->extension('json')
                ->isLoaded()
        ;

Note

Si vous avez besoin de lancer un test uniquement si une extension est présente, vous pouvez utiliser l’annotation PHP.

6.12. float

C’est l’assertion dédiée aux nombres décimaux.

Si vous essayez de tester une variable qui n’est pas un nombre décimal avec cette assertion, cela échouera.

Note

null n’est pas un nombre décimal. Reportez-vous au manuel de PHP pour savoir ce que is_float considère ou non comme un nombre décimal.

6.12.1. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.12.2. isGreaterThan

Voir aussi

isGreaterThan est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isGreaterThan

6.12.3. isGreaterThanOrEqualTo

Voir aussi

isGreaterThanOrEqualTo est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isGreaterThanOrEqualTo

6.12.4. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.12.5. isLessThan

Voir aussi

isLessThan est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isLessThan

6.12.6. isLessThanOrEqualTo

Voir aussi

isLessThanOrEqualTo est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isLessThanOrEqualoo

6.12.7. isNearlyEqualTo

isNearlyEqualTo vérifie que le nombre décimal est approximativement égal à la valeur qu’elle reçoit en argument.

En effet, en informatique, les nombres décimaux sont gérées d’une façon qui ne permet pas d’effectuer des comparaisons précises sans recourir à des outils spécialisés. Essayez par exemple d’exécuter la commande suivante :

$ php -r 'var_dump(1 - 0.97 === 0.03);'
bool(false)

Le résultat devrait pourtant être true.

Note

Pour avoir plus d’informations sur ce phénomène, lisez la documentation PHP sur le type float et sa précision.

Cette méthode cherche donc à minorer ce problème.

<?php
$float = 1 - 0.97;

$this
    ->float($float)
        ->isNearlyEqualTo(0.03) // passe
        ->isEqualTo(0.03)       // échoue
;

Note

Pour avoir plus d’informations sur l’algorithme utilisé, consultez le floating point guide.

6.12.8. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.12.9. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.12.10. isZero

Voir aussi

isZero est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isZero

6.13. function

C’est l’asserter dédié aux fonctions natives qui sont mockée.

6.13.1. wasCalled

wasCalled vérifie que la fonction mockée a été appelée.

6.13.2. wasCalledWithArguments

wasCalledWithArguments permet de vérifier les arguments utilisé avec l’appel de la fonction.

6.13.3. wasCalledWithIdenticalArguments

wasCalledWithIdenticalArguments permet de vérifier tous les arguments utilisé avec l’appel de la fonction.

6.13.4. wasCalledWithoutAnyArgument

wasCalledWithoutAnyArgument vérifie que l’appel a la fonction a été effectué sans aucun argument.

6.13.5. Compter les appels

Si vous voulez vous pouvez effectuer une assertion supplémentaire en comptant le nombre d’appel à la fonction.

<?php
$this->function->error_log = true;

$this
   ->if($this->newTestedInstance())
   ->and($this->testedInstance->methodWithAnErrorLog($notExcepted = uniqid()))
   ->then
       ->function('error_log')
           ->wasCalledWithArguments('Value ' . $notExcepted . ' is not excepted here')
               ->once();

Ici, nous vérifions que notre fonction a été appelée une seule fois, avec les arguments fournis.

6.13.5.1. after

after vérifie que la fonction a été appelée après la méthode passée en paramètre.

Voir aussi

after a le même comportement que celui existant sur l’asserter des mock. Pour plus d’informations, reportez-vous à la documentation de mock::after

6.13.5.2. atLeastOnce

atLeastOnce vérifie que la fonction a été appelée au moins une fois.

Voir aussi

atLeastOnce a le même comportement que celui de l’asserter des mock. Pour plus d’informations, reportez-vous à la documentation de mock::atLeastOnce

6.13.5.3. before

after vérifie que la fonction a été appelée avant la méthode passée en paramètre.

Voir aussi

before is the same as the one on the mock asserter. For more information, refer to the documentation of mock::before

6.13.5.4. exactly

exactly check that the mocked function has been called a specific number of times.

Voir aussi

exactly is the same as the one on the mock asserter. For more information, refer to the documentation of mock::exactly

6.13.5.5. never

never check that the mocked function has never been called.

Voir aussi

never is the same as the one on the mock asserter. For more information, refer to the documentation of mock::never

6.13.5.6. once/twice/thrice

This asserters check that the mocked function has been called exactly:

• une fois (once)
• deux fois (twice)
• trois fois (thrice)

Voir aussi

once is the same as the one on the mock asserter. For more information, refer to the documentation of mock::once/twice/thrice

6.14. generator

Il s’agit de l’asserter dédié aux generators.

L’asserter generator hérite l’asserter iterator, vous pouvez donc utiliser toutes les assertions de celui-ci.

Exemple :

<?php
$generator = function() {
    for ($i=0; $i<3; $i++) {
        yield ($i+1);
    }
};
$this
    ->generator($generator())
        ->hasSize(3)
;

Dans cet exemple, nous créons un générateur qui générera 3 valeurs, et nous vérifierons que la taille de ce qui est généré est de 3.

6.14.1. yields

yields est utilisé pour facilité les tests sur les valeurs générée par le générateur. Chaque fois que ->yields est appelé, la valeur suivante du générateur est récupérée. Vous pouvez ensuite utiliser tout les asserter sur cette valeur (par exemple class, string ou variable).

Exemple :

<?php
$generator = function() {
    for ($i=0; $i<3; $i++) {
        yield ($i+1);
    }
};
$this
    ->generator($generator())
        ->yields->variable->isEqualTo(1)
        ->yields->variable->isEqualTo(2)
        ->yields->integer->isEqualTo(3)
;

Dans cette exemple nous créer un générateur qui produit 3 valeurs : 1, 2 et 3. Ensuite nous produisons chaque valeurs et effectuons une assertion sur celle-ci pour vérifier le type et la valeur. Dans les deux premières valeurs produite, nous utilisons l’asserter variable et nous ne vérifions que la valeur. Avec la troisième valeur produite, nous vérifions qu’il s’agit bien d’un entier (toute asserter peut-être utiliser sur cette valeur) avant de vérifier la valeur.

6.14.2. returns

Note

Cette assertion ne fonctionne que avec PHP >= 7.0.

Depuis la version 7.0 de PHP, les générateurs peuvent retourner une valeur via un appel à la méthode ->getReturn(). Lorsque vous appeler ->returns sur le l’asserter generator, atoum va renvoyé la valeur via la méthode ->getReturn()``sur l'asserter. Ensuite vous pourrez utiliser n'importe quel autre asserter sur cette valeur comme avec l'assertion ``yields.

Exemple :

<?php
$generator = function() {
    for ($i=0; $i<3; $i++) {
        yield ($i+1);
    }
    return 42;
};
$this
    ->generator($generator())
        ->yields->variable->isEqualTo(1)
        ->yields->variable->isEqualTo(2)
        ->yields->integer->isEqualTo(3)
        ->returns->integer->isEqualTo(42)
;

Dans cet exemple, nous effectuons quelques vérifications sur toutes les valeurs produites. On vérifie ensuite que le générateur renvoie un entier avec une valeur de 42 (tout comme un appel à l’assertion yields, vous pouvez utiliser n’importe quel asserter pour vérifier la valeur retournée).

Nouveau dans la version 3.0.0: Asserter generator ajouté

6.15. hash

C’est l’assertion dédiée aux tests sur les hashs (empreintes numériques).

6.15.1. contains

Voir aussi

contains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::contains

6.15.2. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.15.3. isEqualToContentsOfFile

Voir aussi

isEqualToContentsOfFile est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isEqualToContentsOfFile

6.15.4. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.15.5. isMd5

isMd5 vérifie que la chaîne de caractère est du format md5, par exemple une chaîne de caractère d’une longueur de 32.

<?php
$hash    = hash('md5', 'atoum');
$notHash = 'atoum';

$this
    ->hash($hash)
        ->isMd5()       // passe
    ->hash($notHash)
        ->isMd5()       // échoue
;

6.15.6. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.15.7. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.15.8. isSha1

isSha1 vérifie que la chaîne de caractère est du format sha1, par exemple une chaîne de caractère d’une longueur de 40.

<?php
$hash    = hash('sha1', 'atoum');
$notHash = 'atoum';

$this
    ->hash($hash)
        ->isSha1()      // passe
    ->hash($notHash)
        ->isSha1()      // échoue
;

6.15.9. isSha256

isSha256 vérifie que la chaîne de caractère est du format sha256, par exemple une chaîne de caractère d’une longueur de 64 caractères.

<?php
$hash    = hash('sha256', 'atoum');
$notHash = 'atoum';

$this
    ->hash($hash)
        ->isSha256()    // passe
    ->hash($notHash)
        ->isSha256()    // échoue
;

6.15.10. isSha512

isSha512 vérifie que la chaîne de caractère est du format sha512, c’est-à-dire, une chaîne de caractère d’une longueur de 128 caractères.

<?php
$hash    = hash('sha512', 'atoum');
$notHash = 'atoum';

$this
    ->hash($hash)
        ->isSha512()    // passe
    ->hash($notHash)
        ->isSha512()    // échoue
;

6.15.11. notContains

Voir aussi

notContains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::notContains

6.16. integer

C’est l’assertion dédiée aux entiers.

Si vous essayez de tester une variable qui n’est pas un entier avec cette assertion, cela échouera.

Note

null n’est pas un entier. Reportez-vous au manuel de PHP pour savoir ce que is_int considère ou non comme un entier.

6.16.1. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.16.2. isGreaterThan

isGreaterThan vérifie que l’entier est strictement supérieur à une certaine donnée.

<?php
$zero = 0;

$this
    ->integer($zero)
        ->isGreaterThan(-1)     // passe
        ->isGreaterThan('-1')   // échoue car "-1"
                                // n'est pas un entier
        ->isGreaterThan(0)      // échoue
;

6.16.3. isGreaterThanOrEqualTo

isGreaterThanOrEqualTo vérifie que l’entier est supérieur ou égal à une certaine donnée.

<?php
$zero = 0;

$this
    ->integer($zero)
        ->isGreaterThanOrEqualTo(-1)    // passe
        ->isGreaterThanOrEqualTo(0)     // passe
        ->isGreaterThanOrEqualTo('-1')  // échoue, car "-1"
                                        // n'est pas un entier
;

6.16.4. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.16.5. isLessThan

isLessThan vérifie que l’entier est strictement inférieur à une certaine donnée.

<?php
$zero = 0;

$this
    ->integer($zero)
        ->isLessThan(10)    // passe
        ->isLessThan('10')  // échoue, car "10" n'est pas un entier
        ->isLessThan(0)     // échoue
;

6.16.6. isLessThanOrEqualTo

isLessThanOrEqualTo vérifie que l’entier est inférieur ou égal à une certaine donnée.

<?php
$zero = 0;

$this
    ->integer($zero)
        ->isLessThanOrEqualTo(10)       // passe
        ->isLessThanOrEqualTo(0)        // passe
        ->isLessThanOrEqualTo('10')     // échoue car "10"
                                        // n'est pas un entier
;

6.16.7. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.16.8. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.16.9. isZero

isZero vérifie que l’entier est égal à 0.

<?php
$zero    = 0;
$notZero = -1;

$this
    ->integer($zero)
        ->isZero()          // passe

    ->integer($notZero)
        ->isZero()          // échoue
;

Note

isZero est équivalent à isEqualTo(0).

6.17. mock

C’est l’assertion dédiée aux mocks.

<?php
$mock = new \mock\MyClass;

$this
    ->mock($mock)
;

Note

Reportez-vous à la documentation sur les bouchons (mock) pour obtenir plus d’informations sur la façon de créer et gérer les bouchons.

6.17.1. call

call permet de spécifier une méthode du mock à tester, son appel doit être suivi d’un appel à une méthode de vérification d’appel comme atLeastOnce, once/twice/thrice, exactly, etc…

<?php

$this
    ->given($mock = new \mock\MyFirstClass)
    ->and($object = new MySecondClass($mock))

    ->if($object->methodThatCallMyMethod())  // Cela va appeler la méthode myMethod de $mock
    ->then

    ->mock($mock)
        ->call('myMethod')
            ->once()
;

6.17.1.1. after

after vérifie que la méthode a été appelée après la méthode passée en paramètre.

<?php
$this
    ->when($mock = new \mock\example)
    ->if(
        $mock->test2(),
        $mock->test()
    )
    ->mock($mock)
    ->call('test')
        ->after($this->mock($mock)->call('test2')->once())
        ->once() // passe
;

$this
    ->when($mock = new \mock\example)
    ->if(
        $mock->test(),
        $mock->test2()
    )
    ->mock($mock)
    ->call('test')
        ->after($this->mock($mock)->call('test2')->once())
        ->once() // échoue
;

6.17.1.2. atLeastOnce

atLeastOnce vérifie que la méthode testée (voir call) du mock testé a été appelée au moins une fois.

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->call('myMethod')
            ->atLeastOnce()
;

6.17.1.3. before

before vérifie que la méthode a été appelée avant la méthode passée en paramètre.

<?php
$this
    ->when($mock = new \mock\example)
    ->if(
        $mock->test(),
        $mock->test2()
    )
    ->mock($mock)
    ->call('test')
        ->before($this->mock($mock)->call('test2')->once())
        ->once() // passe
;

$this
    ->when($mock = new \mock\example)
    ->if(
        $mock->test2(),
        $mock->test()
    )
    ->mock($mock)
    ->call('test')
        ->before($this->mock($mock)->call('test2')->once())
        ->once() // échoue
;

6.17.1.4. exactly

exactly vérifie que la méthode testée (voir call) du mock testé exactement un certain nombre de fois.

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->call('myMethod')
            ->exactly(2)
;

Note

il existe une version simplifiée avec ->{2}.

6.17.1.5. never

never vérifie que la méthode testée (voir call) du mock testé n’a jamais été appelée.

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->call('myMethod')
            ->never()
;

Note

never est équivalent à exactly(0).

6.17.1.6. once/twice/thrice

Ces assertions vérifient que la méthode testée (voir call) du mock testé a été appelée exactement :

• une fois (once)
• deux fois (twice)
• trois fois (thrice)

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->call('myMethod')
            ->once()
        ->call('mySecondMethod')
            ->twice()
        ->call('myThirdMethod')
            ->thrice()
;

Note

once, twice et thrice sont respectivement équivalents à un appel à exactly(1), exactly(2) et exactly(3).

6.17.1.7. withAnyArguments

withAnyArguments permet de ne pas spécifier les arguments attendus lors de l’appel à la méthode testée (voir call) du mock testé.

Cette méthode est surtout utile pour remettre à zéro les arguments, comme dans l’exemple suivant :

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->call('myMethod')
            ->withArguments('first')     ->once()
            ->withArguments('second')    ->once()
            ->withAnyArguments()->exactly(2)
;

6.17.1.8. withArguments

withArguments permet de spécifier les paramètres attendus lors de l’appel à la méthode testée (voir call) du mock testé.

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->call('myMethod')
            ->withArguments('first', 'second')->once()
;

Avertissement

withArguments ne teste pas le type des arguments.

Si vous souhaitez vérifier également leurs types, utilisez withIdenticalArguments.

6.17.1.9. withIdenticalArguments

withIdenticalArguments permet de spécifier les paramètres attendus lors de l’appel à la méthode testée (voir call) du mock testé.

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->call('myMethod')
            ->withIdenticalArguments('first', 'second')->once()
;

Avertissement

withIdenticalArguments teste le type des arguments.

Si vous ne souhaitez pas vérifier leurs types, utilisez withArguments.

6.17.1.10. withAtLeastArguments

withAtLeastArguments permet de spécifier les paramètres minimums attendus lors de l’appel à la méthode testée (voir call) du mock testé.

<?php
$this
   ->if($mock = new \mock\example)
   ->and($mock->test('a', 'b'))
   ->mock($mock)
   ->call('test')
         ->withAtLeastArguments(array('a'))->once() //passes
         ->withAtLeastArguments(array('a', 'b'))->once() //passes
         ->withAtLeastArguments(array('c'))->once() //fails
;

Avertissement

withAtLeastArguments ne teste pas le type des arguments.

Si vous souhaitez vérifier également leurs types, utilisez withAtLeastIdenticalArguments.

6.17.1.11. withAtLeastIdenticalArguments

withAtLeastIdenticalArguments permet de spécifier les paramètres minimums attendus lors de l’appel à la méthode testée (voir call) du mock testé.

<?php
$this
    ->if($mock = new \mock\example)
    ->and($mock->test(1, 2))
    ->mock($mock)
        ->call('test')
        ->withAtLeastIdenticalArguments(array(1))->once() //passes
        ->withAtLeastIdenticalArguments(array(1, 2))->once() //passes
        ->withAtLeastIdenticalArguments(array('1'))->once() //fails
;

Avertissement

withAtLeastIdenticalArguments teste le type des arguments.

Si vous ne souhaitez pas vérifier leurs types, utilisez withAtLeastArguments.

6.17.1.12. withoutAnyArgument

withoutAnyArgument permet de spécifier que la méthode ne doit recevoir aucun paramètre lors de son appel (voir call).

<?php
$this
    ->when($mock = new \mock\example)
    ->if($mock->test())
    ->mock($mock)
        ->call('test')
            ->withoutAnyArgument()->once() // passe
    ->if($mock->test2('argument'))
    ->mock($mock)
        ->call('test2')
            ->withoutAnyArgument()->once() // échoue
;

Note

withoutAnyArgument reviens à appeler withAtLeastArguments avec un tableau vide : ->withAtLeastArguments(array()).

6.17.2. receive

Est un alias de call.

<?php
$this
    ->given(
        $connection = new mock\connection
    )
    ->if(
        $this->newTestedInstance($connection)
    )
    ->then
        ->object($this->testedInstance->noMoreValue())->isTestedInstance
        ->mock($connection)->receive('newPacket')->withArguments(new packet)->once;

   // Identique à
   $this->mock($connection)->call('newPacket')->withArguments(new packet)->once;

6.17.3. wasCalled

wasCalled vérifie qu’au moins une méthode du mock a été appelée au moins une fois.

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->wasCalled()
;

6.17.4. wasNotCalled

wasNotCalled vérifie qu’aucune méthode du mock n’a été appelée.

<?php
$mock = new \mock\MyFirstClass;

$this
    ->object(new MySecondClass($mock))

    ->mock($mock)
        ->wasNotCalled()
;

6.18. mysqlDateTime

C’est l’assertion dédiée aux objets décrivant une date MySQL et basée sur l’objet DateTime.

Les dates doivent utiliser un format compatible avec MySQL et de nombreux autre SGBD (Système de gestion de base de données)), à savoir « Y-m-d H:i:s » « Y-m-d H:i:s »

Note

Reportez-vous à la documentation de la fonction date() du manuel de PHP pour plus d’information.

Si vous essayez de tester une variable qui n’est pas un objet DateTime (ou une classe qui l’étend) avec cette assertion, cela échouera.

6.18.1. hasDate

Voir aussi

hasDate est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasDate

6.18.2. hasDateAndTime

Voir aussi

hasDateAndTime est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasDateAndTime

6.18.3. hasDay

Voir aussi

hasDay est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasDay

6.18.4. hasHours

Voir aussi

hasHours est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasHours

6.18.5. hasMinutes

Indication

hasMinutes est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasMinutes

6.18.6. hasMonth

Voir aussi

hasMonth est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasMonth

6.18.7. hasSeconds

Voir aussi

hasSeconds est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasSeconds

6.18.8. hasTime

Voir aussi

hasTime est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasTime

6.18.9. hasTimezone

Voir aussi

hasTimezone est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasTimezone

6.18.10. hasYear

Voir aussi

hasYear est une méthode héritée de l’asserter dateTime. Pour plus d’informations, reportez-vous à la documentation de dateTime::hasYear

6.18.11. isCloneOf

Voir aussi

isCloneOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isCloneOf

6.18.12. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isEqualTo

6.18.13. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isIdenticalTo

6.18.14. isInstanceOf

Indication

isInstanceOf est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isInstanceOf

6.18.15. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotEqualTo

6.18.16. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter object. Pour plus d’informations, reportez-vous à la documentation de object::isNotIdenticalTo

6.19. object

C’est l’assertion dédiée aux objets.

Si vous essayez de tester une variable qui n’est pas un objet avec cette assertion, cela échouera.

Note

null n’est pas un objet. Reportez-vous au manuel de PHP pour savoir ce que is_object considère ou non comme un objet.

6.19.1. hasSize

hasSize vérifie la taille d’un objet qui implémente l’interface Countable.

<?php
$countableObject = new GlobIterator('*');

$this
    ->object($countableObject)
        ->hasSize(3)
;

6.19.2. isCallable

<?php
class foo
{
    public function __invoke()
    {
        // code
    }
}

$this
    ->object(new foo)
        ->isCallable()  // passe

    ->object(new StdClass)
        ->isCallable()  // échoue
;

Note

Pour être identifiés comme callable, vos objets devront être instanciés à partir de classes qui implémentent la méthode magique __invoke.

Voir aussi

isCallable est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isCallable

6.19.3. isCloneOf

isCloneOf vérifie qu’un objet est le clone d’un objet donné, c’est-à-dire que les objets sont égaux, mais ne pointent pas vers la même instance.

<?php
$object1 = new \StdClass;
$object2 = new \StdClass;
$object3 = clone($object1);
$object4 = new \StdClass;
$object4->foo = 'bar';

$this
    ->object($object1)
        ->isCloneOf($object2)   // passe
        ->isCloneOf($object3)   // passe
        ->isCloneOf($object4)   // échoue
;

Note

Pour plus de précision, lisez la documentation PHP sur la comparaison d’objet.

6.19.4. isEmpty

isEmpty vérifie que la taille d’un objet implémentant l’interface Countable est égale à 0.

<?php
$countableObject = new GlobIterator('atoum.php');

$this
    ->object($countableObject)
        ->isEmpty()
;

Note

isEmpty est équivalent à hasSize(0).

6.19.5. isEqualTo

isEqualTo vérifie qu’un objet est égal à un autre. Deux objets sont considérés égaux lorsqu’ils ont les mêmes attributs et valeurs, et qu’ils sont des instances de la même classe.

Note

Pour plus de précision, lisez la documentation PHP sur la comparaison d’objet.

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.19.6. isIdenticalTo

isIdenticalTo vérifie que deux objets sont identiques. Deux objets sont considérés identiques lorsqu’ils font référence à la même instance de la même classe.

Note

Pour plus de précision, lisez la documentation PHP sur la comparaison d’objet.

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.19.7. isInstanceOf

isInstanceOf vérifie qu’un objet est :

• une instance de la classe donnée,
• une sous-classe de la classe donnée (abstraite ou non),
• une instance d’une classe qui implémente l’interface donnée.

<?php
$object = new \StdClass();

$this
    ->object($object)
        ->isInstanceOf('\StdClass')     // passe
        ->isInstanceOf('\Iterator')     // échoue
;


interface FooInterface
{
    public function foo();
}

class FooClass implements FooInterface
{
    public function foo()
    {
        echo "foo";
    }
}

class BarClass extends FooClass
{
}

$foo = new FooClass;
$bar = new BarClass;

$this
    ->object($foo)
        ->isInstanceOf('\FooClass')     // passe
        ->isInstanceOf('\FooInterface') // passe
        ->isInstanceOf('\BarClass')     // échoue
        ->isInstanceOf('\StdClass')     // échoue

    ->object($bar)
        ->isInstanceOf('\FooClass')     // passe
        ->isInstanceOf('\FooInterface') // passe
        ->isInstanceOf('\BarClass')     // passe
        ->isInstanceOf('\StdClass')     // échoue
;

Note

Les noms des classes et des interfaces doivent être absolus, car les éventuelles importations d’espace de nommage ne sont pas prises en compte.

Indication

Notez qu’avec PHP >= 5.5 vous pouvez utiliser le mot-clé class pour obtenir les noms de classe absolus, par exemple $this->object($foo)->isInstanceOf(FooClass::class).

6.19.8. isInstanceOfTestedClass

<?php
$this->newTestedInstance;
$object = new TestedClass();
$this->object($this->testedInstance)->isInstanceOfTestedClass;
$this->object($object)->isInstanceOfTestedClass;

6.19.9. isNotCallable

<?php
class foo
{
    public function __invoke()
    {
        // code
    }
}

$this
    ->variable(new foo)
        ->isNotCallable()   // échoue

    ->variable(new StdClass)
        ->isNotCallable()   // passe
;

Voir aussi

isNotCallable est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotCallable

6.19.10. isNotEqualTo

isEqualTo vérifie qu’un objet n’est pas égal à un autre. Deux objets sont considérés égaux lorsqu’ils ont les mêmes attributs et valeurs, et qu’ils sont des instances de la même classe.

Note

Pour plus de précision, lisez la documentation PHP sur la comparaison d’objet.

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.19.11. isNotIdenticalTo

isIdenticalTo vérifie que deux objets ne sont pas identiques. Deux objets sont considérés identiques lorsqu’ils font référence à la même instance de la même classe.

Note

Pour plus de précision, lisez la documentation PHP sur la comparaison d’objet.

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.19.12. isNotInstanceOf

isNotInstanceOf vérifie qu’un objet n’est pas :

• une instance de la classe donnée,
• une sous-classe de la classe donnée (abstraite ou non),
• une instance d’une classe qui implémente l’interface donnée.

<?php
$object = new \StdClass();

$this
    ->object($object)
        ->isNotInstanceOf('\StdClass')     // échoue
        ->isNotInstanceOf('\Iterator')     // échoue
;

Note

Tout comme isInstanceOf, le nom de la classe ou de l’interface doivent être absolus car les imports de namespace seront ignorés.

6.19.13. isNotTestedInstance

<?php
$this->newTestedInstance;
$this->object($this->testedInstance)->isNotTestedInstance; // fail

6.19.14. isTestedInstance

<?php
$this->newTestedInstance;
$this->object($this->testedInstance)->isTestedInstance;

$object = new TestedClass();
$this->object($object)->isTestedInstance; // échec

6.19.15. toString

L’assertion toString caste un objet en string et retourne un asserter string sur cette valeur.

Exemple :

<?php
$this
  ->object(
    new class {
      public function __toString()
      {
        return 'foo';
      }
    }
  )
    ->isIdenticalTo('foo') // rate
    ->toString
      ->isIdenticalTo('foo') // passe
;

6.20. output

C’est l’assertion dédiée aux tests sur les sorties, c’est-à-dire tout ce qui est censé être affiché à l’écran.

<?php
$this
    ->output(
        function() {
            echo 'Hello world';
        }
    )
;

Note

La syntaxe utilise les fonctions anonymes (aussi appelées fermetures ou closures) introduites en PHP 5.3. Pour plus de précision, lisez la documentation PHP sur les fonctions anonymes.

6.20.1. contains

Voir aussi

contains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::contains

6.20.2. hasLength

Voir aussi

hasLength est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLength

6.20.3. hasLengthGreaterThan

Voir aussi

hasLengthGreaterThan est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLengthGreaterThan

6.20.4. hasLengthLessThan

Voir aussi

hasLengthLessThan est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLengthLessThan

6.20.5. isEmpty

Voir aussi

isEmpty est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isEmpty

6.20.6. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.20.7. isEqualToContentsOfFile

Voir aussi

isEqualToContentsOfFile est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isEqualToContentsOfFile

6.20.8. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.20.9. isNotEmpty

Voir aussi

isNotEmpty est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isNotEmpty

6.20.10. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.20.11. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.20.12. matches

Voir aussi

matches est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::matches

6.20.13. notContains

Voir aussi

notContains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::notContains

6.21. resource

C’est l’assertion dédié au ´ressource <http://php.net/language.types.resource>´_.

6.21.1. isOfType

Cette méthode permet de comparer le type de ressource avec le type de la valeur fournie en paramètre. Dans l’exemple suivant, on vérifie que le paramètre est un stream.

$this
    ->resource($variable)
        ->isOfType('stream')
;

6.21.2. isStream

$this
    ->resource($variable)
        ->isStream()
;

->is*() va faire correspondre le type du flux au nom d’une méthode :

->isFooBar() va essayer de trouver un flux correspondant à foo bar, fooBar, foo_bar…

6.21.3. type

$this
    ->resource($variable)
        ->type
                        ->isEqualTo('stream')
                        ->matches('/foo.*bar/')
;

->$type est un helper fournissant l’assertion des string sur le type de stream.

6.22. sizeOf

C’est l’assertion dédiée aux tests sur la taille des tableaux et des objets implémentant l’interface Countable.

<?php
$array           = array(1, 2, 3);
$countableObject = new GlobIterator('*');

$this
    ->sizeOf($array)
        ->isEqualTo(3)

    ->sizeOf($countableObject)
        ->isGreaterThan(0)
;

6.22.1. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.22.2. isGreaterThan

Voir aussi

isGreaterThan est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isGreaterThan

6.22.3. isGreaterThanOrEqualTo

Voir aussi

isGreaterThanOrEqualTo est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isGreaterThanOrEqualTo

6.22.4. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.22.5. isLessThan

Voir aussi

isLessThan est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isLessThan

6.22.6. isLessThanOrEqualTo

Voir aussi

isLessThanOrEqualTo est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isLessThanOrEqualTo

6.22.7. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.22.8. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.22.9. isZero

Voir aussi

isZero est une méthode héritée de l’asserter integer. Pour plus d’informations, reportez-vous à la documentation de integer::isZero

6.23. stream

C’est l’assertion dédié au ´streams <http://php.net/intro.stream>´_.

Elle est basée sur le système de fichier virtuel d’atoum (VFS). Un nouveau stream wrapper sera enregistré (qui commence par atoum://).

Le bouchon va créer un nouveau fichier dans le VFS et le chemin du flux sera accessible en appellant la méthode getPath sur le controlleur de flux (par exemple atoum://mockUniqId).

6.23.1. isRead

isRead vérifie si le flux bouchoné à bien été lu.

<?php
$this
    ->given(
        $streamController = \atoum\mock\stream::get(),
        $streamController->file_get_contents = 'myFakeContent'
    )
    ->if(file_get_contents($streamController->getPath()))
    ->stream($streamController)
        ->isRead() // passe
;

$this
    ->given(
        $streamController = \atoum\mock\stream::get(),
        $streamController->file_get_contents = 'myFakeContent'
    )
    ->if() //we do nothing
    ->stream($streamController)
        ->isRead() // échoue
;

6.23.2. isWritten

isWritten vérifie si le flux bouchoné à bien été écrit.

<?php
$this
    ->given(
        $streamController = \atoum\mock\stream::get(),
        $streamController->file_put_contents = strlen($content = 'myTestContent')
    )
    ->if(file_put_contents($streamController->getPath(), $content))
    ->stream($streamController)
        ->isWritten() // passe
;

$this
   ->given(
     $streamController = \atoum\mock\stream::get(),
     $streamController->file_put_contents = strlen($content = 'myTestContent')
   )
   ->if() // we do nothing
   ->stream($streamController)
      ->isWritten() // échoue
;

6.23.3. isWrited

Indication

isWrited est un alias de la méthode isWritten. Pour plus d’informations, reportez-vous à la documentation de stream::isWritten

6.24. string

C’est l’assertion dédiée aux chaînes de caractères.

6.24.1. contains

contains vérifie qu’une chaîne de caractère contient une autre chaîne de caractère donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->contains('ll')    // passe
        ->contains(' ')     // passe
        ->contains('php')   // échoue
;

6.24.2. endWith

endWith vérifie qu’une chaîne de caractère se termine par une autre chaîne de caractère donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->endWith('world')     // passe
        ->endWith('lo world')  // passe
        ->endWith('Hello')     // échoue
        ->endWith(' ')         // échoue
;

6.24.3. hasLength

hasLength vérifie la taille de la chaîne de caractère.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->hasLength(11)     // passe
        ->hasLength(20)     // échoue
;

6.24.4. hasLengthGreaterThan

hasLengthGreaterThan vérifie que la taille d’une chaîne de caractères est plus grande qu’une valeur donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->hasLengthGreaterThan(10)     // passe
        ->hasLengthGreaterThan(20)     // échoue
;

6.24.5. hasLengthLessThan

hasLengthLessThan vérifie que la taille d’une chaîne de caractères est plus petite qu’une valeur donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->hasLengthLessThan(20)     // passe
        ->hasLengthLessThan(10)     // échoue
;

6.24.6. isEmpty

isEmpty vérifie qu’une chaîne de caractères est vide.

<?php
$emptyString    = '';
$nonEmptyString = 'atoum';

$this
    ->string($emptyString)
        ->isEmpty()             // passe

    ->string($nonEmptyString)
        ->isEmpty()             // échoue
;

6.24.7. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.24.8. isEqualToContentsOfFile

isEqualToContentsOfFile vérifie qu’une chaîne de caractère est égale au contenu d’un fichier donné par son chemin.

<?php
$this
    ->string($string)
        ->isEqualToContentsOfFile('/path/to/file')
;

Note

si le fichier n’existe pas, le test échoue.

6.24.9. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.24.10. isNotEmpty

isNotEmpty vérifie qu’une chaîne de caractères n’est pas vide.

<?php
$emptyString    = '';
$nonEmptyString = 'atoum';

$this
    ->string($emptyString)
        ->isNotEmpty()          // échoue

    ->string($nonEmptyString)
        ->isNotEmpty()          // passe
;

6.24.11. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.24.12. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.24.13. length

length vous permet de récupérer un asserter de type integer contenant la taille de la chaîne de caractères testée.

<?php
$string = 'atoum';

$this
    ->string($string)
        ->length
            ->isGreaterThanOrEqualTo(5)
;

6.24.14. match

Indication

match est un alias de la méthode matches. Pour plus d’informations, reportez-vous à la documentation de string::matches

6.24.15. matches

matches vérifie qu’une expression régulière correspond à la chaîne de caractères.

<?php
$phone = '0102030405';
$vdm = "Aujourd'hui, à 57 ans, mon père s'est fait tatouer une licorne sur l'épaule. VDM";

$this
    ->string($phone)
        ->matches('#^0[1-9]\d{8}$#')

    ->string($vdm)
        ->matches("#^Aujourd'hui.*VDM$#")
;

6.24.16. notContains

notContains vérifie qu’une chaîne de caractère ne contient pas une autre chaîne de caractère donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->notContains('php')   // passe
        ->notContains(';')     // passe
        ->notContains('ll')    // échoue
        ->notContains(' ')     // échoue
;

6.24.17. notEndWith

notEndWith vérifie qu’une chaîne de caractère ne se termine pas par une autre chaîne de caractère donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->notEndWith('Hello')     // passe
        ->notEndWith(' ')         // passe
        ->notEndWith('world')     // échoue
        ->notEndWith('lo world')  // échoue
;

6.24.18. notMatches

notMatches vérifie qu’une expression régulière ne correspond pas à la chaîne de caractères.

<?php
$phone = '0102030405';
$vdm = "Aujourd'hui, à 57 ans, mon père s'est fait tatouer une licorne sur l'épaule. VDM";

$this
    ->string($phone)
        ->notMatches('#azerty#') // passe
        ->notMatches('#^0[1-9]\d{8}$#') // échoue

    ->string($vdm)
        ->notMatches("#^Hier.*VDM$#") // passe
        ->notMatches("#^Aujourd'hui.*VDM$#") // échoue
;

6.24.19. notStartWith

notStartWith vérifie qu’une chaîne de caractère ne commence pas par une autre chaîne de caractère donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->notStartWith('world')     // passe
        ->notStartWith(' ')         // passe
        ->notStartWith('Hello wo')  // échoue
        ->notStartWith('He')        // échoue
;

6.24.20. startWith

startWith vérifie qu’une chaîne de caractère commence par une autre chaîne de caractère donnée.

<?php
$string = 'Hello world';

$this
    ->string($string)
        ->startWith('Hello wo') // passe
        ->startWith('He')       // passe
        ->startWith('world')    // échoue
        ->startWith(' ')        // échoue

;

Nouveau dans la version 3.3.0: Ajout de l’assertion notMatches

6.25. utf8String

C’est l’assertion dédiée aux chaînes de caractères UTF-8.

Note

utf8Strings utilise les fonctions mb_* pour gérer les chaînes multioctets. Reportez-vous au manuel de PHP pour avoir plus d’information sur l’extension mbstring.

6.25.1. contains

Voir aussi

contains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::contains

6.25.2. hasLength

Voir aussi

hasLength est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLength

6.25.3. hasLengthGreaterThan

Voir aussi

hasLengthGreaterThan est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLengthGreaterThan

6.25.4. hasLengthLessThan

Voir aussi

hasLengthLessThan est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::hasLengthLessThan

6.25.5. isEmpty

Voir aussi

isEmpty est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isEmpty

6.25.6. isEqualTo

Voir aussi

isEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isEqualTo

6.25.7. isEqualToContentsOfFile

Voir aussi

isEqualToContentsOfFile est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isEqualToContentsOfFile

6.25.8. isIdenticalTo

Voir aussi

isIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isIdenticalTo

6.25.9. isNotEmpty

Voir aussi

isNotEmpty est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::isNotEmpty

6.25.10. isNotEqualTo

Voir aussi

isNotEqualTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotEqualTo

6.25.11. isNotIdenticalTo

Voir aussi

isNotIdenticalTo est une méthode héritée de l’asserter variable. Pour plus d’informations, reportez-vous à la documentation de variable::isNotIdenticalTo

6.25.12. matches

Indication

matches est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::matches

Note

Pensez à bien ajouter u comme option de recherche dans votre expression régulière. Pour plus de précision, lisez la documentation PHP sur les options de recherche des expressions régulières.

<?php
$vdm = "Aujourd'hui, à 57 ans, mon père s'est fait tatouer une licorne sur l'épaule. FML";

$this
    ->utf8String($vdm)
        ->matches("#^Aujourd'hui.*VDM$#u")
;

6.25.13. notContains

Voir aussi

notContains est une méthode héritée de l’asserter string. Pour plus d’informations, reportez-vous à la documentation de string::notContains

6.26. variable

C’est l’assertion de base de toutes les variables. Elle contient les tests nécessaires à n’importe quel type de variable.

6.26.1. isCallable

isCallable vérifie que la variable peut être appelée comme fonction.

<?php
$f = function() {
    // code
};

$this
    ->variable($f)
        ->isCallable()  // passe

    ->variable('\Vendor\Project\foobar')
        ->isCallable()

    ->variable(array('\Vendor\Project\Foo', 'bar'))
        ->isCallable()

    ->variable('\Vendor\Project\Foo::bar')
        ->isCallable()
;

6.26.2. isEqualTo

isEqualTo vérifie que la variable est égale à une certaine donnée.

<?php
$a = 'a';

$this
    ->variable($a)
        ->isEqualTo('a')    // passe
;

Avertissement

isEqualTo ne teste pas le type de la variable.

Si vous souhaitez vérifier également son type, utilisez isIdenticalTo.

6.26.3. isIdenticalTo

isIdenticalTo vérifie que la variable a la même valeur et le même type qu’une certaine donnée. Dans le cas d’objets, isIdenticalTo vérifie que les données pointent sur la même instance.

<?php
$a = '1';

$this
    ->variable($a)
        ->isIdenticalTo(1)          // échoue
;

$stdClass1 = new \StdClass();
$stdClass2 = new \StdClass();
$stdClass3 = $stdClass1;

$this
    ->variable($stdClass1)
        ->isIdenticalTo(stdClass3)  // passe
        ->isIdenticalTo(stdClass2)  // échoue
;

Avertissement

isIdenticalTo teste le type de la variable.

Si vous ne souhaitez pas vérifier son type, utilisez isEqualTo.

6.26.4. isNotCallable

isNotCallable vérifie que la variable ne peut pas être appelée comme fonction.

<?php
$f = function() {
    // code
};
$int    = 1;
$string = 'nonExistingMethod';

$this
    ->variable($f)
        ->isNotCallable()   // échoue

    ->variable($int)
        ->isNotCallable()   // passe

    ->variable($string)
        ->isNotCallable()   // passe

    ->variable(new StdClass)
        ->isNotCallable()   // passe
;

6.26.5. isNotEqualTo

isNotEqualTo vérifie que la variable n’a pas la même valeur qu’une certaine donnée.

<?php
$a       = 'a';
$aString = '1';

$this
    ->variable($a)
        ->isNotEqualTo('b')     // passe
        ->isNotEqualTo('a')     // échoue

    ->variable($aString)
        ->isNotEqualTo($a)      // échoue
;

Avertissement

isNotEqualTo ne teste pas le type de la variable.

Si vous souhaitez vérifier également son type, utilisez isNotIdenticalTo.

6.26.6. isNotIdenticalTo

isNotIdenticalTo vérifie que la variable n’a ni le même type ni la même valeur qu’une certaine donnée.

Dans le cas d’objets, isNotIdenticalTo vérifie que les données ne pointent pas sur la même instance.

<?php
$a = '1';

$this
    ->variable($a)
        ->isNotIdenticalTo(1)           // passe
;

$stdClass1 = new \StdClass();
$stdClass2 = new \StdClass();
$stdClass3 = $stdClass1;

$this
    ->variable($stdClass1)
        ->isNotIdenticalTo(stdClass2)   // passe
        ->isNotIdenticalTo(stdClass3)   // échoue
;

Avertissement

isNotIdenticalTo teste le type de la variable.

Si vous ne souhaitez pas vérifier son type, utilisez isNotEqualTo.

6.26.7. isNull

isNull vérifie que la variable est nulle.

<?php
$emptyString = '';
$null        = null;

$this
    ->variable($emptyString)
        ->isNull()              // échoue
                                // (c'est vide, mais pas null)

    ->variable($null)
        ->isNull()              // passe
;

6.26.8. isNotNull

isNotNull vérifie que la variable n’est pas nulle.

<?php
$emptyString = '';
$null        = null;

$this
    ->variable($emptyString)
        ->isNotNull()           // passe (c'est vide, mais pas null)

    ->variable($null)
        ->isNotNull()           // échoue
;

6.26.9. isNotTrue

isNotTrue vérifie que la variable n’est strictement pas égale à true.

<?php
$true  = true;
$false = false;
$this
    ->variable($true)
        ->isNotTrue()     // échoue

    ->variable($false)
        ->isNotTrue()     // passe
;

6.26.10. isNotFalse

isNotFalse vérifie que la variable n’est strictement pas égale à false.

<?php
$true  = true;
$false = false;
$this
    ->variable($false)
        ->isNotFalse()     // échoue

    ->variable($true)
        ->isNotFalse()     // passe
;

6.27. Asserter & assertion trucs et astuces

Plusieurs trucs et astuces sont disponibles pour les assertions. Les connaître peuvent simplifier votre vie  ;)

Le premier est que chaque assertion est fluent (chaînable). Donc vous pouvez les enchaîner, il suffit de regarder les exemples précédents.

Vous devez également savoir que toutes les assertions sans paramètres peuvent être écrites avec ou sans parenthèses. Donc $this->integer(0)->isZero() est la même chose que $this->integer(0)->isZero.

6.27.1. Alias

Parfois, vous voulez utiliser quelque chose qui reflètent votre vocabulaire ou votre domaine. atoum fournis un mécanisme simple, les alias. En voici un exemple :

<?php
namespace tests\units;

use mageekguy\atoum;

class stdClass extends atoum\test
{
    public function __construct(adapter $adapter = null, annotations\extractor $annotationExtractor = null, asserter\generator $asserterGenerator = null, test\assertion\manager $assertionManager = null, \closure $reflectionClassFactory = null)
    {
        parent::__construct($adapter, $annotationExtractor, $asserterGenerator, $assertionManager, $reflectionClassFactory);

        $this
            ->from('string')->use('isEqualTo')->as('equals')
        ;
    }

    public function testFoo()
    {
        $this
            ->string($u = uniqid())->equals($u)
        ;
    }
}

Dans cet exemple, nous créons un alias pour faire un nouvel asserter equal```qui agira de la même manière que ``isEqualTo. Vous pouvez utiliser beforeTestMethod à la place du constructeur. Afin de partager ces alias entre les différents tests, le mieux est de créer une classe de base pour vos tests à l’intérieur de votre projet que vous pourrez étendre à la place \atoum\test.

6.27.2. Asserter personnalisé

Maintenant que nous avons vu alias, nous pouvons aller plus loin en créant un asserter personnalisé. Voici un exemple d’un asserter pour carte de crédit.

<?php
namespace tests\units;
use mageekguy\atoum;

class creditcard extends atoum\asserters\string
{
    public function isValid($failMessage = null)
    {
        return $this->match('/(?:\d{4}){4}/', $failMessage ?: $this->_('%s is not a valid credit card number', $this));
    }
}

class stdClass extends atoum\test
{
    public function __construct(adapter $adapter = null, annotations\extractor $annotationExtractor = null, asserter\generator $asserterGenerator = null, test\assertion\manager $assertionManager = null, \closure $reflectionClassFactory = null)
    {
        parent::__construct($adapter, $annotationExtractor, $asserterGenerator, $assertionManager, $reflectionClassFactory);

        $this->getAsserterGenerator()->addNamespace('tests\units');
    }

    public function testFoo()
    {
        $this
            ->creditcard('4444555566660000')->isValid()
        ;
    }
}

Tout comme pour un alias, il est conseillé de créer une classe de base pour vos tests et déclarer l’asserter personnalisé à cet endroit.

6.27.3. Syntaxe courte

Avec un alias vous pouvez définir plusieurs choses intéressantes. Afin de vous aider dans la rédaction de vos tests, plusieurs alias sont disponibles nativement.

• == est la même chose que l’asserter isEqualTo
• === est la même chose que l’asserter isIdenticalTo
• != est la même chose que l’asserter isNotEqualTo
• !== est la même chose que l’asserter isNotIdenticalTo
• < est équivalent à isLessThan
• <= est la même chose que l’asserter isLessThanOrEqualTo
• > est la même chose que l’asserter isGreaterThan
• >= est la même chose que l’asserter isGreaterThanOrEqualTo

<?php
namespace tests\units;

use atoum;

class stdClass extends atoum
{
    public function testFoo()
    {
        $this
            ->variable('foo')->{'=='}('foo')
            ->variable('foo')->{'foo'} // équivalent à la ligne précédente
            ->variable('foo')->{'!='}('bar')

            ->object($this->newInstance)->{'=='}($this->newInstance)
            ->object($this->newInstance)->{'!='}(new \exception)
            ->object($this->newTestedInstance)->{'==='}($this->testedInstance)
            ->object($this->newTestedInstance)->{'!=='}($this->newTestedInstance)

            ->integer(rand(0, 10))->{'<'}(11)
            ->integer(rand(0, 10))->{'<='}(10)
            ->integer(rand(0, 10))->{'>'}(-1)
            ->integer(rand(0, 10))->{'>='}(0)
        ;
    }
}