Dans les tests logiciels, mock vs stub sont deux types populaires de doubles de tests utilisés pour simuler les dépendances. Ils aident à isoler le comportement d'un composant en remplaçant les dépendances réelles par des substituts contrôlés lors des tests. Bien que les simulations et les stubs aient des objectifs similaires, ils sont utilisés différemment en fonction du type de scénario de test.
Cet article approfondit les principales différences entre les simulations et les stubs, leurs cas d'utilisation et quand les utiliser dans votre stratégie de test.

Qu'est-ce qu'un test double ?
Un double de test est un terme générique désignant tout objet ou composant utilisé pour remplacer une dépendance réelle lors du test. L'objectif est d'isoler le composant testé et de supprimer les facteurs externes susceptibles d'affecter le résultat du test. Les simulations et les stubs sont deux types de tests doubles, souvent utilisés dans les tests unitaires et d'intégration.

Qu'est-ce qu'un talon ?
Un stub est un double de test qui renvoie des données prédéfinies lorsqu'il est appelé par le composant testé. Il est généralement utilisé lorsque le composant testé nécessite l’entrée d’une dépendance, mais que le comportement réel de la dépendance n’a pas d’importance pour le résultat du test. Les stubs fournissent des réponses contrôlées, vous permettant de vous concentrer uniquement sur la logique interne du composant.

Exemple de stub :
Disons que vous testez une fonction de traitement des paiements. Au lieu d'appeler une véritable passerelle de paiement, vous utilisez un stub qui renvoie toujours une réponse « paiement réussi », garantissant que la logique de la fonction peut être testée indépendamment.

const paymentGatewayStub = {
  processPayment: () => "payment successful"
};

function processOrder(paymentService) {
  const result = paymentService.processPayment();
  return result === "payment successful" ? "Order Complete" : "Order Failed";
}

// Test
console.log(processOrder(paymentGatewayStub));  // Output: "Order Complete"

Dans ce cas, le stub garantit que le service externe renvoie toujours le résultat attendu, ce qui facilite le test de la logique interne.

Qu'est-ce qu'une simulation ?
Une simulation est un double de test qui non seulement fournit de fausses données, mais vérifie également les interactions entre les composants. Les simulations permettent de garantir que les méthodes correctes sont appelées avec les bons paramètres et que la séquence d'événements souhaitée se produit pendant l'exécution. Ils sont généralement utilisés lorsque le comportement ou l'interaction du composant est important pour le test.
Exemple de simulation :
En utilisant le même exemple de paiement, disons que vous souhaitez vérifier que la méthode processPayment() est appelée exactement une fois lors du traitement de la commande.

const paymentGatewayMock = {
  processPayment: jest.fn().mockReturnValue("payment successful")
};

function processOrder(paymentService) {
  paymentService.processPayment();  
}

// Test
processOrder(paymentGatewayMock);
expect(paymentGatewayMock.processPayment).toHaveBeenCalledTimes(1);

Dans ce cas, le mock vérifie l'interaction en vérifiant si la méthode a été appelée, garantissant ainsi que le composant se comporte correctement lors de l'exécution.
Principales différences entre la simulation et le stub
Aspect Mock Stub
Objectif Vérifie les interactions entre les composants Fournit des réponses prédéfinies
Comportement Valide les appels de méthode et les paramètres Renvoie uniquement les données statiques
Scénario d'utilisation Utilisé lorsque l'interaction est importante Utilisé lorsque la sortie de données est suffisante
Complexité Plus complexe à mettre en œuvre Plus simple à créer
Exemple d'appels de méthode de vérification de test Logique de test avec réponses fixes

Quand utiliser un stub
• Test de logique simple : utilisez un stub lorsque vous avez uniquement besoin de contrôler la sortie d'une dépendance.
• Tests basés sur les données : si l'objectif est de tester le comportement de votre composant avec des données spécifiques, les stubs sont plus adaptés.
• Exemple de cas d'utilisation : si vous testez une fonctionnalité de connexion qui nécessite des données utilisateur provenant d'une base de données, utilisez un stub pour renvoyer un utilisateur factice sans appeler la base de données réelle.
Quand utiliser une simulation
• Tests basés sur les interactions : si l'objectif est de garantir que les méthodes correctes sont appelées avec les bons paramètres, utilisez une simulation.
• Test d'interactions complexes : les simulations sont idéales pour les composants qui interagissent avec plusieurs services ou API.
• Exemple de cas d'utilisation : si vous testez un service d'envoi d'e-mails, utilisez une simulation pour vérifier que la fonction sendEmail() a été appelée avec le destinataire et le message attendus.
Les simulations et les talons peuvent-ils être utilisés ensemble ?
Oui, dans certains cas, des simulations et des stubs sont utilisés ensemble dans le même test pour obtenir à la fois une validation d'interaction et des réponses contrôlées. Par exemple, vous pouvez utiliser un stub pour renvoyer des données spécifiques et une simulation pour vérifier qu'un service particulier a été appelé.
Avantages et inconvénients des simulations et des talons
Avantages des talons :
• Simple et facile à mettre en œuvre
• Utile pour tester la logique des composants de manière isolée
Inconvénients des talons :
• Impossible de valider les appels de méthode ou les paramètres
• Limité aux réponses statiques
Avantages des simulations :
• Vérifie le comportement, les interactions et les séquences
• Utile pour les scénarios complexes avec plusieurs dépendances
Inconvénients des simulations :
• Nécessite plus de configuration et peut rendre les tests plus difficiles à lire
• Peut conduire à des tests fragiles s'il n'est pas utilisé avec précaution
Mock vs Stub : lequel devriez-vous utiliser ?
• Si votre test dépend du résultat d'une dépendance et que vous souhaitez contrôler ce résultat, utilisez un stub.
• Si vous devez vérifier qu'une méthode a été appelée ou valider les interactions entre les composants, utilisez une simulation.
• Pour les tests unitaires, les stubs sont plus couramment utilisés car l'accent est mis sur le test de la logique interne.
• Pour les tests d'intégration, les simulations sont plus utiles pour vérifier la manière dont les différentes parties du système interagissent.

Conclusion
Les simulations et les stubs jouent un rôle essentiel dans les stratégies de test, mais chacun remplit un objectif différent. Alors que les stubs contrôlent les données renvoyées par une dépendance, les simulations garantissent que les interactions correctes se produisent entre les composants. Comprendre quand et comment utiliser chacun peut améliorer la qualité de vos tests, conduisant à un logiciel plus fiable. En appliquant correctement les simulations et les stubs, les équipes peuvent réduire les bogues, accélérer le développement et créer de meilleures stratégies de test pour les tests unitaires et d'intégration.