Déplacement du code existant vers Test Driven Development

Question

Ayant récemment découvert cette méthode de développement, je me suis trouver une bonne méthodologie. Donc, pour mon premier projet, j'ai une petite DLL à la valeur de code (dans C#.NET pour ce que ça vaut), et je veux faire une série de tests pour ce code, mais je suis un peu perdu quant à savoir comment et par où commencer.

Je suis l'aide de NUnit, et VS 2008, tous les conseils sur ce genre de classes pour commencer, de quoi écrire des tests et des conseils sur la façon d'aller sur le déplacement de code à travers de test en fonction du développement serait grandement apprécié.

Answer 1

Voir le livre de Travailler de façon Efficace avec le Code existant par Michael Plumes.

En résumé, c'est beaucoup de travail de refactoriser le code existant dans vérifiés et testés code; Parfois, c'est trop de travail pour être pratique. Cela dépend de la taille de la base de code est, et combien les différentes classes et fonctions dépendent les uns des autres.

Refactoring sans tests d'introduire des changements dans les comportements (p. ex. des bugs). Et les puristes diront que ce n'est pas vraiment le refactoring, en raison de l'absence de tests afin de vérifier que le comportement ne change pas.

Plutôt que d'ajouter de test à travers le conseil d'administration à l'ensemble de votre demande à la fois, ajouter des tests lorsque vous travaillez dans une zone de code. Très probablement, vous aurez à revenir à ces "points chauds" de nouveau.

Ajouter des tests de bas en haut: test peu, indépendant des classes et des fonctions pour l'exactitude.

Ajouter des tests de haut en bas: Test ensemble de sous-systèmes, comme des boîtes noires de voir si son comportement change avec les changements dans le code. Et donc, vous pouvez les parcourir pour trouver ce qui se passe. Cette approche sera probablement que vous obtenez le plus d'avantages.

Ne pas être trop préoccupés d'abord de ce que le comportement "correct" est lors de l'ajout de tests, de chercher à détecter et à éviter les changements de comportement. Grand, non testés, souvent, les systèmes internes des comportements qui peuvent sembler incorrect, mais que d'autres parties du système dépendent.

Pensez à isoler les dépendances telles que la base de données, système de fichiers, réseau, de sorte qu'ils peuvent être permutées pour se moquer de fournisseurs de données en cours de test.

Si le programme ne dispose pas d'interfaces internes, des lignes qui définissent la frontière entre un sous-système ou de la couche et de l'autre, alors vous pourriez avoir à essayer d'introduire ces, et de tester chez eux.

Aussi, automatique se moquant de cadres comme Rhinomocks ou Moq peut aider à se moquer de classes existantes ici. Je n'ai pas vraiment trouvé la nécessité pour eux de code conçu pour la testabilité.

Answer 2

Je l'appelle "Test Driven Reverse Engineering".

Démarrer "en bas", chaque classe peut être examiné séparément et un test écrit pour elle. En cas de doute, deviner.

Quand vous faites ordinaire TDD dans le sens de la marche, vous traitez le test comme sacrée, et supposons que le code est probablement cassé. Parfois, le test est faux, mais votre départ en position off, c'est que c'est le code.

Quand vous faites TDRE, le code est sacré -- jusqu'à ce que vous pouvez prouver que le code dispose depuis longtemps d'un bug. Dans le cas inverse, vous écrivez des tests autour du code, le fait de modifier les tests jusqu'à ce qu'ils travaillent et demande le code fonctionne.

Ensuite, vous pouvez aller dans le mauvais code. Certaines mauvaises cade sera sensible des cas de test -- cette juste besoin d'être nettoyé. Certains mauvais code, cependant, auront également un cas de test qui est absurde. Cela peut être un bug, ou maladroit de conception que vous pouvez être en mesure de réparer.

Pour juger si le code est en fait mal, vous avez aussi besoin de commencer par le haut de l'ensemble des cas de test. Données réelles, ce qui fonctionne réellement est un début. Également des, données réelles, ce qui produit des bugs connus, aussi un bon endroit pour commencer.

J'ai peu écrit des générateurs de code pour transformer les données en direct dans unittest cas. De cette façon, j'ai une base cohérente pour les tests et le refactoring.

Answer 3

Travailler Efficacement avec le Code existant est ma bible quand il s'agit de la migration de code sans tests dans une unité éprouvées en matière d'environnement, et il fournit également un aperçu de beaucoup de ce qui rend le code facile à tester et comment le tester.

J'ai aussi trouvé Développement Piloté par les tests par Exemple et Pragmatique de l'Unité de Test: en C# avec NUnit pour être décent introduction aux tests unitaires dans cet environnement.

Une approche simple pour commencer TDD est de commencer à écrire les premiers tests à partir de ce jour et assurez-vous que toutes les fois que vous besoin de toucher votre existant (onu-unité-testé le code, vous écrivez passer des tests permettant de vérifier le comportement existant du système avant de le modifier, de sorte que vous pouvez ré-exécuter ces tests après à augmenter votre confiance, que vous n'avez rien de cassé.

Answer 4

De code de tests est facile à repérer par l'accompagnement des tests. Si il y en a, il doit être testable. Si il y a aucun supposer le contraire. ;)

Qui a dit: Développement Piloté par les tests (TDD) n'est pas tellement une stratégie de test car c'est une stratégie de conception. Les Tests que vous écrivez d'abord aider dans la conception de l'interface de vos classes, ainsi que dans l'obtention de la portée de votre classe (ou sous-systèmes) à droite.

Avoir les tests que vous avez créé lors de TDD et de les exécuter plus tard, fait de bons tests, mais est simplement une (très bienvenue) effet secondaire de cette conception de la philosophie.

Cela dit, s'attendre à une certaine résistance de votre code à l'encontre d'être testé. Écoutez votre code et de modifier l'interface afin d'être facilement testables. Vous aurez plus de chances de refonte, lorsque vous commencez à écrire des essais.

Answer 5

Votre DLL fournit une sorte de service. Pour chaque service, ce que vous avez à faire avant d'obtenir ce service, quels sont les paramètres si vous réussissez à obtenir ce service, comment sauriez-vous que le service demandé a être correctement exécuté ?

Une fois que vous avez les réponses à ces questions, vous pouvez écrire un premier essai. Ces tests serait plutôt appelé les tests de Caractérisation de tests unitaires, mais serait probablement plus facile à écrire qu'à l'unité-tests si la DLL n'a pas été développé à l'aide de TDD.

Les tests de caractérisation sont également discutés dans M. Plumes " "Travailler Efficacement avec le Code existant", ce qui est recommandé dans d'autres réponses.

Aussi, assurez-vous d'écrire un test en échec avant d'ajouter une nouvelle ligne de code.