TDD et test unitaire
Ma compagnie est assez nouvelle pour tester notre code. J'ai lu sur TDD et des tests unitaires depuis un certain temps et je suis convaincu de leur valeur. J'ai tenté de convaincre notre équipe que TDD mérite d'apprendre et de changer nos mentalités sur la manière dont nous programmons, mais c'est une lutte. Ce qui m'amène à mes questions.
Il y en a beaucoup dans la communauté TDD qui sont très religieux sur la rédaction du test, puis le code (et je suis avec eux), mais pour une équipe qui lance le TDD, un compromis apporte toujours des avantages supplémentaires?
Je peux probablement réussir à obtenir l'équipe à rédiger des tests d'unité une fois que le code est écrit (peut-être comme une exigence de vérification du code) et que mon hypothèse est qu'il existe toujours de la valeur dans la rédaction de ces tests d'unités.
Quelle est la meilleure façon d'apporter une équipe en difficulté à TDD? Et échouer que cela vaut toujours la peine d'écrire des tests unitaires même s'il est après l'écriture du code?
ÉDITER
Ce que j'ai enlevé, c'est qu'il est important pour nous de démarrer des tests unitaires, quelque part dans le processus de codage. Pour ceux de l'équipe qui ramassent le concept, commencez à se déplacer davantage vers TDD et testez d'abord. Merci pour la contribution de chacun.
suivi
Nous avons récemment lancé un nouveau petit projet et une petite partie de l'équipe utilisée TDD, le reste a écrit des tests unitaires après le code. Après avoir envisagé la partie de codage du projet, ces tests de l'unité d'écriture après que le code a été surpris de voir les codeurs TDD déjà effectués et avec un code plus solide. C'était un bon moyen de gagner sur les sceptiques. Nous avons encore beaucoup de douleurs de croissance à venir, mais la bataille des testaments semble être terminée. Merci pour tous ceux qui ont offert des conseils!
Si l'équipe est floue à la mise en œuvre de TDD, mais ils ne créaient pas de tests d'unités avant ... puis commencez-les en créant des tests d'unité après l'écriture de leur code. Même des tests unitaires écrits après que le code vaut mieux que pas de tests d'unité!
Une fois qu'ils sont compétents à des tests unitaires (et tout ce qui est livré avec elle), vous pouvez alors travailler pour les obtenir pour créer d'abord les tests ... et le code seconde.
Il vaut toujours la peine d'écrire les tests de l'unité après l'écriture de code. C'est juste que parfois c'est souvent plus difficile parce que votre code n'a pas été conçu pour être testable et que vous avez peut-être surchargé.
Je pense qu'un bon moyen pragmatique d'apporter une équipe à TDD est de fournir la méthode alternative de "test-pendant le développement" en période de transition, ou éventuellement à long terme. Ils devraient être encouragés aux sections de code TDD qui leur semblent naturelles. Toutefois, dans les sections de code qui semblent difficiles à aborder le test - d'abord ou lors de l'utilisation d'objets prédéterminés par un processus ADR non agile, les développeurs peuvent recevoir la possibilité d'écrire une petite section du code, puis de rédiger des tests pour couvrir cette code et répétez ce processus. Écriture des tests de l'unité pour certains code immédiatement après avoir écrit que le code vaut mieux que ne pas écrire de tests unitaires du tout.
Il est préférable de mieux comprendre une couverture de test de 50% avec "Code d'abord, tester après" et une bibliothèque complétée à 100%, soit une couverture de test de 100% et une bibliothèque complète de 50% avec TDD. Après un certain temps, vos collègues développeurs, espérons-le que c'est divertissant et éducatif pour rédiger des tests pour tout le code public qu'ils écrivent, de sorte que TDD se fraya un chemin dans leur routine de développement.
Je viens de lire ceci sur un calendrier: "Chaque règle, exécutée à son maximum, devient ridicule ou même dangereuse." Donc, ma suggestion ne veut pas être religieuse à ce sujet. Chaque membre de votre équipe doit trouver un équilibre entre ce qu'ils se sentent "à droite" lorsqu'il s'agit de tester. De cette façon, chaque membre de votre équipe sera le plus productif (au lieu de, à la pensée, pourquoi dois-je écrire ce test STI **** ?? ").
Donc, certains tests sont meilleurs que nul, les tests après que le code est meilleur que peu de tests et de test avant que le code ne soit meilleur que après. Mais chaque étape a ses propres mérites et vous ne devriez pas froncer les sourcils sur des petits marches.
TDD est à propos de la conception! Donc, si vous l'utilisez, vous serez sûr d'avoir une conception testable de votre code, ce qui facilitera la tâche de rédiger vos tests. Si vous écrivez des tests une fois que le code est écrit, ils sont toujours précieux mais IMHO vous verrez le temps que vous n'aurez probablement pas de conception testable.
Une suggestion que je peux vous donner pour tenter de convaincre votre équipe d'adopter TDD utilise certaines des techniques décrites dans Changement sans peur: modèles d'introduction de nouvelles idées, par Mary Lynn Manns et Linda Rising .
S'ils sont nouveaux à tester que le code de test de démarrage de l'OMI qui ont déjà été écrits et diplômés lentement pour écrire des tests d'abord. Comme quelqu'un essayant d'apprendre TDD et de nouveaux tests unitaires, je l'ai trouvé un peu difficile de faire un 180 complet et de changer mon état d'esprit pour écrire des tests avant le code. L'approche que je prends est une sorte de mix 50-50 ; Lorsque je sais exactement ce que le code ressemblera, je vais écrire le code, puis écrivez un test pour le vérifier. Pour des situations où je ne suis pas totalement sûr, je vais commencer par un test et travailler mon chemin en arrière.
N'oubliez pas non plus qu'il n'y a rien de mal à écrire des tests pour vérifier le code, au lieu d'écrire du code pour satisfaire des tests. Si votre équipe ne veut pas aller à la route TDD, ne le forcez pas dessus.
Il ne fait aucun doute que les tests (premier, tandis que ou même après) sauveront votre bacon et amélioreront votre productivité et votre confiance. Je recommande l'adopter!
J'étais dans une situation similaire, parce que j'étais un développeur "noob", j'étais souvent frustré lorsqu'il travaillait sur le projet d'équipe par le fait qu'une contribution avait brisé la construction. Je ne savais pas si je devais blâmer ou même dans certains cas, qui à blâmer. Mais j'étais plus préoccupé que je faisais la même chose à mes collègues développeurs. Cette réalisation a ensuite motivé à adopter certaines stratégies TDD. Notre équipe a commencé à avoir des jeux stupides et de règles, comme vous ne pouvez pas rentrer à la maison jusqu'à ce que tous vos tests ne passe, ou si vous soumettez quelque chose sans test, vous devez acheter tout le monde "Beer/déjeuner/etc." et il a fait plus de plaisir à TDD.
C'est quelque chose que votre équipe devra avoir ses propres succès avec avant de commencer à le croire. Je vais rant de ma Nunit Epiphany pour quiconque se soucie:
Il y a environ 5 ans, j'ai découvert Nunit lorsque vous travaillez sur un projet. Nous avions presque terminé v1.0 et j'ai créé quelques tests juste pour essayer ce nouvel outil. Nous avons eu beaucoup de bugs (évidemment!) Parce que nous étions une nouvelle équipe, sur une date limite serrée, des attentes élevées (sons familiers?) Etc. Quoi qu'il en soit, nous avons 1,0 in 1,0 et commencé sur 1.1. Nous avons rétrégé l'équipe un peu et j'ai eu 2 devs qui m'ont assigné. J'ai fait une démo de 1 heure pour eux et je leur ai dit que tout ce que nous avons écrit devait avoir un cas de test avec elle. Nous avons constamment couru "derrière" le reste de l'équipe au cours du cycle de 1,1 Dev, car nous écrivions plus de code, les tests de l'unité. Nous avons fini par travailler plus mais voici le gain - lorsque nous avons finalement été testés, nous avions exactement 0 bugs dans notre code. Nous avons aidé tout le monde à déboguer et à réparer leurs bugs. Dans le postmortem, lorsque le nombre de bugs est apparu, il a attiré l'attention de tout le monde.
Je ne suis pas assez stupide pour penser que vous pouvez tester votre chemin au succès, mais je suis un véritable croyant en ce qui concerne les tests unitaires. Le projet a adopté Nunit et s'est rapidement étendu à la société pour tous les projets .NET à la suite d'un succès. La période totale de notre version V1.1 était de 9 semaines de développement, de sorte que ce n'était certainement pas un succès de toute la nuit. Mais à long terme, cela s'est avéré fructueux pour notre projet et la société que nous avons construite des solutions.
Eh bien, si vous n'écrivez pas les premiers tests, il n'est pas "testé", c'est juste des tests. Il a des avantages en soi et si vous avez déjà une base de code, l'ajout de tests est certainement utile, même si ce n'est pas TDD, mais simplement des tests.
Ecrire des tests d'abord consiste à se concentrer sur ce que le code devrait faire avant de l'écrire. Oui, vous avez également un test qui fait cela et c'est bon, mais certains peuvent soutenir que ce n'est même pas le point le plus important.
Ce que je ferais, c'est former l'équipe sur projets de jouets comme ceux-ci (voir codage de dojo, katas) à l'aide de TDD (si vous pouvez obtenir des programmeurs de TDD expérimentés pour participer à un tel atelier, ce serait encore mieux). Quand ils verront les avantages, ils utiliseront TDD pour le projet réel. Mais pendant ce temps, ne les forcez pas, ils ne voient pas le bénéfice qu'ils ne le feront pas correctement.
L'un des aspects les plus utiles des tests unitaires assure la poursuite de l'exactitude du code déjà de travail. Lorsque vous pouvez refacteur à volonté, laissez un IDE===== vous rappeler des erreurs de temps compilez, puis cliquez sur un bouton pour laisser vos tests surpasser toutes les erreurs d'exécution potentielles - arrivant parfois dans des blocs de code précédemment triviaux. , alors je pense que vous trouverez votre équipe à commencer à apprécier TDD. Donc, à commencer par tester le code existant est définitivement utile.
De plus, pour être émoussé, j'ai appris davantage sur la façon de rédiger un code testable en essayant de tester le code écrit que de commencer par TDD. Il peut être trop abstrait au début si vous essayez de penser à des contrats qui accompliront tous les deux l'objectif final et permettent de tester. Mais lorsque vous regardez le code et que vous pouvez dire "ce singleton ici gâte complètement l'injection de dépendance et fait des tests cela impossibles", vous commencez à développer une appréciation de quels modèles facilitent votre vie de test.
Si vous avez des sessions de conception avant de rédiger un code ou si vous devez produire un document de conception, vous pouvez ajouter des tests d'unité en tant que résultat tangible d'une session.
Cela pourrait ensuite servir de spécification de la manière dont votre code devrait fonctionner. Encouragez le jumelage sur la session de design, pour que les gens parlent de la manière dont quelque chose devrait fonctionner et ce qu'il devrait faire dans des scénarios donnés. Quels sont les cas de bord, avec des cas de test explicites pour eux afin que tout le monde sait ce qu'il va faire si un argument nulle est par exemple.
Une mise à part, mais [~ # ~] bdd [~ # ~ ~] aussi peut être d'intérêt
Vous pouvez trouver une certaine traction en montrant un exemple ou deux où TDD entraîne moins de code écrit - car vous n'échangeez que le code requis pour effectuer la passe de test, la tentation de la plaque d'or ou de s'engager dans Yagni est plus facile à résister. Le code que vous n'écrivez pas n'a pas besoin d'être maintenu, refactored, etc., il s'agit donc d'une "réelle économie" qui peut aider à vendre le concept de TDD.
Si vous pouvez manifester clairement la valeur en termes de temps, de coût, de code et de bugs enregistrés, vous trouverez peut-être que c'est une vente plus facile.
Un moyen puissant de découvrir les avantages de TDD est de faire une réécriture significative de certaines fonctionnalités existantes, peut-être pour des raisons de performance. En créant une suite de tests qui font un bon travail couvrant toutes les fonctionnalités du code existant, cela vous donne ensuite la confiance au refacteur au contenu de votre cœur, sans confiance que vos modifications sont sûres.
Notez que dans ce cas, je parle de tester les tests d'unité de conception ou de contrat qui testent les détails de la mise en œuvre ne conviendra pas ici. Mais à nouveau, TDD ne peut pas tester la mise en œuvre par définition, car elles sont censées être écrites avant la mise en œuvre.
Commencer à construire des cours de test Junit est le moyen de démarrer, pour le code existant, c'est le seul moyen de commencer. D'après mon expérience, il est très utile de créer des classes de test pour le code existant. Si la direction pense que cela investit trop de temps, vous pouvez proposer uniquement d'écrire des classes de test lorsque la classe correspondante se trouve contenant un bogue ou doit avoir besoin de nettoyage.
Pour le processus de maintenance, l'approche de l'équipe sur la ligne serait d'écrire des tests junit pour reproduire des bugs avant de les réparer, c'est-à-dire.
- bug est signalé
- créer une classe de test Junit si nécessaire
- ajouter un test qui reproduit le bug
- réparer votre code
- exécutez le test pour afficher le code actuel ne reproduit pas le bogue
Vous pouvez expliquer que par "documenter" des bugs de cette manière empêchera ces bugs de ramener plus tard. C'est un avantage que l'équipe peut expérimenter immédiatement.
Je l'ai fait dans de nombreuses organisations et j'ai trouvé le meilleur moyen d'obtenir TDD démarré et suivi consiste à configurer la programmation de paires. Si vous avez quelqu'un d'autre, vous pouvez compter sur ce qui connaît TDD, vous pouvez vous séparer et associer avec d'autres développeurs pour effectuer une programmation jumelée à l'aide de TDD. Sinon, je formerais quelqu'un qui vous aidera à le faire avant de le présenter au reste de l'équipe.
L'un des principaux obstacles avec des tests unitaires et en particulier de TDD est que les développeurs ne savent pas comment le faire, afin qu'ils ne puissent pas voir comment cela peut valoir leur temps. De plus, lorsque vous commencez par commencer, il est beaucoup plus lent et ne semble pas offrir des avantages. Cela vous fournit seulement des avantages que lorsque vous en êtes bon. En mettant en place des sessions de programmation appariées, vous pouvez rapidement obtenir des développeurs pour pouvoir l'apprendre rapidement et les bien plus rapidement. En outre, ils pourront y voir des avantages immédiats comme vous le travailliez.
Cette approche a travaillé plusieurs fois pour moi dans le passé.
TDD est un outil que les développeurs peuvent utiliser pour produire un meilleur code. J'arrive à sentir que l'exercice de la rédaction de code testable est le moins aussi précieux que les tests eux-mêmes. Isolant l'IUT (la mise en œuvre sous test) à des fins de test a l'incidence secondaire du découplage de votre code.
TDD n'est pas pour tout le monde, et il n'y a pas de magie qui obtiendra une équipe à choisir de le faire. Le risque est que les écrivains de test unitaire qui ne savent pas ce que la peine d'être testé écrira beaucoup de tests de faible valeur, ce qui sera du fourrage de canon pour les sceptiques TDD de votre organisation.
Je fais habituellement automatiquement tests d'acceptation non négociables, mais permettent aux développeurs d'adopter TDD comme cela leur convient. J'ai mon entraînement/mentor de Tdders expérimentés le reste et "prouver" l'utilité par exemple sur une période de plusieurs mois.
C'est autant un changement social/culturel que celui-ci.