Dois-je unittest privé/protégé méthode
C'est en fait la langue agnostique. Mais je vais vous donner le contexte dans python.
J'ai cette classe parent
class Mammal(object):
def __init__(self):
""" do some work """
def eat(self, food):
"""Eat the food"""
way_to_eat = self._eating_method()
self._consume(food)
def _eating_method(self):
"""Template method"""
def _consume(self, food):
"""Template method"""
Ici eat
est la seule méthode publique alors que _consume
et _eating_method
sont effectivement protégés des méthodes qui seront mises en œuvre par les classes enfant.
Ce sera à toi de test lorsque vous avez écrit que l' Mammal
classe?
Évidemment, tous les 4 méthodes.
Maintenant, nous allons introduire un enfant
class Tiger(Mammal):
def _eating_method(self):
"""Template method"""
def _consume(self, food):
"""Template method"""
Regardez cette classe. Il a seulement 2 protégé méthodes.
Dois-je tester tous les 4 méthodes de Tiger
(y compris 2 héréditaire) ou tout simplement tester les modifications introduites (seulement surdéfini 2 méthodes)?
Ce qui est le cas idéal?
- Cela dépend. Normalement, le
eat
-méthode est testée à chaque résultat possible de_eating_method
et_consume
. Donc, seule la modification des méthodes devront être testés.
Vous devez vous connecter pour publier un commentaire.
À partir d'un point de vue théorique, vous avez seulement besoin de tester les méthodes publiques de vos classes instanciables (en standard de la programmation orientée objet les langues). Il est inutile de tester le comportement interne parce que tout ce que vous voulez est "sortie de cette entrée" (pour une méthode particulière, ou pour l'ensemble de la classe). Vous devriez essayer de respecter autant que vous le pouvez, car il vous oblige à vous poser quelques questions sur la l'encapsulation de votre classe et de la condition de l'interface qui peut être décisif pour votre architecture.
À partir d'un point de vue pragmatique,, vous pouvez parfois avoir quelques abstrait helper classes sans mise en œuvre du béton sous-classe ou d'une classe abstraite de l'affacturage de 90% de ses classes enfant et où il serait trop difficile de tester la sortie sans le brancher à une méthode protégée. Dans ces cas, vous pouvez maquette une sous-classe.
Dans votre exemple simple, je vous suggère de tester la classe
Tiger
(et uniquement la méthode publiqueeat
).Tiger.eat()
, droit?La façon dont je voudrais aborder cette est:
Mammal
qui fournit un minimum de mises en œuvre de deux protégés des méthodes qui permettent à l'unité de tester le comportement des méthodes publiques.Mammal
, mais font valoir que le comportement qui est spécifique à cette sous-classe.Cela devrait vous donner le contrôle de la couverture avec un nombre minimal de tests.
Une approche alternative serait de tester les sous-classes, et sur celui de la sous-classe de tests unitaires affirment, en outre, les fonctionnalités spécifiques à
Mammal
. Cela évite la nécessité de créer un des tests spécifiques à la sous-classe, cependant deux inconvénients sont les suivants:Mammal
dans l'isolement, et, par conséquent, les tests sur lesMammal
code spécifique sont sensibles à l'échec à cause de problèmes dans la sous-classe.Mammal
sont en cours de test.Lors de l'essai, vous devriez vous concentrer sur l'extérieur, le comportement de votre code, pas sur les détails d'implémentation. Je ne connais pas le contexte, donc je vais juste faire une énorme hypothèses ici.
Ne vous inquiétez vraiment le comportement d'un (éventuellement abrégé) Mammifère de la superclasse? Est la réutilisation par une relation d'héritage important? Que faire si vous décidez de remplacer la relation d'héritage à une composition à base de stratégie?
Je mettrait l'accent sur l'analyse du comportement des classes qui se soucient réellement: "est-ce un Tigre mange comme prévu?" au lieu de l'essai de quelques super-classe abstraite qui n'est introduit que pour la réutilisation du code.