3 février 2025

Faire des tests indépendant et plus rapide

par admin PHP, Symfony 0 Commentaires

Comprendre les Dummy, Stub, Mock, Fake et Spy en tests automatisés

Introduction

Résumé : Ce document explique les rôles, différences, et cas d’utilisation des Dummy, Stub, Mock, Fake, et Spy dans les tests automatisés.
Contexte : Ces outils, appelés “doubles de tests”, sont essentiels pour isoler les composants à tester dans un environnement contrôlé. Ils sont particulièrement utiles dans les tests unitaires et d’intégration pour simuler des dépendances.
Audience : Ce guide s’adresse aux développeurs qui souhaitent écrire des tests robustes en Symfony (ou PHP en général) et mieux comprendre le fonctionnement des doubles de tests.

Détails

Description générale

Un “double de test” est un objet utilisé dans les tests pour remplacer une dépendance réelle d’un composant. Ces doubles simulent les comportements nécessaires sans impliquer la véritable implémentation.

Les cinq principaux types de doubles sont :

Dummy : Remplit une méthode ou un constructeur sans être utilisé.
Stub : Fournit des valeurs prédéfinies en réponse à des appels.
Mock : Vérifie les interactions avec une dépendance.
Fake : Fournit une implémentation simplifiée fonctionnelle.
Spy : Capture les interactions pour inspection après exécution.

Liste des types de doubles

1. Dummy

Rôle : Un Dummy est un objet factice utilisé uniquement pour satisfaire les paramètres requis d’une méthode ou d’un constructeur. Il n’est jamais réellement utilisé dans l’exécution du test.
Usage principal : Fournir une dépendance sans importance pour le test en cours.

Exemple concret :

Imaginez une classe OrderProcessor qui prend un LoggerInterface comme dépendance. Si votre test n’a pas besoin de vérifier les interactions avec le logger, vous pouvez utiliser un Dummy.

public function testProcessOrder(): void {
$dummyLogger = $this->createMock(LoggerInterface::class); // Le logger n'est pas utilisé.

$processor = new OrderProcessor($dummyLogger);
$result = $processor->process($order);

$this->assertTrue($result);
}

public function testProcessOrder(): void {

$dummyLogger = $this->createMock(LoggerInterface::class); // Le logger n'est pas utilisé.

$processor = new OrderProcessor($dummyLogger);

$result = $processor->process($order);

$this->assertTrue($result);

}

2. Stub

Rôle : Un Stub est un objet simulé qui remplace une dépendance en fournissant des retours prédéfinis lorsqu’une méthode spécifique est appelée.
Usage principal : Simuler des retours de données ou des comportements nécessaires pour exécuter un test.
Différence avec un Dummy : Contrairement à un Dummy, un Stub influence l’exécution du test en retournant des valeurs configurées.

Exemple concret :

Imaginez un service UserService qui dépend d’un UserRepositoryInterface. Si vous souhaitez tester uniquement la logique du service sans interagir avec la base de données, vous pouvez utiliser un Stub.

public function testGetUserData(): void {
$stubRepository = $this->createStub(UserRepositoryInterface::class);
$stubRepository->method('find')->willReturn(['id' => 1, 'name' => 'Stub User']);

$service = new UserService($stubRepository);
$result = $service->getUserData(1);

$this->assertEquals(['id' => 1, 'name' => 'Stub User'], $result);
}

public function testGetUserData(): void {

$stubRepository = $this->createStub(UserRepositoryInterface::class);

$stubRepository->method('find')->willReturn(['id' => 1, 'name' => 'Stub User']);

$service = new UserService($stubRepository);

$result = $service->getUserData(1);

$this->assertEquals(['id' => 1, 'name' => 'Stub User'], $result);

}

3. Mock

Rôle : Un Mock est un objet simulé qui, en plus de pouvoir fournir des retours, permet de vérifier les interactions avec lui. Vous pouvez configurer des attentes spécifiques sur les méthodes appelées, leurs arguments, et même le nombre d’appels.
Usage principal : Tester les comportements (c’est-à-dire les interactions entre objets), pas seulement les résultats.
Différence avec un Stub : Un Stub se concentre sur les retours prédéfinis, tandis qu’un Mock permet de vérifier que certaines méthodes ont été appelées avec les bons arguments.

