Quels sont les inconvénients du code d'écriture avant d'écrire des tests d'unité?
J'ai toujours vu la recommandation que nous devrions d'abord écrire des tests d'unité, puis commencer à écrire un code. Mais je pense que cela va que l'autre façon est beaucoup plus confortable (pour moi) - écrivez le code, puis les tests de l'unité, car je pense que nous avons beaucoup plus de clarté après avoir écrit le code réel. Si j'écris le code, puis les tests, je devais peut-être modifier mon code un peu pour le rendre testable, même si je me concentre beaucoup sur la création d'une conception testable. D'autre part, si j'écris les tests, puis le code, les tests changeront fréquemment comme et lorsque le code se formule.
Comme je vois beaucoup de recommandations pour commencer à écrire des tests, puis passer au codage, quels sont les inconvénients si je le fais de l'autre moyen - écrivez le code, puis les tests de l'unité?
Rouge est la réponse. Le rouge est ce que vous obtenez du cycle de refacteur rouge-vert de TDD que vous ne pouvez pas obtenir, de la dernière fois. Tout d'abord, écrivez un test d'échec. Regarder ça échoue. C'est votre rouge, et c'est important. Il dit: J'ai cette exigence et je sait Mon code ne le satisfait pas. Ainsi, lorsque vous allez à l'étape 2 (vert), vous savez, avec une certitude tout aussi de certitude que votre code satisfait maintenant cette exigence. Vous savez que vous avez modifié votre base de code de manière à satisfaire à la condition requise.
Les exigences (tests) développées après le code, en fonction du code, vous prive de ce type de certitude, cette confiance.
Si vous écrivez le code, puis les tests, il est trop facile de tomber dans le piège d'écrire les tests afin que le code passe, plutôt que de rédiger les tests pour vous assurer que le code répond à la spécification.
Cela dit, ce n'est certainement pas le seul moyen de faire des choses, et il n'y a pas de "meilleur" moyen de développer des logiciels. Si vous mettez beaucoup de travaux initiaux pour développer des cas de test, vous ne savez pas si votre architecture proposée a des défauts jusqu'à bien plus tard - tandis que si vous développez le code en premier, vous les longez plus tôt et que vous pouvez redéfinler avec moins de coule effort.
Toutes les autres réponses sont bonnes, mais il y a un point qui n'a pas été touché. Si vous écrivez d'abord le test, cela garantit que les tests sont écrits. Il est tentant, une fois que vous avez écrit du code de travail, de sauter les tests et de le vérifier tout au long de l'interface utilisateur. Si vous avez la discipline pour toujours avoir un test de défaillance avant d'écrire du code, vous pouvez éviter ce piège.
Si vous écrivez d'abord vos tests, cela vous donne une autre chance de penser à votre conception, avant que cette conception ne soit "jette en pierre".
Par exemple, vous pouvez penser que vous avez besoin d'une méthode qui prend un certain ensemble de paramètres. Et si vous avez d'abord écrit le code, vous l'écririez de cette façon et faites le test adapté aux paramètres spécifiés. Mais si vous écrivez d'abord le test, vous pouvez penser "Attendez une minute, je ne voudrais pas utiliser ce paramètre dans le code principal, alors peut-être que je devrais changer l'API."
Comme je vois beaucoup de recommandations pour commencer à écrire des tests, puis passer au codage,
Il y a une vraie bonne raison pour cela.
Si vous dites "faire ce qui se sent bien", les gens font les choses les plus stupides et les plus folles.
Si vous dites "Ecrire des tests d'abord", les gens peuvent au moins essayer de faire la bonne chose.
quels sont les inconvénients si je le fais dans l'autre moyen - écrivez le code, puis les tests de l'unité?
Habituellement, un test moche et un design qui doivent être retravaillés pour être testables.
Cependant, ce n'est qu'un "généralement". Certaines personnes évoluent les conceptions et les tests en parallèle. Certaines personnes ont mis du code testable en place et écrivent des tests sans retravailler.
La règle "Test d'abord" est spécifiquement là pour enseigner et instruire des personnes qui n'ont aucune idée du tout.
De la même manière, on nous dit toujours de regarder "les deux sens" avant de traverser la rue. Cependant, nous ne le faisons pas. Et peu importe. Je vis dans un pays d'entraînement à droite et je n'ai besoin que de regarder à gauche lorsque vous commencez à croiser.
Quand je visiterai un pays d'entraînement à gauche, l'air à gauche ne pouvait que me faire tuer.
Les règles sont très fortement énoncées pour une raison.
Ce que vous faites est votre propre problème.
le point d'écrire le test d'abord est que cela vous fait penser à
- comment tester le code
- l'interface que le code doit présenter pour être testable
si vous faites quelque chose de simple, cela ne compte probablement pas lequel vous écrivez en premier (bien qu'il soit bon de cultiver la première habitude de test) car le test sera simple et l'interface sera évidente
mais TDD augmente les tests d'acceptation, pas seulement des tests unitaires, puis l'interface devient non triviale.
Tout d'abord, si vous n'écrivez pas d'abord vos tests, vous ne faites pas de développement dirigé par des tests (TDD). Les avantages sont nombreux et souvent difficiles à croire jusqu'à ce que vous vous pratiquiez plusieurs fois. Voici les avantages que j'ai reçus de TDD sur le développement traditionnel:
- Un filet de sécurité des tests - vous permet de faire de gros changements sans la peur de briser quelque chose de manière impressionnante
- Design organique - Le design que je finis avec est généralement différent de ce que la conception que j'aurais fait à partir de zéro et cela a toujours été mieux
- Productivité - Travailler vers de petits objectifs (passez ce test) et le faire (tous les tests Pass) fonctionne vraiment bien pour moi et me maintient motivé. Ajouter une paire et ma productivité atteint de nouveaux hauts.
Livres: Beck, K. Développement axé sur les tests par exemple
Bon exemple: http://jamesshore.com/blog/lets-play/
Lorsque vous écrivez un test, comment savez-vous qu'il détectera une condition d'échec? La réponse est "Test du test". La façon dont vous faites cela est d'écrire le test en premier, voir l'échec de l'échec et ne le vois que lorsque l'unité sous test a été codée avec succès (le cycle rouge/vert/refacteur mentionné dans l'une des autres réponses).
Écrire le code Tout d'abord, puis le test quitte la question de savoir si le test montrerait un échec honnête.
N'oubliez pas que vos tests expriment des spécifications. Si vous devez réviser vos tests lorsque votre code "formes", il suggère que vos spécifications changent. Qui peut être ou non être une bonne chose. Cela pourrait signifier que votre compréhension du problème n'était pas initialement correcte. D'autre part, cela pourrait signifier que vous testez "comment" l'unité fait son travail plutôt que quoi C'est censé être accompli.