Une question posée plusieurs fois auparavant mais avec un développement spécifique de twds mvc.
J'ai été un très bon garçon et j'ai codé toutes mes actions de contrôleur avec des tests unitaires correspondants, ce qui a été génial (même si un peu [lire beaucoup] répétitif parfois). Pour être honnête, j'ai en fait créé un petit modèle T4 pour écrire la plupart des os nus des tests unitaires initiaux, puis peaufiné selon les besoins. J'admets ne pas être sûr de savoir comment gérer les tests dans les vues qui contiennent des vues partielles - mais c'est une histoire pour une autre question.
Maintenant, la partie difficile pour moi de décider est à quel point la couverture doit être profonde dans ma couche de service. La raison en est que certaines de mes méthodes de service (pour le meilleur ou pour le pire) effectuent en fait une variété de requêtes linq qui fournissent ensuite des informations discrètes à la logique suivante dans la méthode. Je sais que je pourrais (devrais ??) décomposer ces méthodes pour appeler uniquement la logique requise pour chaque instruction linq, puis les appliquer dans la méthode. Cependant, dans de nombreux cas, il n'y a jamais de réutilisation des «fonctions» linq et par conséquent, il estime que cela refactoriserait le code trop loin.
Ce que je demande, c'est qu'avec une logique complexe se produisant dans une méthode, est-ce `` assez bon '' d'avoir une méthode de test qui affirme simplement le résultat requis et / ou l'erreur attendue, ou si chaque ligne logique doit être simultanée et testée également. la façon dont je le vois, pour faire les tests correctement, alors la logique de la méthode (ligne par ligne) devrait également obtenir une sorte de couverture. Cependant (à mon avis naïf), cela pourrait conduire à un cycle sans fin d'essayer de garder le test et la méthode mise en œuvre si étroitement alignés (ce que je sais qu'ils devraient être) au point de créer une industrie artisanale dans les tests eux-mêmes.
Je sais que ma question peut offenser quelques-uns des adeptes du TDD qui verront cela comme une évidence. N'étant pas dans le camp TDD, c'est une «évidence» pour moi, d'où la question.
btw - avait vérifié cela pour des idées:
regardant maintenant vers le bas les votes réguliers :)
[modifier] - au profit de l'électeur (enfin en ce moment célibataire !!) "proche". cette question n'est pas subjective. Je recherche un consensus sur un sujet très ciblé. Je ne cherche pas à attiser des passions négatives, je ne cherche pas à exposer les défauts de la technologie - je suis un grand fan. Alors s'il vous plaît, laissez un commentaire poli à mon avantage si vous votez pour clore, car cela peut m'aider à restructurer la question en cas d'ambiguïté ou de désinformation. cette question pourrait bénéficier à une grande partie de la population mvc.
Merci!!
Jim
la source
Réponses:
Tout d'abord, ce dont vous parlez ne ressemble pas tout à fait à TDD. TDD implique une première approche de test qui consiste à piloter la conception de votre système en suivant le modèle Test-> Code-> Refactor . Alors peut-être que votre premier problème est le but de vos tests, les écrivez-vous en codant? Si c'est le cas, je m'attends à ce que la quasi-totalité de la logique de votre test se rapporte à un test unitaire. Une couverture de code élevée est donc un résultat indirect de l'application de TDD.
Lorsque vous effectuez TDD, vous écrivez suffisamment de code de test pour motiver le code que vous souhaitez écrire. Vous vous assurez également que le test échoue en premier. Fondamentalement, demandez-vous ce que cette méthode doit faire. Ensuite, vous le codez, mais juste assez pour que le test réussisse, si ce n'est pas ce que vous recherchez, vous écrivez des tests supplémentaires, puis refactorisez la méthode.
La couverture de code après coup n'est pas une méthode efficace pour mesurer votre adhésion à TDD, bien que vous constatiez généralement une couverture de code très élevée dans le code écrit à l'aide de TDD, car tout le code aurait dû être motivé par un test.
Les tests TDD servent à la fois à piloter la conception et à documenter et à expliquer la conception aux autres en langage clair (donc la façon dont vous nommez vos tests est très importante).
Cependant, rien de tout cela ne répond vraiment à votre question directement, alors je dirai simplement que vous devriez viser une couverture de code assez élevée du code de service (non UI), en particulier là où il y a une logique non trivalente, et encore mieux si les tests sont écrit en premier ;-). Le fait est (bien que certains puissent être en désaccord) que plus de tests sont généralement meilleurs. De nombreux projets open source de haute qualité ont beaucoup plus de code de test que de code en cours d'exécution.
De plus, les tests doivent être écrits chaque fois que:
Vous écrivez du nouveau code, les tests doivent conduire et documenter votre conception et expliquer vos hypothèses sur ce que le code devrait faire. Le doit être écrit avant de coder.
Vous avez trouvé un bogue, un test ayant échoué devrait démontrer le bogue. Une fois le bogue corrigé, le test doit réussir.
Vous modifiez le code d'une manière qui change la nature de ce qu'une méthode ou une classe fait (bien que si de nombreux tests échouent lorsqu'une zone du code change, cela peut indiquer des tests fragiles). Cela conserve les tests documentant correctement le code.
Personnellement, j'ai trouvé que l'apprentissage du TDD est un défi intéressant, et il faut du temps pour développer une bonne "intuition". Pratiquer, pratiquer, pratiquer a été la meilleure façon d'apprendre pour moi. Cela et la lecture du code de test à partir de projets open source et maintenant aussi y contribuer tout en écrivant de nouveaux tests avec mes modifications.
la source
Il est évident que tester uniquement la valeur de retour d'une méthode est moins puissant que tester toutes les branches à l'intérieur. Les entrées alternatives ne seront pas garanties d'un comportement correct.
D'un autre côté, vous n'avez peut-être pas assez de temps ou de patience pour tout tester.
Ce que vous pouvez faire est de décider de la quantité de code que vous souhaitez couvrir avec des tests (80-90% ou autre) et de l'imposer en utilisant des outils automatisés qui le vérifient.
Un "cycle sans fin" de tests d'écriture ne se produira que si le cycle d'écriture de code est également sans fin :)
la source
Dans quelle mesure voulez-vous être certain que votre code fonctionne correctement? Les tests unitaires sont simplement un outil dans le sac du programmeur pour aider à vérifier que votre implémentation fait ce que la spécification dit qu'elle doit faire. Vous n'avez probablement pas besoin d'une couverture à 100%, mais vous devez écrire des tests unitaires pour couvrir les parties les plus critiques de votre code. Il est toujours bon de s'assurer que vos méthodes fonctionnent bien ensemble, pas seulement seules, et vous devriez donc essayer d'écrire des tests qui couvrent certaines de vos "lignes logiques" plus critiques.
la source
L'exécution de tests unitaires avec la couverture de code activée dans Visual Studio devrait vous donner une bonne indication (et graphique) de la façon dont votre code est couvert.
Si vous n'utilisez pas le cadre MSTest intégré, vous devrez peut-être consulter un produit de couverture de code tiers pour travailler avec NUnit ou suivre les instructions ici: /programming/2665799/does-vs2010-code -nouvelle-support-couverture
la source