Tests unitaires - l'avantage des tests unitaires avec des changements de contrat?

Il est préférable d'avoir à corriger les tests unitaires qui échouent en raison de changements de code intentionnels que de ne pas avoir de tests pour attraper les bogues qui sont finalement introduits par ces changements.

Lorsque votre base de code a une bonne couverture de test unitaire, vous pouvez rencontrer de nombreux échecs de test unitaire qui ne sont pas dus à des bogues dans le code mais à des changements intentionnels sur les contrats ou le refactoring de code.

Cependant, cette couverture de test unitaire vous donnera également confiance pour refactoriser le code et implémenter toutes les modifications de contrat. Certains tests échoueront et devront être corrigés, mais d'autres tests échoueront finalement en raison de bugs que vous avez introduits avec ces modifications.

Les tests unitaires ne peuvent sûrement pas attraper tous les bugs, même dans le cas idéal de 100% de couverture de code / fonctionnalité. Je pense que c'est de ne pas être prévu.

Si le contrat testé change, je (le développeur) devrais utiliser mon cerveau pour mettre à jour tout le code (y compris le code de test!) conséquent. Si Je ne parviens pas à mettre à jour quelques mocks qui produisent donc encore l'ancien comportement, c'est de ma faute, pas des tests unitaires.

C'est similaire au cas où je corrige un bug et produit un test unitaire Pour, mais j'échoue réfléchir (et tester) tous les cas similaires, dont certains se révèlent plus tard être bogués.

Donc oui, les tests unitaires ont besoin de maintenance aussi bien que le code de production lui-même. Sans entretien, ils se décomposent et pourrissent.

J'ai des expériences similaires avec les tests unitaires-lorsque vous modifiez le contrat d'une classe, vous devez souvent changer des charges d'autres tests (ce qui passera dans de nombreux cas, ce qui le rend encore plus difficile). C'est pourquoi j'utilise toujours des tests de niveau supérieur:

1. tests D'acceptation-tester quelques classes ou plus. Ces tests sont généralement alignés sur les magasins d'utilisateurs qui doivent être implémentés-vous testez donc que l'histoire de l'utilisateur "fonctionne". Ces n'avez pas besoin de vous connecter à un DB ou d'autres systèmes externes, mais peut.
2. tests D'intégration-principalement pour vérifier la connectivité du système externe, etc.
3. tests complets de bout en bout-tester l'ensemble du système

