Ne serait-il pas bénéfique d'écrire des tests pendant la revue de code?
Un collègue de mien a eu une idée que j'ai trouvé intéressante.
Ne serait-il pas bénéfique d'écrire des tests pendant la révision du code, par la personne qui fait l'examen en supposant que nous ne faisons pas TDD?
Pour cette question, supposez qu'il s'agit d'un projet purement académique, donc il n'y a pas de vie en jeu. De plus, l'équipe est de 4 personnes. Tout le monde connaît la langue et connaît tous les outils/bibliothèques/frameworks utilisés et peut écrire des tests. Donc, fondamentalement, les gens qui ne sont pas des ingénieurs de ninja ninja, mais des codeurs décents.
Avantages j'ai trouvé:
- Encourage la compréhension plus approfondie du code lors de l'examen pour écrire des tests significatifs.
- Vous pouvez ensuite ajouter un examen de code de ces tests effectués par l'auteur du code testé.
Contre j'ai trouvé:
- La boucle de retour entre la rédaction de code et les tests augmentent.
EDIT: Je sais que cela ne fonctionnera pas bien sur les applications Web "normales". Ce que j'avais à l'esprit était un cas d'angle où vous mettez en œuvre des algorithmes scientifiques complexes qui nécessitent des soins aux détails. Supposons quelque chose comme implémenter ma propre bibliothèque graphique, NLP, etc. Je me demande si le code que nous écrivons est isolé des bases de données et, mais très difficile à comprendre ne serait pas le niveau de contrôle supplémentaire, l'autre personne qui doit comprendre la source Code et faire un test significatif, rendre l'ensemble du processus moins sujet à ces bugs moins évidents qui ne placent pas l'application, mais font finalement vos résultats?
Ne serait-il bénéfique aux tests d'écriture lors de l'examen de code, par la personne faisant l'examen?
J'ai trouvé qu'un bon moment à des tests d'écriture est quand vous réalisez que vous avez besoin d'un test pour une situation.
Tâche de commutation pour les ordinateurs est coûteux - encore plus-donc pour l'homme.
A ce moment, vous avez généralement une bonne compréhension des exigences et des dépendances pour le test. Donc, tirer parti de l'immersion de votre équipe dans le problème. Si vous avez besoin d'affiner votre nouveau test à l'avenir, grand, vous avez déjà le framework de test/fixtures en place, et tout ce que vous devez faire est de changer la partie qui doit être amélioré.
Si cela se produit lors de l'examen du code, pourquoi ne pas aller de l'avant et le faire? Je l'ai fait avant. Je l'ai trouvé qu'il vaut mieux que de ne pas, surtout si vous pouvez le faire rapidement, et encore mieux si vous ne l'auriez pas fait autrement.
En supposant que nous ne faisons pas TDD?
Même si vous ne pratiquez TDD, si vous réalisez que vous avez besoin d'un test tout en faisant l'examen du code, celui que vous n'avez pas, pourquoi ne pas écrire le test alors et là?
Avantages
- Vous tirer parti de votre attention sur le code en cours d'examen.
- Parfois, la révision du code devient hang-out et le temps dans le chat quand les gens ne sont pas en elle. La rédaction d'un test encourage tout le monde à penser plus activement sur le code en cours d'examen.
- Membres plus jeunes de l'équipe auront l'occasion d'apprendre de l'expérience d'écriture test.
- Vous pouvez identifier les talents de votre équipe que vous ne saviez pas que vous aviez.
Est-il vraiment un con que d'autres tests peuvent conduire à plus de code? Si le test était nécessaire, et le code était nécessaire pour le test, et maintenant vous avez, alors c'est un bien chose.
Avertissements
Peut-être quelques-uns des besoins de l'équipe pour se concentrer sur d'autres choses. Si elle provoque une distraction de priorités ou votre examen du code passe au-dessus calendrier, alors vous devez limiter ou couper l'écriture proprement dite de l'out test. Cependant, l'examen du code peut certainement identifier les tests qui doivent être écrites, et peut-être ils peuvent au moins être bouchonné pour l'écrivain pour terminer plus tard.
Je ne pense pas que l'idée est entièrement sans mérite - cependant, le principal avantage de la TDD et al est que des problèmes sont trouvés début. Le développeur est également mieux placé pour repérer quels cas d'angle peuvent nécessiter une attention particulière. Si cela est laissé jusqu'à la révision du code, il y a un risque que ces connaissances pourraient être perdues.
Les tests d'écriture au cours de l'examen du code subiraient du même problème que les tests manuels traditionnels - la compréhension des règles de gestion peut varier d'un développeur au développeur, comme cela peut la diligence.
Il y a aussi la vieille expérience de l'âge qui fonctionnera et courira si les développeurs testeraient si bien leur code s'ils savaient qu'il y avait une fonction de test plus en amont qui devrait attraper les bugs plus graves.
Je suis d'accord avec la réponse de @ Robbiee, mais j'ai un peu plus à ajouter.
Si vous aimez vraiment cette idée, pourquoi ne pas avoir les mêmes personnes écrivant les tests avant le code en tant que critères d'acceptation exécutables pour l'histoire d'utilisation?
Cela ferait la même chose, maintiendrait toujours les commentaires courts et que tout le monde ait une discussion autour de l'histoire, ce qui, à mon avis, serait d'une plus grande valeur.
Les inconvénients sont le danger d'une réunion de critères d'acceptation sans fin :-( et je pense que vous essayez d'obtenir des gens dans l'examen du code pour consulter le code de mise en œuvre, mais je suggérais une programmation et une rotation des paires en tant que meilleure solution à ce problème.
L'OP a ajouté une modification où ils disposent d'autres détails de cet étant une fonctionnalité lourde difficile ou d'algorithme.
En réponse à cela, j'ajouterais que votre instinct d'avoir plus d'yeux sur le problème et la solution est bonne. Peut-être paire avec plusieurs personnes un sur un sur un jusqu'à ce que tout le monde ait vu un peu de code et de tests de mise en œuvre vraiment difficiles. Chacun lancant de nouvelles idées et ajout de plus de valeur.
Il y a une idée parfois appeler la programmation de la foule, comme un appariement, mais avec plus de gens. C'est presque ce dont vous parlez, mais ils aident au moment de l'écriture plutôt que dans une revue formelle par la suite. Ce n'est pas pour tout le monde et peut avoir besoin d'un pilote solide (leader) pour le faire fonctionner ou une équipe qui est très à l'aise et le processus.
Faire après la programmation de la foule, je suppose que beaucoup des mêmes avantages de nombreux yeux de voir le problème et de suggérer des améliorations et si c'est la manière dont votre équipe est à l'aise, cela peut aider, mais j'essaierais vraiment de garder le nécessaire Des occurrences de ceci jusqu'à un minimum, car je pense que cela pourrait ralentir l'équipe.
Comme vous le dites, si vous exécutez une équipe TDD, ceci est notifié car le code doit déjà être testé.
Globalement, je ne pense pas que ce soit une bonne idée, mais cela dépend de votre approche actuelle et de ce qui fonctionne pour vous. Fondamentalement, le problème que je vois est que vous perdez l'avantage de tests "courte boucle de rétroaction". Obtenir une notification instantanée au moment où vous cassez quelque chose, même si vous écrivez, le nouveau code est où des tests brillent vraiment. Si vous repoussez les tests jusqu'à ce que l'examen du code, vous disiez fondamentalement "Eh bien, nous aurions pu résoudre ce problème plus tôt dans moins de temps et avec moins de personnes impliquées, mais au moins nous avons tous appris quelque chose (peut-être)". Je préférerais simplement vous assurer que les gens soumettent un code testé pour examen, puis vous jugez l'exactitude et la maintenabilité des tests. Après tout, l'examen du code est destiné à révision, pas de code de rédaction.
D'autre part, je vous recommande de jouer avec les tests/code lors de l'examen. Essayez de casser quelque chose. Commenter une condition si. remplacer un booléen avec un littéral vrai/faux. Voir si les tests échouent.
Mais oui, dans l'ensemble, je vous recommande d'écrire vos tests avec votre code, puis de l'examiner à la fois.
Cela dépend de ce que vous faites dans l'examen du code. Je pense qu'il y a deux raisons principales d'écrire des tests à ce stade:
premièrement, si vous refactez également pendant la révision du code et que vous notiez qu'il n'ya pas suffisamment de tests d'unités pour couvrir le type de refactoring que vous souhaitez appliquer, ajoutez de tels tests.
deuxièmement, si le code vous regarde comme si cela pourrait avoir un bogue et que vous voulez qu'il prouve (ou réfuve) cela, écrivez-le pour cela
Les deux cas expriment un besoin de tests qui ne sont pas là pour le moment, mais devraient être. Bien sûr, cela pourrait dépendre de la culture de vos équipes si ces types de tests devraient être écrits par le critique ou par l'auteur d'origine, mais quelqu'un devrait écrire les tests.
En fait, je ne pense pas que ce soit "un cas d'angle", juste adapté aux "algorithmes complexes et scientifiques" - tout à fait le contraire, cela convient à tout type de logiciel que vous attendez d'un certain degré de qualité.
Non, ne le faites pas. Vous les ferez penser que TDD est horrible.
Je pense que @ k3b a raison dans les commentaires sur la question. Le code écrit via un processus de style TDD a tendance à regarder et à interagir, très différemment au code écrit sans tests. L'ajout de (bons) tests au code non testé prend généralement beaucoup de refactorisation du code pour clarifier son intention et ses parties en mouvement.
En ajoutant les tests après avoir écrit le code, vous manquez les aspects architecturaux des avantages de TDD (ce qui me tient à l'esprit l'un des principaux avantages). Non seulement cela, vous demandez à quelqu'un d'autre, qui n'est pas aussi familière avec le code, de prendre le coup d'ajouter des tests déjà difficiles à ajouter.
Soit l'ajout de tests de la personne devra refacturer de manière significative le code, soit ils devront travailler très fort pour tester un code sans faille. De toute façon, ils ne vont pas profiter de l'expérience. Même si cela pourrait ne pas être classique TDD, ils ne le verront pas de cette façon, et vous pourriez les mettre de côté TDD une fois pour toutes.
(Si vous suivez déjà un processus TDD, écrivez supplément tests pendant la révision du code serait moins nocif, bien que dans mon expérience, si les tests sont déjà bien écrits, il est tout aussi facile d'expliquer le Test supplémentaire à la personne qui soumet le code de contrôle et les écrire.)
Les tests unitaires pendant la révision du code sont un substitut médiocre des tests d'unités pendant le développement.
Ce que vous suggérez beaucoup de sens, de manière intuitive. Quel est l'avis? Vérifier que le code est bon. Quels sont les tests? Vérifier que le code est bon. Alors pourquoi ne pas combiner les deux?
Voici pourquoi.
apporter le code sous test est un travail acharné. Code d'écriture que fonctionne simplement À la seule chose que c'est censé faire est une chose; code d'écriture qui peut être efficacement et efficacement Testé est un autre. Le fait que le code fonctionne désormais sous deux scénarios - "Travail réel" et "Test" - exige une flexibilité beaucoup plus grande, exigent que ce code soit capable de se tenir debout de manière significative.
Écrire votre code afin que ce soit testtable soit un travail et une compétence supplémentaires. Refactoring quelqu'un else's Code de testabilité, lorsqu'il n'a pas été écrit avec une testabilité à l'esprit pour commencer, peut être une tâche majeure.
Vous avez duplication des efforts entre le développeur et l'examinateur. Vraisemblablement, votre développeur ne remet pas son code pour examen sans au moins Certains niveau de confiance que c'est travail. Il doit déjà tester le code. Maintenant, il existe différents niveaux et étanches de test. QA teste le code après le développeur et le critique. Mais quelle que soit la portée que vous pensez être appropriée pour le développeur et le réviseur, cela n'a aucun sens pour que le développeur de déterminer comment tester le code à ce niveau une fois, mais faire ses tests jetables et difficile à Reproduire, puis apporter In Le critique Pour développer test à nouveau, cette fois-ci qui sont automatisés et reproductibles. Vous venez d'avoir les deux d'entre eux investir du temps écrit les mêmes tests - une fois mal, une fois bien.
Vous tournez en revue dans une étape beaucoup plus longue et plus laborieuse. Si le test est une partie essentielle du processus d'examen, Que se passe-t-il lorsque certains tests échouent? L'examinateur est-il responsable de l'exécution des tests de toutes les tests, elle a donc besoin de déboguer le code aussi? Ou va-t-il être ping-pongé d'avant en arrière, un test d'écriture, l'autre les amène à passer?
Parfois, vous pouvez écrire tout un tas de tests qui sont tous orthogonaux les uns aux autres, vous n'avez donc pas besoin de ping-pong. Le critique écrit une douzaine de tests, la moitié d'entre eux échouent, le développeur corrige les bugs et tous les tests restent valables et passent maintenant. Mais ... Beaucoup de temps, vous avez des bugs bloquants ou des bugs nécessitant des modifications de la refonte et de l'API, ou de rien. Si vous lancez la responsabilité des tests de passage entre les examinateurs et le développeur, vous n'êtes pas réellement à la phase de révision. Vous développez toujours.
Devant écrire des tests n'entraîne pas une révision plus approfondie. Cela signifie essentiellement que plus vous allez, plus vous devez écrire des tests, et probablement ils seront Difficile tests qui doivent aller au fond du système.
Comparez-vous au développeur Ecrire les tests, où son incitatif est: Si je n'écris pas d'essais importants, le critique signalera cela dans la revue.
Même le examinateur aura une bien meilleure compréhension du système si elle doit aller sur des tests approfondis du code, alors si elle doit décider pour elle-même Quand elle peut cesser d'écrire un test de creusement en profondeur et juste ok, l'examen du code.
Si le développeur n'écrit pas les tests d'unité, le critique ne sera pas non plus. Il existe de nombreux obstacles à l'adoption de tests comme une pratique courante. Peut-être que vous êtes sous trop de pression, et votre base de code est difficile à apporter un test. Peut-être que vous n'êtes pas si expérimenté dans le test et que vous vous sentez comme si vous ne pouvez pas vous permettre la courbe d'apprentissage. Peut-être que vous avez un meurtrier à la hache envoyant des notes menaçantes aux personnes qui écrivent des tests. Je ne sais pas!
Mais quelle que soit la cause, il est prudent de parier qu'elle s'applique également à l'examinateur et au développeur. Si l'équipe est stressée, le critique n'a pas plus de temps que le développeur (si elle le fait, redistribue le travail afin que les gens ne soient pas aussi stressés). Si personne ne sait comment écrire des tests unitaires, le critique ne peut probablement pas non plus (si elle le fait, elle devrait s'asseoir et enseigner à ses coéquipiers).
Cette suggestion semble tenter de passer le dollar d'un collègue à un autre. Et je ne vois tout simplement pas de moyen pour cela de travailler bien, Tout d'abord et avant tout car c'est vraiment difficile (et malsain) de créer une situation où une personne est le seul à pouvoir faire Les tests, et une autre personne ne peut pas effectuer de tester du tout.
Ce que fait Travail est avoir les tests de couverture d'examen aussi. Si le développeur a déjà écrit dix tests, il est beaucoup plus probable que le critique puisse aider à suggérer dix autres que Si le développeur n'avait écrit aucun.
Et, si le test d'angle de test est une tâche majeure, il pourrait être logique de distribuer cela plus largement à travers l'équipe. ** Une fois que le code est testable en premier lieu, écrire plus Les tests deviennent beaucoup plus faciles. Amateur
L'avis est un bon moment pour point Cas d'angle. Et, si le critique peut sauter et écrire un test pour les cas de coin, elle trouve, alors hé - tout le meilleur! Mais de manière générale, en supposant que l'examinateur puisse écrire des tests où le développeur n'a pas Cela ressemble à une très mauvaise idée.