Alors que je suis tout à fait pour les tests unitaires, je me demande parfois si cette forme de premier développement de test est vraiment bénéfique ...
De petits tests triviaux comme celui-ci peuvent être le "canari dans la mine de charbon" pour votre base de code, alertant du danger avant qu'il ne soit trop tard. Les tests triviaux sont utiles à garder car ils vous aident à obtenir les bonnes interactions.
Par exemple, pensez à un test trivial mis en place pour savoir comment utiliser une API que vous ne connaissez pas. Si ce test est pertinent par rapport à ce que vous faites dans le code qui utilise l'API "pour de vrai", il est utile de garder ce test à portée de main. Lorsque l'API publie une nouvelle version et que vous devez mettre à niveau. Vous avez maintenant vos hypothèses sur la façon dont vous vous attendez à ce que l'API se comporte enregistrées dans un format exécutable que vous pouvez utiliser pour intercepter les régressions.
... [I] n processus réel, vous avez 3-4 couches au-dessus de votre code (demande commerciale, document d'exigences, document d'architecture), où la règle métier réellement définie (le prix de remise est le prix - la remise) pourrait être mal définie. Si tel est le cas, votre test unitaire ne vous dit rien.
Si vous codez depuis des années sans écrire de tests, il se peut que vous ne sachiez pas immédiatement qu'il y a une valeur. Mais si vous pensez que la meilleure façon de travailler est de «publier tôt, publier souvent» ou «agile» en ce sens que vous voulez pouvoir déployer rapidement / continuellement, alors votre test signifie définitivement quelque chose. La seule façon de le faire est de légitimer chaque modification que vous apportez au code avec un test. Quelle que soit la taille du test, une fois que vous avez une suite de tests verte, vous pouvez théoriquement déployer. Voir aussi «production continue» et «bêta perpétuelle».
Vous n'avez pas non plus besoin d'être "test premier" pour avoir cet état d'esprit, mais c'est généralement le moyen le plus efficace d'y arriver. Lorsque vous faites du TDD, vous vous enfermez dans un petit cycle Red Green Refactor de deux à trois minutes. À aucun moment, vous ne pouvez vous arrêter et partir et avoir un désordre complet sur vos mains qui prendra une heure à déboguer et à remonter.
De plus, votre test unitaire est un autre point d'échec ...
Un test réussi est celui qui démontre une défaillance du système. Un test échoué vous alertera d'une erreur dans la logique du test ou dans la logique de votre système. Le but de vos tests est de casser votre code ou de prouver qu'un scénario fonctionne.
Si vous écrivez des tests après le code, vous courez le risque d'écrire un test qui est «mauvais» car pour voir que votre test fonctionne vraiment, vous devez le voir à la fois cassé et fonctionnel. Lorsque vous écrivez des tests après le code, cela signifie que vous devez "lancer le piège" et introduire un bogue dans le code pour voir le test échouer. La plupart des développeurs ne sont pas seulement inquiets à ce sujet, mais soutiennent que c'est une perte de temps.
Que gagnons-nous ici?
Il y a certainement un avantage à faire les choses de cette façon. Michael Feathers définit le «code hérité» comme un «code non testé». Lorsque vous adoptez cette approche, vous légitimez chaque modification que vous apportez à votre base de code. C'est plus rigoureux que de ne pas utiliser de tests, mais lorsqu'il s'agit de maintenir une base de code volumineuse, cela se paie de lui-même.
En parlant de plumes, il y a deux excellentes ressources que vous devriez consulter à ce sujet:
Ces deux explications expliquent comment intégrer ces types de pratiques et de disciplines dans des projets qui ne sont pas «Greenfield». Ils fournissent des techniques pour écrire des tests autour de composants étroitement couplés, de dépendances câblées et de choses sur lesquelles vous n'avez pas nécessairement de contrôle. Il s'agit de trouver des «coutures» et de tester autour de celles-ci.
[S] i le prix réduit est erroné, l'équipe de test trouvera toujours le problème, comment les tests unitaires ont-ils sauvé du travail?
De telles habitudes sont comme un investissement. Les retours ne sont pas immédiats; ils s'accumulent avec le temps. L'alternative à ne pas tester est essentiellement de s'endetter de ne pas pouvoir détecter les régressions, d'introduire du code sans crainte d'erreurs d'intégration ou de prendre des décisions de conception. La beauté est que vous légitimisez chaque changement introduit dans votre base de code.
Qu'est-ce que j'oublie ici? S'il vous plaît, apprenez-moi à aimer TDD, car j'ai du mal à l'accepter comme utile jusqu'à présent. Je veux aussi, parce que je veux rester progressiste, mais cela n'a pas de sens pour moi.
Je considère cela comme une responsabilité professionnelle. C'est un idéal vers lequel tendre. Mais c'est très difficile à suivre et fastidieux. Si vous vous en souciez et pensez que vous ne devriez pas produire de code qui ne soit pas testé, vous pourrez trouver la volonté d'apprendre de bonnes habitudes de test. Une chose que je fais beaucoup maintenant (comme d'autres) est de me donner une heure pour écrire du code sans aucun test du tout, puis d'avoir la discipline de le jeter. Cela peut sembler inutile, mais ce n'est pas vraiment le cas. Ce n'est pas comme si cet exercice coûtait des matériaux physiques à une entreprise. Cela m'a aidé à comprendre le problème et à écrire du code de manière à ce qu'il soit à la fois de meilleure qualité et testable.
Mon conseil serait finalement que si vous n'avez vraiment pas le désir d'être bon dans ce domaine, alors ne le faites pas du tout. De mauvais tests qui ne sont pas maintenus, qui ne fonctionnent pas bien, etc. peuvent être pires que de ne pas avoir de tests. Il est difficile d'apprendre par vous-même et vous n'aimerez probablement pas cela, mais il sera presque impossible d'apprendre si vous n'avez pas le désir de le faire ou si vous ne pouvez pas y voir suffisamment de valeur pour justifie l'investissement en temps.
Quelques personnes n'arrêtent pas de dire que les tests aident à appliquer les spécifications. D'après mon expérience, les spécifications se sont également trompées, le plus souvent ...
Le clavier d'un développeur est l'endroit où le caoutchouc rencontre la route. Si la spécification est fausse et que vous ne lève pas le drapeau dessus, il est fort probable que vous en soyez blâmé. Ou du moins votre code le fera. La discipline et la rigueur impliquées dans les tests sont difficiles à respecter. Ce n'est pas du tout facile. Cela demande de la pratique, beaucoup d'apprentissage et beaucoup d'erreurs. Mais finalement, cela porte ses fruits. Sur un projet au rythme rapide et en évolution rapide, c'est la seule façon de dormir la nuit, peu importe si cela vous ralentit.
Une autre chose à laquelle il faut penser ici est que des techniques qui sont fondamentalement les mêmes que les tests ont fait leurs preuves dans le passé: "salle blanche" et "conception par contrat" ont toutes deux tendance à produire les mêmes types de constructions de "méta" -code que les tests le font et les appliquent à différents moments. Aucune de ces techniques n'est une solution miracle, et la rigueur va vous coûter en fin de compte la portée des fonctionnalités que vous pouvez offrir en termes de délai de mise sur le marché. Mais ce n'est pas de cela qu'il s'agit. Il s'agit de pouvoir maintenir ce que vous livrez. Et c'est très important pour la plupart des projets.