Le code en double est-il plus tolérable dans les tests unitaires?

Question

J'ai ruiné plusieurs tests unitaires il y a quelques temps, quand je suis allé à travers et remaniée pour les rendre plus SEC--l'intention de chaque essai était plus claire. Il semble y avoir un compromis entre les tests de lisibilité et de facilité de maintenance. Si je laisse le code dupliqué dans les tests unitaires, ils sont plus lisibles, mais alors si je change le SUT, je vais le traquer et de changer à chaque copie du code dupliqué.

Êtes-vous d'accord que cela existe? Si oui, préférez-vous vos tests pour être lisible, ou maintenable?

Answer 1

La lisibilité est plus importante pour les tests. Si un test échoue, vous voulez que le problème soit évident. Le développeur ne devrait pas avoir à parcourir beaucoup de code de test fortement pondéré pour déterminer exactement ce qui a échoué. Vous ne voulez pas que votre code de test devienne si complexe que vous deviez écrire des tests unitaires.

Cependant, éliminer les doubles emplois est généralement une bonne chose, à condition que cela ne masque rien. Assurez-vous simplement de ne pas dépasser le seuil des rendements décroissants.

Answer 2

Le code dupliqué est une odeur dans l'unité de test de code, tout autant que dans un autre code. Si vous avez le code dupliqué dans les tests, il est plus difficile de refactoriser le code d'implémentation parce que vous avez un nombre disproportionné de tests de mise à jour. Les Tests devraient vous aider à refactoriser avec confiance, plutôt que d'être un grand fardeau qui empêche votre travail sur le code testé.

Si la duplication est dans le gabarit mis en place, envisager de faire davantage usage de la setUp méthode ou de fournir plus (ou plus souple) Méthodes de Création.

Si la duplication est dans le code de la manipulation de la CUS, puis demandez-vous pourquoi plusieurs soi-disant "unité" des tests sont l'exercice de la exactement la même fonctionnalité.

Si la duplication est dans les affirmations, alors peut-être vous avez besoin de quelques Assertions Personnalisées. Par exemple, si plusieurs tests ont une chaîne d'affirmations comme:

assertEqual('Joe', person.getFirstName())
assertEqual('Bloggs', person.getLastName())
assertEqual(23, person.getAge())

Alors peut-être vous avez besoin d'un seul assertPersonEqual méthode, de sorte que vous pouvez écrire assertPersonEqual(Person('Joe', 'Bloggs', 23), person). (Ou peut-être vous avez simplement besoin de la surcharge de l'opérateur d'égalité sur Person.)

Comme vous le mentionnez, il est important que le code de test pour être lisible. En particulier, il est important que l' intention d'un test, c'est clair. Je trouve que si de nombreux tests de look pour la plupart les mêmes, (par exemple, les trois quarts des lignes les mêmes ou presque les mêmes), il est difficile de repérer et de reconnaître les différences significatives, sans le lire soigneusement et de les comparer. Donc, je trouve que le refactoring pour supprimer la duplication permet de lisibilité, car chaque ligne de chaque méthode de test est directement pertinent pour l'objectif du test. C'est beaucoup plus utile pour le lecteur qu'une combinaison aléatoire de lignes qui sont directement pertinents, et que les lignes sont juste des passe-partout.

Cela dit, parfois, les tests sont l'exercice de situations complexes qui sont identiques, mais encore sensiblement différents, et il est difficile de trouver un bon moyen de réduire la duplication. Utilisez votre bon sens: si vous vous sentez les tests sont lisibles et faire leurs intentions claires, et vous êtes à l'aise avec peut-être besoin de mettre à jour plus de théorie à un nombre minimal de tests lors d'un refactoring du code invoquée par les tests, puis d'accepter l'imperfection et de passer à quelque chose de plus productif. Vous pouvez toujours revenir et refactoriser les tests plus tard, quand l'inspiration est là!

Answer 3

La mise en œuvre du code et des tests sont différents des animaux et de l'affacturage règles s'appliquent différemment.

Code dupliqué ou de la structure est toujours une odeur dans la mise en œuvre du code. Lorsque vous commencez à avoir des passe-partout dans la mise en œuvre, vous avez besoin de revoir votre abstractions.

D'autre part, les tests de code doit maintenir un niveau de duplication. La Duplication de code de test permet d'atteindre deux objectifs:

• En gardant les tests découplés. Excessive d'essai de couplage peut être difficile de changer un seul test en échec qui nécessite une mise à jour parce que le contrat a changé.
• En gardant les tests significatifs dans l'isolement. Lorsqu'un test est un échec, il doit être assez simple pour savoir exactement ce que c'est de tester.

J'ai tendance à ignorer trivial duplication de code de test, à condition que chaque méthode de test des séjours plus courts que sur les 20 lignes. J'aime quand le programme d'installation-run-vérifier le rythme est apparent dans les méthodes de test.

Lorsque la duplication se glisse dans la section "vérifier" une partie des tests, il est souvent avantageux de définir des méthodes d'assertion. Bien sûr, ces méthodes doivent encore test a clairement identifié la relation qui peut être rendue apparente dans le nom de la méthode: assertPegFitsInHole -> bon, assertPegIsGood -> mauvais.

Lors de l'essai de méthodes de croître long et répétitif je trouve parfois utile de définir remplir-dans-le-blancs modèles de test que de prendre un peu de paramètres. Ensuite, le test de méthodes sont réduits à un appel à la méthode de modèle avec les paramètres appropriés.

Comme pour beaucoup de choses dans la programmation et les tests, il n'existe pas de réponse tranchée. Vous avez besoin de développer un goût, et la meilleure façon de le faire est de faire des erreurs.

Answer 4

Vous pouvez réduire le nombre de répétitions à l’aide de plusieurs types de méthodes d’utilité de test .

Je suis plus tolérant vis-à-vis de la répétition dans le code de test que dans le code de production, mais cela m'a parfois frustré. Lorsque vous modifiez la conception d'une classe et que vous devez modifier 10 méthodes de test différentes qui effectuent toutes les mêmes étapes de configuration, c'est frustrant.

Answer 5

Je suis d'accord. Le compromis existe mais est différent selon les endroits.

Je suis plus susceptible de refactoriser le code dupliqué pour configurer l'état. Mais moins susceptibles de refactoriser la partie du test qui exerce réellement le code. Cela dit, si l'exercice du code prend toujours plusieurs lignes de code, je pourrais penser que c'est une odeur et un refactor du code réel à tester. Et cela améliorera la lisibilité et la maintenabilité du code et des tests.