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

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

Indice

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

Indice

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

Indice

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

Indice

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.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

Indice

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

Indice

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

Indice

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

Indice

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')
;

Indice

L’asserter castToArray retourne une instance de l’assertion array. Vous pouvez donc utiliser toutes les méthodes de l’assertion 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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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. isInstanceOf

Indice

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.15. isNotEqualTo

Indice

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.16. isNotIdenticalTo

Indice

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

6.10.1. hasCode

hasMessage 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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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

Indice

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. generator

C’est l’asserter dédié aux tests sur les generateurs.

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

Example:

<?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 retourne 3 valeurs, et nous testons que la taille de ce générateur est bien 3.

6.13.1. yields

yields est utilisé pour tester facilement les valeurs retournées par le générateur. Chaque fois que vous appelez l’assertion ->yields, la prochaine valeur du générateur sera utilisée. Vous aurez alors la possibilité d’utiliser l’asserter de votre choix sur la valeur retournée (par exemple class, string or 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 cet exemple, nous créons un générateur qui retourne 3 valeurs : 1, 2 et 3. Puis, pour chaque valeur du générateur, nous exécutons un test pour vérifier le type et la valeur. Dans les 2 premiers tests, nous utilisons l’asserter variable pour vérifier uniquement la valeur. Dans le troisième test, nous ajoutons un tests sur la valeur en utilisant l’asserter integer (tous les asserters peuvent être utilisée sur cette valeur) avant de tester la valeur.

6.13.2. returns

Note

Cette méthode ne fonctionne que pour PHP >= 7.0.

Depuis la version 7.0 de PHP, les générateurs peuvent retourner une valeur finale, qui peux être récupérée via un appel à la méthode ->getReturn(). Lorsque vous utilisez l’assertion ->returns sur l’asserter generator, atoum vous permet d’exécuter des tests sur cette valeur de retour.

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 commençons par exécuter plusieurs vérifications sur les valeurs retournées. Puis, nous vérifions que la valeur de retour finale du générateur est bien un entier valant 42. Comme lors de l’utilisation de l’assertion ->yields, vous pouvez utiliser tous les asserters pour valider la valeur de retour.

6.13.3. Historique

Version Modifications
v3.0.0 Ajout de l’asserter generator.

6.14. hash

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

6.14.1. contains

Indice

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

6.14.2. isEqualTo

Indice

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

6.14.3. isEqualToContentsOfFile

Indice

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

6.14.4. isIdenticalTo

Indice

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

6.14.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.14.6. isNotEqualTo

Indice

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

6.14.7. isNotIdenticalTo

Indice

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

6.14.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.14.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.14.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.14.11. notContains

Indice

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

6.15. 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.15.1. isEqualTo

Indice

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.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.15.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.15.4. isIdenticalTo

Indice

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. 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.15.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.15.7. isNotEqualTo

Indice

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.8. isNotIdenticalTo

Indice

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.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.16. 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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.16.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.17. 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.17.1. hasDate

Indice

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

6.17.2. hasDateAndTime

Indice

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

6.17.3. hasDay

Indice

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

6.17.4. hasHours

Indice

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

6.17.5. hasMinutes

Indice

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

6.17.6. hasMonth

Indice

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

6.17.7. hasSeconds

Indice

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

6.17.8. hasTime

Indice

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

6.17.9. hasTimezone

Indice

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

6.17.10. hasYear

Indice

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

6.17.11. isCloneOf

Indice

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

6.17.12. isEqualTo

Indice

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

6.17.13. isIdenticalTo

Indice

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

6.17.14. isInstanceOf

Indice

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

6.17.15. isNotEqualTo

Indice

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

6.17.16. isNotIdenticalTo

Indice

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

6.18. 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.18.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.18.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.

Indice

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

6.18.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.18.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.18.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.

Indice

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

6.18.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.

Indice

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

6.18.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.

Indice

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.18.8. isInstanceOfTestedClass

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

6.18.9. isNotCallable

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

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

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

Indice

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

6.18.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.

Indice

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

6.18.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.

Indice

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

6.18.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.18.13. isNotTestedInstance

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

6.18.14. isTestedInstance

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

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

6.19. 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.19.1. contains

Indice

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

6.19.2. hasLength

Indice

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

6.19.3. hasLengthGreaterThan

Indice

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

6.19.4. hasLengthLessThan

Indice

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

6.19.5. isEmpty

Indice

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

6.19.6. isEqualTo

Indice

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.7. isEqualToContentsOfFile

Indice

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

6.19.8. isIdenticalTo

Indice

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.9. isNotEmpty

Indice

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

6.19.10. isNotEqualTo

Indice

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

Indice

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. matches

Indice

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

6.19.13. notContains

Indice

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

6.20. resource

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

6.20.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.20.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.20.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.21. 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.21.1. isEqualTo

Indice

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

6.21.2. isGreaterThan

Indice

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

6.21.3. isGreaterThanOrEqualTo

Indice

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

6.21.4. isIdenticalTo

Indice

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

6.21.5. isLessThan

Indice

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

6.21.6. isLessThanOrEqualTo

Indice

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

6.21.7. isNotEqualTo

Indice

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

6.21.8. isNotIdenticalTo

Indice

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

6.21.9. isZero

Indice

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

6.22. 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.22.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.22.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.22.3. isWrited

Indice

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

6.23. string

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

6.23.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.23.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.23.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.23.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.23.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.23.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.23.7. isEqualTo

Indice

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

6.23.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.23.9. isIdenticalTo

Indice

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

6.23.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.23.11. isNotEqualTo

Indice

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

6.23.12. isNotIdenticalTo

Indice

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

6.23.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.23.14. match

Indice

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

6.23.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.23.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.23.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.23.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.23.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.23.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

;

6.24. 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.24.1. contains

Indice

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

6.24.2. hasLength

Indice

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

6.24.3. hasLengthGreaterThan

Indice

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

6.24.4. hasLengthLessThan

Indice

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

6.24.5. isEmpty

Indice

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

6.24.6. isEqualTo

Indice

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.7. isEqualToContentsOfFile

Indice

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

6.24.8. isIdenticalTo

Indice

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.9. isNotEmpty

Indice

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

6.24.10. isNotEqualTo

Indice

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.11. isNotIdenticalTo

Indice

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.12. matches

Indice

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.24.13. notContains

Indice

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

6.25. variable

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

6.25.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.25.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.25.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.25.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.25.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.25.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.25.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.25.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.25.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.25.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.26. 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 toutes assertions sont 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.26.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.26.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.26.3. Syntaxe courte

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

<?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)
        ;
    }
}