Veuillez noter que même si vous avez une couverture de test unitaire de 100%, vous n'êtes même pas assuré que votre application démarre! C'est pourquoi vous avez besoin de tests de niveau supérieur. Il y a tellement de couches différentes de tests parce que plus vous testez quelque chose, plus il est généralement moins cher (en termes de développement, de maintien infrastructure de test ainsi que le temps d'exécution).

Comme note de côté-en raison du problème que vous avez mentionné, l'utilisation de tests unitaires vous apprend à garder vos composants aussi découplés que possible et leurs contrats aussi petits que possible-ce qui est certainement une bonne pratique!

Quelqu'un a posé la même question dans le Groupe Google pour le livre "cultivons l'Objet de Logiciels Orientés - Guidés par des Tests". Le thread est les hypothèses de simulation/talon de test unitaire pourrissent .

Voici la réponse de J. B. Rainsberger (Il est l'auteur de "JUnit Recipes"de Manning).

L'une des règles pour le code de tests unitaires (et tout autre code utilisé pour les tests) est de le traiter de la même manière que le code de production - ni plus, ni moins - tout de même.

Ma compréhension de ceci est que (à part le garder pertinent, refactorisé, travailler etc. comme le code de production), il devrait être regardé de la même manière à partir de la prospective d'investissement/coût.

Probablement votre stratégie de test devrait inclure quelque chose pour résoudre le problème que vous avez décrit dans la post - quelque chose le long des lignes spécifiant quel code de test (y compris les talons/mocks) devrait être examiné (exécuté, inspecté, modifié, corrigé, etc.) lorsqu'un concepteur change une fonction/méthode dans le code de production. Par conséquent, le coût de tout changement de code de production doit inclure le coût de faire cela-sinon - le code de test deviendra "citoyen de troisième classe" et la confiance des concepteurs dans la suite de tests unitaires ainsi que sa pertinence diminuera... De toute évidence, le ROI est dans le moment de la découverte de bugs et fix.

Un principe sur lequel je compte ici est la suppression de la duplication. Je n'ai généralement pas beaucoup de faux ou de mocks différents mettant en œuvre ce contrat (j'utilise plus de faux que de mocks en partie pour cette raison). Lorsque je change le contrat, il est naturel d'inspecter chaque implémentation de ce contrat, code de production ou test. Cela me dérange quand je trouve que je fais ce genre de changement, mes abstractions auraient dû être mieux pensées peut-être etc, mais si les codes de test sont trop onéreux pour changer pour l'échelle du changement de contrat, alors je dois me demander si ceux-ci sont également dus à un refactoring.

Je le regarde de cette façon, lorsque votre contrat change, vous devriez le traiter comme un nouveau contrat. Par conséquent, vous devez créer un nouvel ensemble entier de test unitaire pour ce" nouveau " contrat. Le fait que vous ayez un ensemble existant de cas de test est en plus du point.

Je second l'avis de l'oncle Bob que le problème est dans la conception. Je voudrais en outre revenir en arrière et vérifier la conception de vos contrats.

En bref

, au Lieu de dire "return -1 pour x==0" ou "jeter CannotCalculateException pour x==y", underspecify niftyCalcuatorThingy(x,y) avec la condition x!=y && x!=0 dans des situations appropriées (voir ci-dessous). Ainsi, vos stubs peuvent se comporter arbitrairement pour ces cas, vos tests unitaires doivent le refléter, et vous avez une modularité maximale, c'est - à-dire la liberté de changer arbitrairement le comportement de votre système testé pour tous les cas sous-spécifiés-sans avoir besoin de changer de contrat ou de test.

Sous-Spécification le cas échéant

Vous pouvez différencier votre instruction "-1 quand elle échoue pour une raison quelconque" selon les critères suivants: est le scénario

1. un comportement exceptionnel que l'implémentation peut vérifier?
2. dans le domaine/la responsabilité de la méthode?
3. un exception que l'appelant (ou quelqu'un plus tôt dans la pile d'appels) peut récupérer/gérer d'une autre manière?

SI et seulement si 1) à 3) hold, spécifiez le scénario dans le contrat (par exemple que EmptyStackException est lancé lors de l'appel de pop() sur une pile vide).

Sans 1), l'implémentation ne peut garantir un comportement spécifique dans le cas exceptionnel. Par exemple, l'Objet.equals () ne spécifie aucun comportement lorsque la condition de réflexivité, de symétrie, de transitivité et de cohérence est pas rencontré.

Sans 2), Singleresponsabilityprinciple n'est pas respecté, la modularité est brisée et les utilisateurs / lecteurs du code sont confus. Par exemple, Graph transform(Graph original) ne devrait pas spécifier que MissingResourceException pourrait être lancé car au fond, un clonage via la sérialisation est effectué.

Sans 3), l'appelant ne peut pas utiliser le comportement spécifié (certaine valeur de retour/exception). Par exemple, si la JVM lance un UnknownError.

Avantages et inconvénients

Si vous spécifiez les cas où 1), 2) ou 3) ne tient pas, vous obtenez quelques difficultés:

• un but principal d'un contrat (design by) est la modularité. Ceci est mieux réalisable si vous séparez vraiment les responsabilités: lorsque la condition préalable (la responsabilité de l'appelant) n'est pas remplie, ne pas spécifier le comportement de l'implémentation conduit à une modularité maximale - comme le montre votre exemple.
• vous n'avez aucune liberté de changer dans le futur, même pas à une fonctionnalité plus générale de la méthode qui jette exception dans moins de CAs
• les comportements exceptionnels peuvent devenir assez complexes, de sorte que les contrats les couvrant deviennent complexes, sujets aux erreurs et difficiles à comprendre. Par exemple: chaque situation est-elle couverte? Quel comportement est correct si plusieurs conditions préalables exceptionnelles tiennent?

L'inconvénient de la sous-spécification est que la robustesse (test), c'est-à-dire la capacité de l'implémentation à réagir de manière appropriée à des conditions anormales, est plus difficile.

Comme compromis, j'aime utiliser le schéma de contrat suivant si possible:

Si PRE n'est pas satisfait, l'implémentation actuelle lance le RTE A, B ou C.