Exemple concret :

Imaginez que vous voulez vérifier qu’un service NotificationService envoie bien un email en appelant une méthode sur un objet MailerInterface. Un Mock est idéal pour cela.

public function testSendNotification(): void {
$mockMailer = $this->createMock(MailerInterface::class);
$mockMailer->expects($this->once()) // Vérifie que la méthode est appelée une seule fois
->method('send')
->with($this->isInstanceOf(Email::class)); // Vérifie que l'argument est bien de type Email.

$service = new NotificationService($mockMailer);
$service->notify(new User('user@example.com'));
}

public function testSendNotification(): void {

$mockMailer = $this->createMock(MailerInterface::class);

$mockMailer->expects($this->once()) // Vérifie que la méthode est appelée une seule fois

->method('send')

->with($this->isInstanceOf(Email::class)); // Vérifie que l'argument est bien de type Email.

$service = new NotificationService($mockMailer);

$service->notify(new User('user@example.com'));

}

4. Fake

Rôle : Un Fake est une implémentation simplifiée, mais fonctionnelle, d’une dépendance réelle. Il inclut une logique interne pour simuler un comportement réaliste, comme le stockage en mémoire.
Usage principal : Remplacer une dépendance réelle (ex. : base de données, API) par une version légère pour permettre des tests d’intégration réalistes.

Exemple :

class InMemoryUserRepository implements UserRepositoryInterface {
    private $users = [];
    
    public function save(User $user): void {
        $this->users[$user->getId()] = $user;
    }

    public function find(int $id): ?User {
        return $this->users[$id] ?? null;
    }
}

// Test avec un Fake Repository
public function testFindUserWithFake(): void {
    $fakeRepository = new InMemoryUserRepository();
    $fakeRepository->save(new User(1, 'Fake User'));

    $service = new UserService($fakeRepository);
    $user = $service->getUserData(1);

    $this->assertEquals('Fake User', $user->getName());
}

class InMemoryUserRepository implements UserRepositoryInterface {

private $users = [];

public function save(User $user): void {

$this->users[$user->getId()] = $user;

}

public function find(int $id): ?User {

return $this->users[$id] ?? null;

}

// Test avec un Fake Repository

public function testFindUserWithFake(): void {

$fakeRepository = new InMemoryUserRepository();

$fakeRepository->save(new User(1, 'Fake User'));

$service = new UserService($fakeRepository);

$user = $service->getUserData(1);

$this->assertEquals('Fake User', $user->getName());

}

5. Spy

Rôle : Un Spy est un double de test qui capture les interactions avec une dépendance (méthodes appelées, arguments, nombre d’appels) pour les inspecter après l’exécution du test. Contrairement au mock, si une méthode n’est pas appelé, le test peux focntionner.
Usage principal : Vérifier que certaines interactions (comportements) ont eu lieu pendant le test.

Exemple :

class SpyMailer implements MailerInterface {
    private array $sentEmails = [];

    public function send(Email $email): void {
        $this->sentEmails[] = $email;
    }

