Combien devriez-test Chaque unité de test?

Question

Combien devrait chacun de mes tests unitaires examiner? Par exemple, j'ai ce test

[TestMethod]
public void IndexReturnsAView()
{
    IActivityRepository repository = GetPopulatedRepository();
    ActivityController activityController = GetActivityController(repository);
    ActionResult result = activityController.Index();
    Assert.IsInstanceOfType(result, typeof(ViewResult));
}

et aussi

[TestMethod]
public void IndexReturnsAViewWithAListOfActivitiesInModelData()
{
    IActivityRepository repository = GetPopulatedRepository();
    ActivityController activityController = GetActivityController(repository);
    ViewResult result = activityController.Index() as ViewResult;
    Assert.IsInstanceOfType(result.ViewData.Model, typeof(List<Activity>));
}

Il est évident que si le premier test échoue, il en sera le deuxième test devrait donc ces deux être combinés en un seul test avec deux affirme? Mon sentiment est que plus granulaire des tests et moins chaque test vérifie plus vite il sera de trouver les causes des échecs. Cependant, il est en tête d'avoir un grand nombre de tests très faible, ce qui pourrait coûter du temps à courir tous les tests.

Answer 1

Je recommande de les briser autant que possible.

Il y a beaucoup de raisons à cela, à mon humble avis les plus importants sont les suivants:

• Lorsque un de vos tests échoue, vous voulez être en mesure d'isoler exactement ce qui a mal tourné aussi rapidement et aussi sûrement que possible. Avoir chaque méthode de test uniquement de test une seule chose est la meilleure façon d'y parvenir.

• Chaque test doit commencer par une table rase. Si vous créez le dépôt une fois, puis l'utiliser dans 2 ou plusieurs tests, alors vous avez une dépendance implicite de l'ordre de ces tests. Dites ajoute un élément Test1 au référentiel, mais oublie de le supprimer. Le comportement de test2 sera désormais différent, et peut-être la cause de votre échec du test. La seule exception à cette règle est des données immuables.

En ce qui concerne vos problèmes de vitesse, je ne vous inquiétez pas. Pour le code crissement pur comme celui-ci, .NET est très rapide, et vous ne serez jamais en mesure de faire la différence. Dès que vous sortez de code crissement et dans des choses comme des bases de données, vous vous sentirez les problèmes de performance, mais dès que vous faites que vous rencontrez tous les problèmes de « table rase » tel que décrit ci-dessus, vous pouvez juste à vivre avec elle (ou faire autant de vos données immuables que possible).

Bonne chance avec vos tests.

Answer 2

Plus à grains fins le mieux. Lorsqu'un assert échoue dans un cas de test, le cas de test n'est pas plus loin. Les dernières parties de l'affaire pourraient découvrir d'autres erreurs.

S'il y a un code partagé entre les cas de test, l'utilisation des fonctions de configuration / teardown pour prendre soin de vous répéter que, sans trop. coût du temps est souvent négligeable. Si la configuration / désassemblage prend trop de temps, vous n'êtes probablement pas faire des tests unitaires, mais certains tests automatisés de niveau supérieur. Les tests unitaires devraient idéalement pas le système de fichiers, réseau, base de données dépendances etc.

Answer 3

Je pense que la réponse est qu'il devrait arriver au point « standard » que s'il y a un bogue dans le code, il faut briser un test, mais pas cacher d'autres échecs (pas arrêter les autres tests de fonctionnement) lorsque celui-ci échoue. Chaque test teste une chose et deux tests ne testent pas la même chose. C'est un idéal, pas toujours atteignable. Appelez-conseils.

Cela étant dit, il est vraiment un art. Je mettrais de côté les questions de performance au départ, et se concentrer davantage sur la maintenabilité. Là, vous avez deux ans et demi à trois lignes de duplication. Si les modifications de conception, qui va se difficiles à maintenir. La duplication en soi peut être résolu par une méthode d'installation d'un déposé dans la classe, dans ce cas, mais la principale chose à vous inquiéter est maintenabilité au sujet.

Les tests devraient être assez petit pour être maintenable, facile à comprendre, et quelque chose qui le rend raisonnable pour les autres (ou vous après le temps a passé) de comprendre ce que fait le code et être en mesure de maintenir les tests.

Answer 4

Un test unitaire doit tester exactement que ce qui est décrit dans votre conception technique en perspective de la conception fonctionnelle.

Answer 5

L'approche sur combien un des tests de test est certainement quelque chose que vous devez décider avant et de s'y tenir. Je ne crois pas que tout le monde devrait suivre la même approche uniforme, puisque les différentes équipes et / ou des projets ont des priorités différentes vers le codage, la performance, le dépannage, l'infrastructure de test, etc. Mais étant compatible toujours aider:

1. plus rapide d'identifier les problèmes depuis vous savez à l'avance la profondeur à creuser;
2. passer moins de temps dans la construction vos tests;
3. employer les mêmes des classes d'aide de test en des tests d'application.
4. exécuter des tests assez vite:. Pas trop vite et pas trop lent
5. organiser des tests (suites, paquets, etc.)

Si vous décidez que la performance est plus important de mettre en œuvre des tests plus épais avec plus / asserttions validations. Si vous décidez que le dépannage est primordial d'isoler ensuite vos tests autant que nécessaire. Je ne vois pas pourquoi les tests épais et bien structurés sont imparfaites. Ces tests obtiendraient le même travail fait qu'une plus grande quantité de tests plus minces et tout aussi bien.

Bien sûr, chaque test doit toujours se concentrer sur la fonction particulière / fonctionnalité, mais ce n'est pas vraiment le sujet de ce fil.