Si vous changez de code avec un test unitaire, lequel changez-vous en premier?

Question

J'ai un projet que je construis que je dois changer une méthode pour se comporter légèrement différent. J'ai plusieurs tests unitaires déjà construits contre cette méthode, mais je devrai en ajouter d'autres pour couvrir le nouveau comportement que je vais y ajouter. Est-ce une bonne forme de changer/ajouter ces tests avant de faire le changement de code, ou changez-vous votre code, corrigez les tests brisés et ajoutez les nouveaux tests pour couvrir le nouveau comportement?

Answer 1

Il est préférable de mettre à jour les premiers tests et les laisser ne puis revenir en arrière et mettre à jour le code jusqu'à ce que le test passe. A.K.A Développement piloté par test ou Test premier développement.

Answer 2

Si vous êtes à suivre TDD pratiques, vous devez mettre à jour vos premiers tests. Vous aurez des cas de test cassés qui, espérons-le, seront corrigés lorsque vous corrigerez votre code.

Answer 3

Ce que je fais est le code d'abord, puis créer des tests après. Puisque vous pourriez avoir un cas où vous programmez votre test pour travailler d'une manière ou d'une autre et ensuite quand vous codez, vous réalisez que vous ne pouvez pas faire cela. Donc, vous devrez changer les tests à nouveau.

Answer 4

Si vous faites test de premier développement, au minimum, vous devez écrire un nouveau test qui justifie le changement. Le changement pourrait alors casser les vieux tests et vous pourriez les réparer après que vous les voyiez échouer, si le changement est accessoire au test. Si, cependant, vous savez que le test utilisé pour tester l'ancien comportement et il a juste besoin de changer pour le nouveau comportement, il n'y a aucune raison de ne pas simplement changer ce test au lieu d'en écrire un nouveau.

Il ne vaut pas la peine (à mon avis) de déterminer quels tests vont rompre avec le changement et de les changer tous d'abord parce que le coureur d'essai vous dira qu'après avoir effectué le changement.

EDIT (en réponse au commentaire): Je préfère écrire le premier test, mais qui est le style TDD. Dans ce cas, le test entraîne la conception. Il y a aussi un rythme et un modèle pour ce type de développement (refactor rouge-vert). L'inverse est plus le pur test de l'unité, vous avez déjà conçu et mis en œuvre ce que vous voulez, maintenant vous le testez. Il n'y a rien de mal à cela, c'est une approche de développement différente et le choix ne dépend pas de l'existence d'autres tests. C'est vraiment une approche de développement en général.

Answer 5

Personnellement, je préfère d'abord écrire la fonctionnalité et ensuite faire les tests unitaires (si cela est approprié à la fonctionnalité spécifique). Si c'est quelque chose qui ne vaut pas vraiment le test unitaire, je le passe d'habitude. J'ai trouvé que, c'est généralement une perte de temps pour ajouter un test unitaire au code all que vous écrivez. Il y a certainement des endroits où il est très utile de l'avoir, mais cela ne s'étend pas à tout votre code.

Il est facile de repérer la productivité perdue lorsque vous refactoring quelque chose, et se rendre compte que vous avez cassé la moitié des tests unitaires qui ne vraiment pas ajouter de la valeur pour commencer; puisqu'une faute aurait été facilement repérée en premier lieu. Donc tout cet effort est une perte de temps. Si vous travaillez dans un environnement où il n'y a pas d'incitation à livrer rapidement et à s'adapter rapidement, alors je suppose qu'il est possible d'avoir des tonnes de tests unitaires. Autrement, vous avez juste augmenté vos coûts d'un tas sans ajouter beaucoup plus de valeur à vos utilisateurs.

Answer 6

J'avouerai que parfois je triche. Si un changement est assez simple pour que je puisse connaître le résultat avec certitude, je vais parfois changer de code, puis tester. Comme si je multiplie un nombre par une constante, et tout ce que je fais change la constante, je vais aller de l'avant avec le changement et mettre à jour le cas de test par la suite.

Si vous êtes bien, en faisant quoi que ce soit même un peu plus complexe, je vous conseille de coller à l'orthodoxie TDD et changer le premier test. Définissez ce que vous voulez faire avant de le faire.Aussi, je recommande de mettre de nouveaux tests après tests préexistants, de sorte que les tests liés aux fonctionnalités existantes que vous souhaitez conserver soient exécutés en premier, vous assurant que vous n'avez rien cassé (ou vous avertir le plus tôt possible que tu as).