Quelles sont les écoles de Londres et de Chicago de TDD?
J'ai entendu parler du style londonien contre le style de Chicago (parfois appelé style de Detroit) de Test Driven Development (TDD).
Atelier du groupe d'utilisateurs de programmation extrême de l'Utah:
Interaction-style TDD est aussi appelé mockist-style, ou London-style après le club Extreme Tuesday de Londres où il est devenu populaire. Il est généralement contrasté avec style Detroit ou classique TDD qui est plus basé sur l'état.
L'atelier couvre à la fois la école de Chicago de TDD (test de comportement basé sur l'état et triangulation), et la école de Londres, qui se concentre davantage sur les tests d'interaction, la moquerie et TDD de bout en bout, avec un accent particulier sur Conception axée sur la responsabilité et Dites, ne demandez pas approche de [~ # ~] oo [~ # ~] récemment re-popularisé par l'excellent logiciel de Steve Freeman et Nat Pryce Un logiciel orienté objet en croissance guidé par des tests livre.
Le message Classic TDD ou "London School"? par Jason Gorman a été utile, mais ses exemples m'ont dérouté, car il utilise deux exemples différents au lieu d'un exemple avec les deux approches. Quelles sont les différences? Quand utilisez-vous chaque style?
Supposons que vous ayez une classe appelée "ledger", une méthode appelée "calcul" qui utilise une "calculatrice" pour effectuer différents types de calculs en fonction des arguments passés à "calculer", par exemple "multiplier (x, y)" ou "soustraire ( x, y) ".
Supposons maintenant que vous vouliez tester ce qui se passe lorsque vous appelez ledger.calculate ("5 * 7").
L'école London/Interaction vous demanderait si Calculator.multiply (5,7) a été appelé. Les différents frameworks de simulation sont utiles pour cela, et cela peut être très utile si, par exemple, vous n'avez pas la propriété de l'objet "Calculatrice" (supposez que c'est un composant ou service externe que vous ne pouvez pas tester directement, mais vous le faites vous devez appeler d'une manière particulière).
L'école de Chicago/State voudrait que vous confirmiez si le résultat est 35. Les cadres jUnit/nUnit sont généralement orientés vers cela.
Les deux sont des tests valides et importants.
L'article Les moqueries ne sont pas des talons , de Martin Fowler est une bonne introduction au sujet.
Selon le style de conception que vous choisissez (et les principes de conception sur lesquels vous construisez vos programmes), il existe au moins deux façons de voir un objet:
- En tant qu'unité qui effectue des calculs basés sur des entrées. À la suite de ce calcul, l'objet peut renvoyer une valeur ou changer son état.
- En tant qu'élément actif qui communique avec d'autres éléments du système par passage de messages.
Dans le premier cas, vous êtes intéressé par ce qui sort du traitement ou dans quel état l'objet est laissé après ce traitement. C'est là que des méthodes telles que assertEquals() entrent dans l'image. Dans ce cas, peu importe quels autres objets ont été impliqués dans le traitement, quelles méthodes ont été appelées, etc. Ce type de vérification est appelé vérification basée sur l'état et est le style "classique".
Dans le second cas, puisque la plupart des objets ne renvoient même aucun résultat (par exemple les méthodes void en Java), vous êtes plus intéressé par la façon dont les objets communiquent entre eux et s'ils transmettent les bons messages dans les circonstances imposées par le test. Ces interactions sont généralement vérifiées à l'aide de cadres fictifs. Ce type de vérification est appelé vérification basée sur le comportement ou basée sur l'interaction. L'une de ses implications est la technique appelée Behavior Driven Development, par laquelle vous développez une classe en supposant que ses collaborateurs existent déjà (même s'ils n'existent pas encore), vous pouvez donc coder par rapport à leurs interfaces.
Notez que ce n'est pas un choix soit/ou. Vous pouvez avoir un style de conception qui mélange les deux approches pour tirer le meilleur parti de chacune.