Qu'est-ce qu'un «stub»?

Donc, dans le prolongement de ma résolution du nouvel an pour obtenir plus de TDD, je commence maintenant à travailler davantage avec Rhino Mocks .

Une chose que je tiens à faire est de m'assurer de vraiment comprendre ce dans quoi je m'engage, alors je voulais vérifier ma compréhension de ce que j'ai vu jusqu'à présent (et j'ai pensé que ce serait bien de le faire ici en tant que Ressource).

Qu'est-ce qu'un «stub»?

Martin Fowler a écrit un excellent article sur ce sujet. De cet article:

Meszaros utilise le terme Test Double comme terme générique pour tout type d'objet simulé utilisé à la place d'un objet réel à des fins de test. Le nom vient de la notion de Stunt Double dans les films. (L'un de ses objectifs était d'éviter d'utiliser un nom qui était déjà largement utilisé.) Meszaros a alors défini quatre types particuliers de double:

• Des objets factices sont transmis mais jamais réellement utilisés. Habituellement, ils sont simplement utilisés pour remplir les listes de paramètres.
• Les faux objets ont en fait des implémentations fonctionnelles, mais prennent généralement un raccourci qui les rend non adaptés à la production (une base de données en mémoire est un bon exemple).
• Les stubs fournissent des réponses standardisées aux appels effectués pendant le test, ne répondant généralement pas du tout à quoi que ce soit en dehors de ce qui est programmé pour le test. Les stubs peuvent également enregistrer des informations sur les appels, comme un stub de passerelle de messagerie qui se souvient des messages qu'il a «envoyés», ou peut-être seulement du nombre de messages qu'il «a envoyés».
• On parle ici de simulacres: des objets préprogrammés avec des attentes qui forment une spécification des appels qu'ils sont censés recevoir.

Pour le dire dans mes propres mots: les objets simulés «s'attendent» à ce que certaines méthodes soient appelées sur eux, et font généralement échouer un test unitaire si leurs attentes ne sont pas satisfaites. Les objets stub fournissent des réponses prédéfinies (et peuvent être générées automatiquement par des bibliothèques d'assistance), mais ne provoquent généralement pas directement l'échec du test unitaire. Ils sont généralement simplement utilisés pour que l'objet que vous testez obtienne les données dont il a besoin pour faire son travail.

Un «stub» est une implémentation d'une interface qui existe pour fournir des données / une réponse quelconque. Par exemple:

• un DataSet
• liste des utilisateurs
• un fichier Xml

Normalement, cela serait fourni par un autre service (que ce soit un service Web, une autre application, une base de données) mais afin d'améliorer la testabilité du code, les résultats sont "falsifiés".

Un avantage majeur de ceci est qu'il permet de faire des affirmations dans des tests unitaires basés sur les données attendues. Si des erreurs surviennent en raison d'erreurs de données, des tests peuvent être facilement ajoutés, un nouveau stub créé (répliquant l'erreur de données) et un code produit pour corriger l'erreur.

Les stubs diffèrent des Mocks en ce qu'ils sont utilisés pour représenter et tester l' état d'un objet, alors qu'un Mock teste son interaction .

Je crois que "stub" vient de STartUpBlock. il est utilisé pour faire référence à des parties de code qui sont générées automatiquement pour vous aider, le développeur, à démarrer.

Une «méthode de stub» ou «stub» est conçue pour être un code de démarrage ou un substitut temporaire à un code encore à développer. C'est un code intégré généré par un IDE. Les méthodes stub sont en fait des méthodes utilisées pour tester les méthodes d'une classe particulière. Il est utilisé en entrant des valeurs pour les variables locales dans vos méthodes de développement réelles et en vérifiant si la sortie est correcte. Il est important de trouver des bogues dans votre code.

J'ai récemment fait face à la question et j'ai reconnu que cette comparaison entre Stub et Driver est vraiment claire et utile:

Fondamentalement, les stubs et les pilotes sont des routines qui ne font rien d'autre que se déclarer et les paramètres qu'ils acceptent. Le reste du code peut alors prendre ces paramètres et les utiliser comme entrées.

+ --------- + ------------------------------- + ------- ------------------------ +
| | Stub | Chauffeur |
+ --------- + ------------------------------- + ------- ------------------------ +
| Type | Codes factices | Codes factices |
+ --------- + ------------------------------- + ------- ------------------------ +
| Utilisé dans | Intégration descendante | Intégration ascendante |
+ --------- + ------------------------------- + ------- ------------------------ +
| Objectif | Pour permettre le test de la tige | Pour permettre le test du bas |
| | niveaux du code, lorsque le | niveaux du code, lorsque le |
| | les niveaux inférieurs du code sont | les niveaux supérieurs du code sont |
| | pas encore développé. | pas encore développé. |
+ --------- + ------------------------------- + ------- ------------------------ +
| Exemple | A et B sont des composants. | A et B sont des composants. |
| | A ---> B | A ---> B |
| | | |
| | Un a été développé. | A doit encore être développé.
| | B doit encore être développé. | B a été développé. |
| | Par conséquent, stub est utilisé | Par conséquent, le pilote est utilisé |
| | à la place de B pour l'imiter. | à la place de A pour l'imiter |
| | | |
| | A ---> Stub | Pilote ---> B |
+ --------- + ------------------------------- + ------- ------------------------ +

De la différence entre le stub et le pilote

Après quelques recherches et sur la base des fichiers stub que j'ai rencontrés au cours de ma vie de codeur, je dirais qu'un fichier stub est juste un fichier qui contient tout ou partie de l'implémentation d'un fichier. Cela aide les développeurs à commencer à coder.