    public function getSentEmails(): array {
        return $this->sentEmails;
    }
}

// Test avec un Spy
public function testSpyMailer(): void {
    $spyMailer = new SpyMailer();

    $service = new NotificationService($spyMailer);
    $service->notify(new User('user@example.com'));

    $this->assertCount(1, $spyMailer->getSentEmails());
    $this->assertEquals('user@example.com', $spyMailer->getSentEmails()[0]->getRecipient());
}

class SpyMailer implements MailerInterface {

private array $sentEmails = [];

public function send(Email $email): void {

$this->sentEmails[] = $email;

}

public function getSentEmails(): array {

return $this->sentEmails;

}

// Test avec un Spy

public function testSpyMailer(): void {

$spyMailer = new SpyMailer();

$service = new NotificationService($spyMailer);

$service->notify(new User('user@example.com'));

$this->assertCount(1, $spyMailer->getSentEmails());

$this->assertEquals('user@example.com', $spyMailer->getSentEmails()[0]->getRecipient());

}

Résumé des différences Dummy, Stub et Mock

Type	Objectif	Impact sur le test	Usage typique
Dummy	Satisfaire des dépendances sans importance.	Aucun impact sur le comportement ou le résultat.	Remplir un argument ou un constructeur inutilisé.
Stub	Fournir des retours prédéfinis.	Influence les retours pour exécuter le test.	Simuler une base de données ou une API externe.
Mock	Vérifier les interactions avec une dépendance.	Contrôle les comportements attendus.	Vérifier qu’une méthode est appelée correctement.

En résumé, choisissez :

Dummy pour des dépendances sans impact.
Stub pour des retours simulés.
Mock pour valider des interactions et comportements spécifiques.

Résumé des différences Fake, Spy

Aspect	Fake	Spy
Simplicité	Contient une logique simplifiée.	Enregistre uniquement les interactions.
Impact sur le test	Simule un comportement fonctionnel.	Vérifie les interactions et comportements.
Usage principal	Fournir une alternative légère à une dépendance réelle.	Inspecter les appels après exécution.
Exécution	Fournit un comportement réaliste simulé.	Agit comme une “boîte noire” qui capture les interactions.
Exemple d’usage	Remplacer un repository ou une base de données.	Vérifier les appels à un service tiers.

Conséquences et recommandations

Impacts attendus

Tests plus isolés : Les doubles de tests permettent de tester un composant sans dépendre de sa véritable infrastructure.
Performance accrue : En remplaçant des services lourds ou externes, les tests s’exécutent plus rapidement.
Débogage facilité : Les erreurs sont localisées plus précisément grâce à l’isolation.

Points d’attention

Ne pas abuser des mocks : Trop de mocks peuvent rendre les tests difficiles à maintenir et sensibles aux changements de code.
Savoir choisir le bon double : Chaque type de double a un usage spécifique. Utilisez-les de manière appropriée pour éviter de compliquer inutilement vos tests.
Documenter vos fakes : Si vous créez une implémentation Fake, documentez clairement ses limitations pour éviter de fausses hypothèses.

Ressources supplémentaires

Documentation connexe

Outils recommandés

PHPUnit : Principal framework pour écrire des tests en PHP.
Prophecy : Outil pour créer des doubles de tests plus expressifs.

Tags:mock, PHP, Symfony, test

A propos de l'autheur

Jérémy

Chef de projet informatique spécialisé dans le domaine du web depuis plusieurs années et référent technique. En veille permanente, je me tiens à jour sur les nouveautés et évolutions afin de pouvoir réfléchir aux meilleurs outils à utiliser en fonction du besoin. De nature autonome et calme, j’aime travailler avec une équipe qui sait se remettre en question et qui cherche la solution la plus adéquate en fonction du problème et des délais imparties.

Programmation web

Faire des tests indépendant et plus rapide

Comprendre les Dummy, Stub, Mock, Fake et Spy en tests automatisés

Introduction

Détails

Description générale

Liste des types de doubles

1. Dummy

2. Stub

3. Mock

4. Fake

5. Spy

Résumé des différences Dummy, Stub et Mock

Résumé des différences Fake, Spy

Conséquences et recommandations

Impacts attendus

Points d’attention

Ressources supplémentaires

Documentation connexe

Outils recommandés

A propos de l'autheur

Jérémy

Ajouter un commentaire

Comprendre les Dummy, Stub, Mock, Fake et Spy en tests automatisés

Introduction

Détails

Description générale

Liste des types de doubles

1. Dummy

2. Stub

3. Mock

4. Fake

5. Spy

Résumé des différences Dummy, Stub et Mock

Résumé des différences Fake, Spy

Conséquences et recommandations

Impacts attendus

Points d’attention

Ressources supplémentaires

Documentation connexe

Outils recommandés

Articles similaire

A propos de l'autheur

Jérémy

Ajouter un commentaire