Les tests unitaires ou le développement piloté par les tests valent-ils la peine?
Mon équipe au travail se déplace vers Scrum et d'autres équipes commencent à faire du développement piloté par les tests à l'aide de tests unitaires et de tests d'acceptation des utilisateurs. J'aime les UAT, mais je ne suis pas vendu sur des tests unitaires pour le développement piloté par les tests ou le développement piloté par les tests en général.
Il semble que l'écriture de tests soit un travail supplémentaire, donne aux gens une béquille lorsqu'ils écrivent le vrai code, et pourrait ne pas être efficace très souvent.
Je comprends comment fonctionnent les tests unitaires et comment les rédiger, mais est-ce que quelqu'un peut dire que c'est vraiment une bonne idée et que cela vaut la peine et le temps?
De plus, y a-t-il quelque chose qui rend TDD particulièrement bon pour Scrum?
Réponse courte: Absolument positive.
Réponse longue: Les tests unitaires sont l'une des pratiques les plus importantes que j'essaie d'influencer sur mon lieu de travail (grande banque, trading fx). Oui, c'est un travail supplémentaire, mais c'est un travail qui rapporte encore et encore. Les tests unitaires automatisés vous aident non seulement à exécuter réellement le code que vous écrivez et bien sûr à vérifier vos attentes, mais ils agissent également comme une sorte de chien de garde pour les changements futurs que vous ou quelqu'un d'autre pourriez apporter. La rupture du test se produit lorsque quelqu'un modifie le code de manière indésirable. Je pense que la valeur relative des tests unitaires diminue en corrélation avec le niveau de changement et de croissance attendus dans une base de code, mais la vérification initiale de ce que le code fait en vaut la peine même lorsque le changement attendu est faible. La valeur de test unitaire dépend également du coût des défauts. Si le coût (où le coût est la perte de temps/d'argent/de réputation/d'effort futur) d'un défaut est nul, alors la valeur relative d'un test est également nulle; cependant, ce n'est presque jamais le cas dans un environnement commercial.
En général, nous n'engageons plus de personnes qui ne créent pas régulièrement de tests unitaires dans le cadre de leur travail - c'est juste quelque chose que nous attendons, comme se présenter tous les jours. Je n'ai pas vu d'analyse de rentabilité pure d'avoir des tests unitaires (quelqu'un se sent libre de m'en indiquer un), mais je peux dire par expérience que dans un environnement commercial, être capable de prouver que le code fonctionne dans un grand système important vaut la peine . Cela me permet également de mieux dormir la nuit en sachant que le code que j'ai écrit fonctionne de manière prouvée (à un certain niveau), et s'il change, quelqu'un sera alerté de tout effet secondaire inattendu par une construction cassée.
Le développement piloté par les tests, dans mon esprit, n'est pas une approche de test. Il s'agit en fait d'une approche/pratique de conception, le résultat étant le système de travail et un ensemble de tests unitaires. Je suis moins religieux à propos de cette pratique car c'est une compétence assez difficile à développer et à perfectionner. Personnellement, si je construis un système et que je n'ai pas une idée claire de son fonctionnement, j'emploierai TDD pour m'aider à trouver mon chemin dans l'obscurité. Cependant, si j'applique un modèle/une solution existante, je ne le ferai généralement pas.
En l'absence de preuve mathématique qu'il est logique d'écrire des tests unitaires, je vous encourage à l'essayer sur une longue période et à en ressentir vous-même les avantages.
Les erreurs trouvées plus tôt sont moins coûteuses à corriger que les erreurs trouvées plus tard. TDD vous aide à vérifier l'exactitude de votre système. Vous investissez un peu plus à l'avance, mais récupérez-le plus tard. Le graphique est un peu exagéré, mais il montre bien l'idée.
Les tests unitaires ou le développement piloté par les tests en valent-ils la peine?
Oui, c'est le cas . Oncle Bob (Robert C Martin) a dit dans un dans une présentation;
Pour qu'un développeur prouve que son code fonctionne mieux pour écrire un test et le réussir que de crier, chanter ou danser à ce sujet.
Et puisque vous n'allez pas supprimer le test, tant que le test est une réussite, vous êtes sûr que la fonctionnalité fonctionne - les problèmes de régression sont résolus.
Il y a beaucoup de choses écrites dessus,
- Vous êtes responsable de faire fonctionner cette fonctionnalité. Écrivez un test. Faites-le.
- Quand remplacer les tests unitaires par le test d'intégration
Le SCRUM, les tests unitaires et le TDD sont-ils liés?
En bref, lorsque vous êtes maître à Unit testing vous serez proche de TDD. [~ # ~] scrum [~ # ~] n'a rien à voir avec cela, mais comme on dit, de grandes choses se mélangent bien, ces techniques de développement d'un logiciel s'additionnent dans une excellente pile , si vous ne l'avez pas encore essayé, essayez.
Y a-t-il quelque chose qui rend TDD particulièrement bon pour SCRUM?
Comme je l'ai dit ci-dessus , ils font une bonne combinaison ; Si vous y ajoutez des tests d'automatisation , c'est plus spécial .
Il semble que l'écriture de tests soit un travail supplémentaire, donne aux gens une béquille lorsqu'ils écrivent le vrai code, et pourrait ne pas être efficace très souvent.
Les tests unitaires ont une valeur de béquille. Il soutient vos efforts de développement, vous permettant de modifier votre implémentation sans craindre que votre application cesse de fonctionner comme requis. Les tests unitaires sont également bien plus qu'une béquille, car ils vous donnent un outil avec lequel vous pouvez valider que votre mise en œuvre correspond aux exigences.
Tous les tests, qu'il s'agisse de tests unitaires, de tests d'acceptation, de tests d'intégration, etc., ne sont aussi efficaces que ceux qui les utilisent. Si vous abordez votre travail avec négligence, vos tests seront bâclés et votre implémentation aura des problèmes. Alors pourquoi s'embêter? Vous dérangez les tests parce que vous devez prouver à vous-même et à vos clients que votre logiciel fonctionne et qu'il n'a aucun problème qui pourrait empêcher l'utilisation du logiciel. Oui, les tests sont certainement un travail supplémentaire, mais la façon dont vous procédez aux tests déterminera combien d'efforts vous devrez consacrer à la correction des bogues après la publication, et combien d'efforts votre code nécessitera pour changer et maintenir.
Je comprends comment fonctionnent les tests unitaires et comment les rédiger, mais est-ce que quelqu'un peut dire que c'est vraiment une bonne idée et vaut la peine et le temps?
TDD, et vraiment n'importe quelle méthode qui vous oblige à écrire des tests avant de coder adopte l'approche que vous avez mise en œuvre dès le début en tant qu'acompte sur la future dette technique. Au fur et à mesure que vous progressez dans le projet, tout ce qui est manqué ou mal exécuté entraînera une dette technique plus importante sous la forme d'une difficulté accrue de maintenance, qui affecte directement les coûts futurs et les besoins en ressources. Les tests initiaux garantissent que non seulement vous avez fait un effort pour faire face à la dette technique future, mais également que vous codez vos besoins de manière à ce qu'ils puissent être vérifiés simplement en exécutant votre code. Le test vous donne également la possibilité de valider votre compréhension du domaine problématique avant de vous engager à résoudre le problème dans le code, et il valide vos efforts d'implémentation.
Cela revient vraiment à essayer de maximiser la valeur commerciale de votre code. Le code largement non testé et difficile à maintenir est généralement bon marché et rapide à créer, et très coûteux à maintenir pendant la durée de vie du produit après sa sortie. Le code qui a été testé à fond au niveau de l'unité est généralement plus cher à créer, mais coûte relativement peu à maintenir pendant la durée de vie du produit après sa sortie.
De plus, y a-t-il quelque chose qui rend TDD particulièrement bon pour SCRUM?
TDD n'est pas spécifiquement bon pour une méthodologie particulière. C'est simplement un outil. Une pratique que vous pouvez intégrer dans vos processus de développement afin de vous aider à atteindre vos résultats spécifiques. Donc, pour répondre à votre question, TDD est complémentaire à votre méthode, que ce soit SCRUM ou toute autre approche.
Les gens pensent que c'est un effort supplémentaire parce que c'est une activité initiale. Ce que vous perdez dans le temps, vous le récupérez plus tard.
Mes raisons pour les tests unitaires comprennent également:
Vous donne une cible: vous ne pouvez pas écrire un test si vous ne savez pas ce que le logiciel doit faire. Cela permet d'éliminer les problèmes dans les spécifications plus tôt que tard.
Vous donne un sentiment de progrès.
Vous avertit si un changement de code modifie la sortie d'autres zones de code. Cela facilite le refactoring.
Fournit une couche supplémentaire de documentation (surtout si vous commentez correctement vos tests).
Encourage toutes sortes de bonnes pratiques. Étant donné que les tests doivent s'exécuter rapidement, il vous encourage à écrire du code découplé et prend en charge la simulation. Tout cela facilite le refactoring.
Il y en a d'autres également couverts dans d'autres articles de ce fil. Ça vaut le coup.
Les tests unitaires ou le développement piloté par les tests valent-ils la peine?
Certainement oui (voir les autres réponses)
[Est-ce] vraiment une bonne idée et vaut la peine et le temps?
- Oui si vous démarrez quelque chose de nouveau (ajoutez un nouveau module ou une application complètement nouvelle)
- Non s'il existe déjà beaucoup de code existant qui n'a pas été développé piloté par les tests et qui doit être étendu (hérité).
À mon avis, le développement piloté par les tests est plus efficace si vous écrivez les tests unitaires avant le code réel. de cette façon, le code qui remplit les tests est clairement séparé avec un minimum de références externes faciles à tester.
Si le code existe déjà sans les tests unitaires, il y a généralement beaucoup de travail supplémentaire pour écrire les tests unitaires par la suite car le code n'a pas été écrit pour un test facile.
Si vous faites TDD, le code est testable facilement.
Permettez-moi d'aborder cela de l'autre côté. Que se passe-t-il lorsque vous développez une application non triviale sans tests unitaires? Si vous avez un bon service d'assurance qualité, l'une des premières choses qui se produira est que vous constaterez que vous avez un grand nombre de problèmes signalés. Pourquoi parce que vous n'avez pas testé ce que vous avez fait et supposé que cela fonctionnerait et parce que vous n'avez pas accordé beaucoup d'attention aux exigences et que votre application ne les satisfait pas. Oops retour à la planche à dessin pour réécrire et corriger. Maintenant que vous avez fait les correctifs et trouvez un tout nouvel ensemble de problèmes parce que vous n'aviez aucun moyen de vérifier que vos correctifs n'affectaient rien d'autre avant de passer au contrôle qualité. Oops la date limite est maintenant révolue et la gestion est bouleversée.
La situation est pire si vous ne disposez pas d'un bon service d'assurance qualité, car les utilisateurs trouveront les bogues et non seulement cela rendra votre patron mécontent, mais cela peut mettre l'environnement de production à genoux et des centaines ou même des milliers de personnes seront à un arrêt pendant que vous corrigez les bogues que les tests unitaires auraient empêchés. Ce n'est PAS un bon choix de carrière.
Supposons maintenant que cette approche de cow-boy dure depuis des années? Maintenant, chaque changement, même insignifiant, semble faire éclater de nouveaux problèmes insoupçonnés. Non seulement cela, mais bon nombre des choses que vous aimeriez faire pour améliorer le fonctionnement de l'application, vous ne pouvez pas le faire car elles sont trop risquées ou trop chères ou les deux. Vous mettez donc des correctifs sur les correctifs, ce qui rend le système de plus en plus compliqué, plus buggé et plus difficile à utiliser.
Les utilisateurs commencent à remettre en question vos estimations de temps car ils deviennent de plus en plus grands et il est difficile de leur expliquer que le système est devenu un gâchis si compliqué, il est difficile de trouver où faire les changements et encore plus difficile de s'assurer qu'ils ne le font pas. t casser quelque chose d'autre.
J'ai travaillé dans un endroit comme celui-ci où, après dix ans de développement, pratiquement rien que nous voulions faire pour résoudre les vrais problèmes ne pouvait être fait car nous ne pouvions pas dire laquelle des centaines d'applications clientes personnalisées se briserait. Les premiers développeurs étaient essentiellement des développeurs de type "tests unitaires, nous n'avons pas besoin de tests unitaires puants". Tous ceux qui les ont suivis ont souffert de leur myopie.
Sans tests unitaires, le logiciel est plus bogué et prend plus de temps à développer et à maintenir initialement. Pourquoi diable ne voudriez-vous pas faire des tests unitaires? Le temps que vous passerez à écrire le test sera beaucoup moins long que le temps que vous passeriez à résoudre les problèmes que vous auriez dû trouver plus tôt (plus tôt le bogue est trouvé, moins de temps pour le corriger) et les problèmes que vous auriez évités en écrivant les tests ce qui donne une meilleure compréhension des exigences avant de commencer à coder.
Tout le code que vous écrivez doit être testé à un moment donné. Vous ne voulez pas écrire le tout en une seule fois, puis appuyez sur le bouton de compilation et croisez les doigts. Vous écrivez et compilez de petits blocs et envoyez des entrées soigneusement conçues à votre code pour vérifier qu'il fait ce que vous pensez qu'il fait. Ensuite, vous supprimez généralement votre appareil de test ad hoc et passez au composant suivant.
Avec les tests unitaires, cela simplifie ce processus et vous donne une excuse pour garder vos tests. De cette façon, si vous apportez des modifications qui cassent les éléments que vous aviez testés dans le passé, vous pouvez intercepter cette régression explicitement au lieu de lui permettre d'affecter d'autres parties de votre code. Cela a une réelle valeur.
En ce qui concerne l'approche red-green-refactor du TDD, je trouve cela un peu fastidieux. Mais a chacun le sien.
La plupart du temps, je trouve que les développeurs résistent à l'idée d'écrire des tests. Ce n'est pas tant qu'ils soutiendront que les tests n'ont aucune valeur mais plutôt qu'ils ne sont qu'un moyen de comprendre comment résoudre un problème particulier. Habituellement, ce problème change en fonction du contexte. Une fois cela fait, les tests ne servent à rien et pourraient tout aussi bien être supprimés. Voici un échantillon de contextes que mes collègues ont donnés dans le passé sur la façon de décider quand écrire un test et vous trouverez que la seule réponse possible selon eux n'est jamais:
- le problème doit être un exemple de manuel pour TDD tel qu'une pile ou une calculatrice
- le code trivial ne doit pas être testé (invalide l'argument précédent)
- le code critique ou difficile doit être soigneusement testé (sous-entendu par l'argument précédent)
- les tests ne doivent pas être étroitement associés à l'implémentation pour permettre un refactoring de balayage (invalide l'argument précédent)
- il n'est pas nécessaire de tester les effets secondaires comme appeler un service tiers avec une charge utile spécifique (donc pas de test de boîte noire)
En fait, il y a un type de test que j'ai trouvé généralement accepté et qui, à mon avis, est finalement inutile. À savoir des tests basés sur une interface graphique, tels que l'utilisation de Selenium, d'un pilote Web, de watir ou d'arquillian. C'est ainsi que nous obtenons les cycles de construction de 7 heures plutôt que les cycles de construction de 5 minutes sur mes projets TDD.
Ces mêmes développeurs se plaignent généralement auprès de tout le monde de la gravité du code et de l'incompétence des développeurs précédents. Ils trouvent également qu'il est extrêmement important que vous fassiez une conception appropriée en utilisant un tableau blanc, MS Office ou un wiki et prenez grand soin de vous assurer que cette conception reste à jour.
Ce dernier est ce qui m'a vraiment fait réaliser que ces développeurs sont des fraudes. Nous savons tous que tout document de conception qui n'est pas un test unitaire deviendra obsolète et ne sera pas tenu à jour en raison du simple coût de la maintenance. En fait, j'ai essayé et essayé de trouver un bon moyen d'exprimer des idées de conception au format MS Office qui était utile et lisible avant et après l'écriture de code. J'ai échoué dans tous les cas et bien qu'il y ait des gens qui réussissent à produire un document MS Office qui semble joli, je n'ai jamais trouvé ceux-ci utiles non plus.
Donc tu as un choix. Vous pouvez faire de la conception et de la documentation en pratiquant TDD qui est la seule méthode connue et éprouvée pour produire une telle documentation basée sur mes 10 années d'expérience en développement. Ou vous pouvez faire de la politique.