Comment motiver ses collègues à écrire des tests unitaires?
Nous travaillons sur un grand produit qui est en production depuis environ 5 ans. La base de code est .. euh .. fonctionne. Pas vraiment bien mais ça marche. De nouvelles fonctionnalités sont mises en production et testées avec un petit contrôle qualité. Les bugs sont corrigés, etc. Mais personne, sauf moi, n'écrit des tests unitaires. Personne n'utilise le pouvoir de "traquer" les bogues en écrivant des tests unitaires pour s'assurer que ce bogue spécial (cas de test) ne se reproduira plus jamais.
J'ai parlé à la direction. J'ai parlé aux développeurs. J'ai parlé à tout le monde dans toute l'entreprise. Tout le monde dit: "Oui, nous devons écrire plus de tests unitaires!" C'était il y a environ un an. Depuis lors, j'ai forcé l'introduction de la révision du code pré-commit ( Gerrit ) et de l'intégration continue ( Jenkins ).
J'ai tenu quelques réunions sur les tests unitaires et j'ai également montré les avantages d'écrire des tests unitaires. Mais personne ne semble intéressé.
Q1: Comment puis-je motiver mes collègues à écrire des tests unitaires?
Q2: Comment puis-je rester motivé pour suivre mes normes de qualité de code personnel? (Parfois, c'est vraiment frustrant!)
PS: Quelques faits frustrants (atteints en 1 an):
- Total des tests unitaires: 1693
- Total "exemples de tests unitaires": environ 50
- Fait par moi: 1521
Edit: Est-ce que j'attends trop? C'est mon premier lieu de travail et j'essaie de faire de mon mieux.
Edit 2: Sur la base de toutes les réponses, je me suis fait une petite liste de contrôle. J'ai parlé à deux développeurs en privé et nous avons eu une bonne et honnête conversation.
L'un d'eux m'a dit, comme Telastyn a dit, qu'il était vraiment mal à l'aise avec les tests unitaires. Il a dit qu'il aimerait être "plus professionnel" mais qu'il a besoin d'un coup de pied. Il a également dit que notre réunion de test unitaire avec tous les développeurs (vers 9-11) était bonne, mais qu'elle était trop encombrée. Meh. Quelques critiques pour moi, mais j'apprendrai de cela. (voir les réponses ci-dessous pour les réunions de kata tdd!)
L'autre a dit qu'il n'était pas intéressé à écrire des tests unitaires. Il pense que son travail est assez bon pour son salaire. Il ne veut pas faire plus d'efforts. J'étais sans voix. 9-5 "travailleur" typique.
La semaine prochaine, je vais parler aux autres développeurs.
Merci pour vos excellentes réponses (jusqu'à présent!) Et votre soutien. J'apprécie vraiment cela! J'en ai beaucoup appris, merci beaucoup!
J'ai remarqué que parler de TDD ne marchait guère. Les gens aiment voir résultats bruts. Dire que "l'écriture de tests réduira le temps de développement" est probablement vrai, mais cela pourrait ne pas être suffisant pour convaincre quelqu'un.
J'étais dans une position similaire (enfin, pas aussi mauvaise que la vôtre), et cela s'est résolu en quelque sorte lorsque les gens ont commencé à travailler sur mon code (remarque: mon code a été testé à l'unité, d'autres pas tellement). Quand quelque chose a cessé de fonctionner, un suivi naturel après enquête locale a été de me demander quelle pourrait être la raison. Puis nous nous sommes assis, nous avons effectué des tests unitaires et vu ce qui s'est passé. Si les tests réussissaient, la plupart du temps les problèmes étaient dans le nouveau code non testé. Si ce n'est pas le cas, les tests ont généralement permis de détecter le problème (ou du moins de nous orienter dans la bonne direction). Nous avons corrigé le bug, les tests étaient à nouveau en place, tout le monde était content.
Pour faire court, quelques situations comme celle-ci se sont produites et 2 autres développeurs sont devenus des passionnés de TDD/testing (il en reste encore quelques-uns, mais cela semble prometteur).
Quant aux conseils, vous pouvez essayer le kata TDD; tâche simple à implémenter en utilisant une première approche de test par opposition à pas de tests. Selon la complexité de la tâche, l'approche non-test devrait généralement être plus lente, en particulier avec les modifications requises incrémentielles:
Edit : Le commentaire de OP m'a fait réaliser qu'il y avait un argument encore plus fort à sa disposition - régression aka renvoyant des bugs . Ce genre de situations sont des exemples parfaits démontrant à quel point les tests unitaires bénéfiques peuvent être. Les gens aiment les chiffres - comme je l'ai dit en disant "les tests unitaires sont bons" peut ne pas être convaincant, mais organiser les données comme ci-dessous pourrait sûrement être:
- temps consacré à l'implémentation de la fonctionnalité (aucun test n'a été écrit; je suppose que cela s'est produit souvent, il devrait donc être relativement facile de trouver un tel exemple)
- temps estimé pour implémenter la fonctionnalité avec TDD (ou même tests après approche; n'a pas d'importance - ce qui est important c'est la présence de tests unitaires)
- temps passé à résoudre le bug sur code non testé vs testé
Une chose à vous avertir (cette migration est évidente mais mérite d'être notée): biais de résultat - assurez-vous de ne pas sélectionner d'exemple où la seule façon de repérer un bogue avec test était d'écrire un test pour cela punaise. Habituellement, personne ne sait que le bug se produira d'avance, mais il est tentant de dire "mec, ce bug serait trivial si nous avions testé X" - il est facile de trouver une tactique gagnante pour une guerre après a fini.
Le résultat de ces exemples devrait être une question simple - si vous pouviez passer x heures à développer la fonctionnalité Y, pourquoi insister pour le faire en 2x?
Vous devez d'abord savoir pourquoi ils n'écrivent pas de tests.
Des horaires de développement serrés en sont souvent la raison, mais vous dites que vous n'en avez pas.
La raison suivante est qu'avec une grande base de code existante non testée, l'écriture de tests semble probablement écrasante - un travail sans fin (comme la lessive et à peu près aussi excitant). Donc, la nature humaine est de penser que c'est trop de choses à affronter, alors je vais sauter.
Une autre raison pourrait être que même s'ils pensent que les tests sont une bonne idée, ils ne savent pas comment commencer à les écrire, surtout s'ils n'ont jamais travaillé nulle part où ils les ont écrits.
Une autre possibilité forte est qu'ils ne voient vraiment aucune valeur pour plus de travail, même s'ils donnent du bout des lèvres l'idée.
Alors, comment gérez-vous les différentes raisons?
La première raison est simple, montrez-leur un exemple de la façon dont cela fait gagner du temps de développement.
Deuxième raison - montrez-leur combien de tests vous avez écrits dans une année et quel pourcentage de la base de code qu'il couvre. Faites le calcul pour montrer combien de tests supplémentaires ils pourraient avoir à la même période l'année prochaine s'ils le font. Une fois qu'ils voient que de petits progrès quotidiens s'additionnent vraiment, l'idée n'est plus si écrasante. Si vous pouvez extraire les données du système, montrez-leur combien de bogues étaient des bogues récurrents dans les parties non testées du code et combien de bogues récurrents apparaissent dans le code avec des tests unitaires.
La raison 3 est une formation, pas seulement une démonstration. Faites-leur passer des tests dans une classe de formation.
Raison 4, c'est le nœud du problème. Tout d'abord, choisissez un point douloureux, l'un de ces bogues qui est revenu plusieurs fois. Lorsque cela arrive, c'est le moment de suggérer à la direction que s'ils avaient des tests unitaires sur cet article, cela ne reviendrait pas comme un mauvais centime.
Une autre façon d'aborder la raison 4 est de demander à la direction de l'intégrer au processus et le code ne passe pas la revue de code à moins que les tests ne passent également la revue de code. Mieux vaut les approcher en en faisant une politique juste après l'un de ces points douloureux ou de préférence juste après en avoir eu plusieurs en quelques jours.
Nous aimons tous penser qu'en tant que développeurs, nous gérons nous-mêmes (LOL), mais les ambitieux se soucieront de ce que la direction leur soulignera et les professionnels qui font vraiment de l'autogestion écrivent déjà les tests. S'ils ne se soucient pas d'être professionnels et d'appliquer les meilleures pratiques parce qu'ils améliorent le produit ou se soucient d'impressionner les managers pour qu'ils soient promus (ou non licenciés), alors vous pourriez vous demander si c'est le bon endroit pour vous. Si vous ne parvenez pas à faire en sorte que la direction se soucie des meilleures pratiques, alors vous mènerez une bataille difficile tout le long et à nouveau, vous pourriez évaluer si c'est la bonne culture d'entreprise pour vous. Alors que chaque lieu de travail a ses problèmes (et s'enfuir n'est pas toujours la réponse), cet endroit ne semble pas correspondre à votre niveau de professionnalisme.
Je voudrais commencer en démontrant les avantages du TDD. Essayez de mettre en valeur les avantages des tests unitaires.
En tant qu'êtres humains normaux, les développeurs sont motivés par les avantages. Ils ne veulent pas faire des choses qui créent simplement plus de travail. Les tests unitaires signifient moins de travail . Cela signifie plus sortir avec des amis. Cela signifie avoir plus de plaisir car vous n'avez pas à passer chaque nuit à coder jusqu'à 23 heures. Cela signifie plus de partir en vacances en toute tranquillité.
L'un des plus grands avantages de TDD est que vous pouvez refactoriser votre programme pour une meilleure conception ou simplement changer le nom de quelque chose ... et aussi longtemps que que la conception ne brise pas les tests, vous pouvez être sûr à 100% que votre changement n'a rien cassé.
Un autre excellent cas pour TDD est la création de tests unitaires pour le code hérité . Cela représenterait l'une des meilleures façons de commencer à refactoriser le mal. À long terme, cela permettra d'améliorer votre connaissance de la base de code, de comprendre ses forces et ses défauts, de repérer la logique métier codée en dur dans le code et de vous donner un bon départ pour améliorer la qualité à l'avenir!
Bonnes références pour une lecture plus approfondie:
Cela semble être un gros cas de ( donner l'exemple .
Il y a deux aspects inhérents à la nature humaine que vous combattez:
- Les créatifs n'aiment pas le processus.
- La plupart des gens n'aiment pas les jugements négatifs externes sur leur qualité.
Il est très difficile de lutter contre cela avec des conférences, des déclarations de gestion ou même de la logique. Vous devez gagner en profitant d'un aspect alternatif de la nature humaine.
- Les gens imitent le comportement des meilleurs employés
Si les meilleurs employés utilisent TDD et que cela fonctionne, le processus se développera. S'ils ne le font pas, ce ne sera pas le cas. Si vous devez convaincre qui que ce soit, ce sont les 1 ou 2 meilleurs employés.
http://blog.jtimothyking.com/2006/07/11/twelve-benefits-of-writing-unit-tests-first
Je pense que j'ai mis en signet ce lien d'un article de Jeff Atwood il y a quelque temps [edit: ouais, le voici] . Vieux mais pertinent. En raison de ces avantages et d'autres qui seront sans aucun doute décrits dans d'autres réponses, vos programmeurs devraient être en mesure de se motiver! Cela leur permettra de travailler plus efficacement et rendra ainsi leur travail un peu plus facile. Qui ne veut pas ça?
En ce qui concerne votre deuxième question: votre sentiment d'appartenance et votre fierté des normes de qualité de votre code devraient vous aider à les suivre . Pensez à ce que vous voulez accomplir en ayant de telles normes et à qui en profite. Mes normes de code personnel peuvent également être frustrantes, mais j'ai toujours l'impression de rendre service au monde/à l'entreprise/à l'équipe en les mettant en œuvre. Je ne pense donc pas que vous essayez d'en faire trop - les résultats varieront d'un endroit à l'autre, mais au moins vous faites l'effort.
Demandez-leur.
Vous dites que les gens ont été informés et êtes d'accord qu'ils devraient passer plus de tests. Pourquoi ne le sont-ils pas?
Ce n'est peut-être pas (souvent pas le cas) une simple motivation. Ils pourraient les oublier. Ils pourraient se sentir sous la pression du temps. Ils pourraient ne pas savoir comment écrire de bons tests. Ils pourraient penser que vous êtes si bon qu'ils n'ont pas besoin de le faire. Connaître la cause première vous aidera à mieux résoudre le problème.
On pourrait penser que les tests unitaires seraient la vente eux-mêmes. Je ne sais pas comment fonctionne votre entreprise, mais quand il y a un problème lors d'un déploiement de production, nous le travaillons jusqu'à ce qu'il soit corrigé. Peu importe si cela se produit à 2 heures du matin un dimanche matin. C'est très rare pour nous, mais quand c'est le cas, ça craint.
Je commencerais par leur demander combien de fois ils ont dû se lever au milieu de la nuit pour résoudre un problème majeur qui aurait facilement pu être trouvé dans les tests automatisés. Cela ne veut pas dire que les tests automatisés régleront tout, mais cela devrait aider à réduire cela.
Le deuxième grand vendeur est le cycle QA. Avant le démarrage de TDD dans mon entreprise, nous transmettions chaque semaine de nouvelles versions au contrôle qualité. Ils créeraient une pile de bogues à partir de cette version, nous corrigeons ces bogues et pousserons une autre version. Répétez jusqu'à la fin. Le premier projet que nous avons réalisé TDD n'a nécessité un Push to QA que plusieurs semaines plus tard. Et le nombre de bogues trouvés a été très, très faible. 10% par rapport à un projet similaire. Avez-vous de toute façon compilé ces statistiques pour votre équipe?
L'autre grand argument de vente était la façon dont le code avait été adopté après le TDD, il était plus facile à lire, car nous voulions le rendre plus facile à tester. Affiche une comparaison entre le code écrit pour les tests unitaires et le code non écrit.
Enfin, montrez-leur comment ils pourront refactoriser le code en toute confiance.
Gardez tout cela à l'esprit lorsque vous n'avez pas envie d'écrire des tests. :)
J'ai utilisé quelques techniques:
a) mettre en place une construction automatisée. Lorsque quelqu'un casse quelque chose que vous avez testé, montrez-lui comment le test l'a détecté et à quel point le bogue aurait été grave.
b) Faites des projets complexes avec des tests (vous conduisez). Cela montrera combien peu de bogues existent dans ce projet. J'ai eu un projet complexe d'interaction avec le serveur qui a commencé à fonctionner parfaitement. Il n'a jamais échoué l'AQ et tous les tests d'intégration se sont déroulés à 100% sans problème. Ce système est devenu très stable et la direction générale en était satisfaite. Ce que vous faites dans ces situations est de savoir comment les tests unitaires ont permis cela.
c) Attirez une personne à la fois. Celui qui vous écoute. Relevez les bugs et montrez comment les tests exposent des problèmes profonds et difficiles. CA aide. Ce n'est jamais une chose facile. Mais une fois que vous aurez un fan, il ne fera que l'aider. C'est un effet domino.
Je voudrais développer la réponse de HLGEM , en particulier cette section:
La raison suivante est qu'avec une grande base de code existante non testée, l'écriture de tests semble probablement écrasante - un travail sans fin (comme la lessive et à peu près aussi excitant). Donc, la nature humaine est de penser que c'est trop de choses à affronter, alors je vais sauter.
J'ai trouvé que le code que j'écris avec l'intention d'écrire des tests est un code bien meilleur que le code que j'écris sans l'intention d'écrire des tests; me demandant Comment vais-je tester cette fonction? force une meilleure conception de chaque fonction. (Moins de dépendance vis-à-vis des données globales ou semi-globales; IO séparé du calcul; les fonctions ne font qu'une chose; gestion cohérente des erreurs; et ainsi de suite.)
Essayer de mettre des tests sur l'ancien code qui n'a pas été écrit en pensant aux tests peut être plus que frustrant.
Cuire les tests unitaires dans le processus. Si un bug en production est trop évident pour être détecté lors du test unitaire, ce type en est responsable. Demandez aux gens de rédiger chaque test qu'ils font. Choisissez des cas au hasard et regardez l'exécution de quelques cas chaque semaine. En faisant des tests unitaires, les gens poseront des questions sur les exigences et éventuellement lieront les exigences au développement et, espérons-le, développeront des logiciels à la fois requis et qui fonctionnent :)