Qu’est-ce le stub, le dummy, le fake, le spy et le mock ?

Voici un petit article pour simplifier la compréhension de termes fréquemment rencontrés dans le monde du développement agile : le stub, le dummy, le mock, le fake et le spy.

Cet article a pour but de bien comprendre ces 5 éléments de tests mais n’a pas pour vocation de vous apprendre tous les détails techniques de ceux-ci. N’hésitez pas à vous référer à d’autres articles sur le sujet après la lecture de cet article si vous voulez entrer encore plus dans le détail.

Méthodes de doublure de tests

Les stub, dummy, mock, fake et spy sont des méthodes pour réaliser ce qu’on appelle vulgairement des doublures de tests. Elles ont pour but de faire croire au code que la classe appelée existe en appelant une classe de doublure vide.

Ils peuvent être utilisés lors de l’utilisation des tests unitaires ou dans d’autres cas un peu plus spécifiques ; ils seront donc d’une grande aide dans vos développements et surtout dans la mise en place d’une bonne excellence technique.

Qu’est-ce que le dummy ?

Le Dummy est la notion la plus simple des 5 que j’ai cité en introduction de cet article.

Son concept est de proposer une classe vide qui ne réagit pas et qu’on pourra utiliser quand on aura besoin d’instancier un objet dépendant de celle-ci. Ce Dummy n’a que pour but de faire croire qu’une classe existe à celle qu’on désire tester.

Voici un exemple de classe MonDummy :

<?php

interface MonInterface
{
    public function maFonctionUne();

    public function maFonctionDeux();
}

class MonDummy implements MonInterface
{
    public function maFonctionUne()
    {
        return null;
    }

    public function maFonctionDeux()
    {
        return null;
    }
}

Voici à présent un exemple où la mise en place d’un Dummy serait indispensable pour tester notre classe MaClasse :

<?php

class MaClasse
{
    private $dummy;

    public function __construct(MonInterface $dummy)
    {
        $this->dummy = $dummy;
    }

    public function getMyName()
    {
        return get_class($this);
    }
}

$classe = new MaClasse(new MonDummy());
$classe->getMyName();

En effet, c’est relativement simple à réaliser.

Qu’est-ce que le stub ?

Le Stub est très proche du Dummy sauf qu’il répond exactement ce qu’attend la classe appelante. Cela permet d’aller plus loin dans la simulation car on aura pas d’erreurs éventuelles d’un retour ‘null’.

<?php

interface MonInterface
{
    public function maFonctionUne();

    public function maFonctionDeux();
}

class MonStub implements MonInterface
{
    public function maFonctionUne()
    {
        return 'maFonctionUne';
    }

    public function maFonctionDeux()
    {
        return 'maFonctionDeux';
    }
}

Voici à prése

nt un exemple où la mise en place d’un Stub serait indispensable pour tester notre classe MaClasse :

<?php

class MaClasse
{
    private $stub;

    public function __construct(MonInterface $stub)
    {
        $this->stub = $stub;
    }

    public function getMyFunctionName()
    {
        return $this->stub->maFonctionDeux();
    }
}

$classe = new MaClasse(new MonStub());
$classe->getMyFunctionName();

En effet, ce concept reste relativement simple à mettre en place et peut s’avérer fort utile lors de vos tests.

Qu’est-ce que le fake ?

Si la notion du fake reste simple, il est plus complexe à mettre en place car il va falsifier des comportements attendus et pas seulement de simples résultats.

Vous pouvez par exemple l’utiliser pour créer une connexion en base de données sur une base de test afin de s’assurer d’insertions et de lectures fonctionnelles. Ce type d’implémentation prend beaucoup plus de temps que les deux premières car impose d’ajouter des notions métiers.

Voici un exemple simplifié qui présente un Fake :

class PDOFake
{
    private $PDO;

    public function __construct()
    {
        $this->PDO = new PDO('odbc:SAMPLE', 'test', 'test',
            array(PDO::ATTR_PERSISTENT => true));
    }

    public function query($request)
    {
        $sth = $this->PDO->prepare($request);
        $sth->execute();
        return $sth->fetchAll();
    }
}

$pdo = new PDOFake;
$result = $pdo->query($request);

Qu’est-ce que le Spy ?

Le Spy est en fait l’équivalent d’un Stub à l’exception qu’il va enregistrer des données complémentaires qui seront récupérables à la suite.

Voici l’exemple du Stub du début de l’article qu’on transforme en Spy :

<?php

interface MonInterface
{
    public function maFonctionUne();

    public function maFonctionDeux();
}

class MonStub implements MonInterface
{
    public function maFonctionUne()
    {
        return 'maFonctionUne';
    }

    public function maFonctionDeux()
    {
        $this->maDonneeEnregistree ='maFonctionDeux';
        return 'maFonctionDeux';
    }
}

Comme vous pouvez le voir on enregistre la donnée dans une variable interne de la classe.

Qu’est-ce que le Mock ?

Le Mock qui est l’un de ces 5 éléments les plus utilisés dans le monde du test permet de se substituer à l’implémentation de la classe originale. Il permet également de faire des levées d’exceptions et des vérification de comportement.

<?php

interface MonInterface
{
    public function maFonctionUne();

    public function maFonctionDeux();
}

class MonStub implements MonInterface
{
    public function maFonctionUne()
    {
        return 'maFonctionUne';
    }

    public function maFonctionDeux()
    {
        $this->maDonneeEnregistree = 'maFonctionDeux';
        return 'maFonctionDeux';
    }

    public function verification() {
        if ($this->maDonneeEnregistree == 'maFonctionDeux') {
            return true;
        } else {
            return false;
        }
}

Vous pourrez aller bien plus loin dans vos Mock mais cela vous montre une utilisation simplifiée pour bien comprendre l’intérêt de celui-ci.

Conclusion

Ces 5 éléments sont très utilises dans le monde du test et les connaitre est vraiment important que ce soit pour des coachs ou des développeurs. Utilisez-vous d’autres concepts similaires dans vos équipes ?