Quelle est l'ampleur des tests unitaires?
La chose que j'ai trouvé sur le DRT est que sa prend du temps de faire des tests et d'être naturellement paresseux j'ai toujours envie d'écrire que peu de code que possible. La première chose que je semble faire, c'est de tester mon constructeur a mis toutes les propriétés, mais est-ce exagéré?
Ma question est de savoir à quel niveau de granularité ne vous vous écrire des tests unitaires à l'?
..et c'est là un cas de test trop?
Vous devez vous connecter pour publier un commentaire.
Je suis payé pour le code qui fonctionne, pas pour les tests, donc ma philosophie est de tester aussi peu que possible de parvenir à un niveau de confiance donné (je soupçonne que ce niveau de confiance est élevé par rapport aux normes de l'industrie, mais qui pourrait tout simplement être l'arrogance). Si je ne suis pas habituellement faire une sorte d'erreur (comme un mauvais réglage de la variables dans un constructeur), je n'ai pas fait de test pour elle. J'ai tendance à donner un sens à tester des erreurs, donc je suis très prudent quand j'ai de la logique compliquée avec des instructions conditionnelles. Lors du codage d'une équipe, j'ai modifier ma stratégie soigneusement le code de test que nous avons, collectivement, ont tendance à faire mal.
Des personnes différentes ont différentes stratégies de tests basée sur cette philosophie, mais qui me semble raisonnable compte tenu de l'état immature de comprendre comment les tests peuvent le mieux s'insérer dans la boucle de codage. Dix ou vingt ans à partir de maintenant, nous allons probablement le plus universel de la théorie des tests à écrire, ce qui essais de ne pas écrire, et comment faire la différence. Dans l'intervalle, l'expérimentation semble dans l'ordre.
Écrire des tests unitaires pour les choses que vous vous attendez à briser, et pour les cas limites. Après cela, les cas de test doit être ajouté en tant que rapports de bugs viennent en avant d'écrire le correctif pour le bug. Le développeur peut alors être confiant que:
Par le commentaire ci - jointe- je suppose que cette approche de l'écriture de tests unitaires pourrait causer des problèmes si beaucoup de bugs sont, au fil du temps, découvert dans une classe donnée. C'est probablement là où la discrétion est utile - l'ajout de tests unitaires uniquement pour les bugs qui sont susceptibles de se reproduire, ou lorsque leur ré-apparition pourrait causer de sérieux problèmes. J'ai constaté qu'une mesure de l'intégration des tests unitaires les tests peuvent être utiles dans ces scénarios de test de code de plus haut codepaths peut couvrir la codepaths plus bas.
L'un des plus mal compris des choses sur le DRT est le premier mot. Test. C'est pourquoi BDD est venu le long. Parce que les gens ne comprennent pas vraiment que le premier D est le plus important, à savoir le Conduit. Nous avons tous tendance à penser un peu trop à propos de l'Essai, et un petit peu à peu sur la conduite de la conception. Et je suppose que c'est une vague réponse à votre question, mais vous devriez probablement envisager la façon de conduire votre code, au lieu de ce que vous êtes réellement tester; c'est quelque chose de Couverture-outil peut vous aider avec. Le Design est un beaucoup plus grand et plus problématique.
À ceux qui proposent des tests de "tout": réaliser que "entièrement test", une méthode comme
int square(int x)
nécessite environ 4 milliards de cas de test en commun des langues et typiques des environnements.En fait, c'est même pire que ça: une méthode
void setX(int newX)
est également tenu pas de modifier les valeurs de tous les autres membres en plus dex
-- êtes-vous testsobj.y
,obj.z
, etc. tous restent inchangés à la suite de l'appel deobj.setX(42);
?C'est seulement pratique pour tester un sous-ensemble de "tout". Une fois que vous acceptez cela, il devient plus acceptable de considérer les tests incroyablement de base du comportement. Chaque programmeur a un distribution de probabilité de bug endroits; la meilleure approche est de se concentrer votre énergie sur le test des régions où vous estimez que le bug de la probabilité d'être élevé.
La réponse classique est de "tester tout ce qui peut éventuellement se briser". Je l'interpréter en ce sens que les tests de dépistage setters et getters qui ne font rien à l'exception de définir ou obtenir est probablement trop de tests, pas besoin de prendre le temps. À moins que votre IDE écrit pour vous, alors vous pourriez aussi bien.
Si votre constructeur pas définition des propriétés pourraient conduire à des erreurs plus tard, les tests qu'ils sont ensemble n'est pas exagéré.
J'écris des essais pour couvrir les hypothèses des classes, je vais écrire. Les tests de respecter les exigences. Essentiellement, si x ne peut jamais être 3, par exemple, je vais vous assurer qu'il y a un test qui couvre cette exigence.
Invariablement, si je n'écris pas un test pour couvrir une condition, il va survenir plus tard au cours de "l'homme" de test. Je vais certainement écrire un, puis, mais je préfère les attraper tôt. Je pense que le point est que l'analyse est fastidieux (peut-être), mais nécessaire. J'écris suffisamment de tests pour être complète, mais pas plus.
Une partie du problème avec saut de tests simples pour maintenant, c'est le refactoring qui pourrait faire simple propriété très compliqué avec beaucoup de logique. Je pense que la meilleure idée est que vous pouvez utiliser des Tests pour vérifier les exigences pour le module. Si lorsque vous passez X, vous devriez obtenir Y, alors c'est ce que vous voulez tester. Ensuite, lorsque vous modifiez le code un peu plus tard, vous pouvez vérifier que X vous donne Y, et vous pouvez ajouter un test pour une vous donne B, lorsque cette exigence est ajoutée plus tard.
J'ai trouvé que le temps que je passe au cours du développement initial de l'écriture des tests de paie dans la première ou la deuxième correction de bug. La capacité de ramasser code vous n'avez pas regardé dans 3 mois et être raisonnablement sûr de votre position couvre tous les cas, et "probablement" ne pas casser quelque chose est très précieuse. Vous y trouverez également que les tests unitaires va aider au triage de bugs bien au-delà de la trace de la pile, etc. De voir comment les différents éléments de l'application de fonctionner et ne parviennent pas donne d'énormes aperçu des raisons pour lesquelles ils travaillent ou échouer dans son ensemble.
Dans la plupart des cas, je dirais que, si on est logique, le tester. Cela inclut les constructeurs et les propriétés, en particulier lorsque plus d'une chose est défini dans la propriété.
À l'égard de trop de tests, c'est discutable. Certains diront que tout doit être testé pour la robustesse, d'autres disent que pour un test efficace, seulement les choses qui pourraient casser (c'est à dire la logique) doivent être testés.
J'avais penchent davantage vers le deuxième camp, juste à partir d'une expérience personnelle, mais si quelqu'un l'a fait décider de tout tester, je ne dirais pas que c'était un peu trop... un peu exagéré peut-être pour moi, mais pas trop pour eux.
Donc, Pas - je dirais il n'y a pas une telle chose comme "trop" de test dans le sens général, uniquement pour les particuliers.
Développement Piloté par les tests signifie que vous arrêtez de codage lors de tous vos tests passent.
Si vous n'avez pas de test pour une propriété, alors pourquoi devriez-vous mettre en œuvre? Si vous n'effectuez pas de test/définir le comportement à adopter en cas de "illégal" de cession, de ce que doit être la propriété de faire?
Donc je suis totalement pour les tests de tous les comportements d'une classe d'exposition. Y compris les "primitifs" propriétés.
Pour faire ce test plus facile, j'ai créé un simple NUnit
TestFixture
qui fournit des points d'extension pour le réglage/mise en valeur et prend des listes de valeurs valides et invalides et a un test simple pour vérifier si la propriété des œuvres de droite. Le test d'une seule propriété pourrait ressembler à ceci:À l'aide de lambda et les attributs de ce pourrait même être écrite de manière plus compacte. Je cueille, MBUnit a même certains la prise en charge native pour les choses comme ça. Le but, cependant, est que le code ci-dessus capture l'intention de la propriété.
P. S.: Probablement la PropertyTest devrait également avoir un moyen de vérifier que autres propriétés sur l'objet n'a pas changé. Hmm .. retour à la planche à dessin.
Je fais de test unitaire pour atteindre le maximum possible de la couverture. Si je ne peux pas atteindre un peu de code, je refactoriser jusqu'à ce que la couverture aussi complète que possible
Après avoir fini à l'aveuglement de l'écriture essai, j'ai l'habitude d'écrire un scénario de test reproduisant chaque bug
J'ai l'habitude de séparer le code de test et les tests d'intégration. Au cours de tests d'intégration, (qui sont aussi de l'unité de test, mais sur des groupes de composants, donc pas exactement ce que l'unité de test sont pour), je vais tester pour les exigences pour être correctement mis en œuvre.
Donc, plus je conduis ma programmation par l'écriture de tests, moins je m'inquiète du niveau de granuality de l'essai. En regardant en arrière, il semble que je suis en train de faire la chose la plus simple possible pour atteindre mon objectif de la validation de comportement. Cela signifie que je suis de la génération d'un calque de la confiance que mon code est de faire ce que je lui demande de faire, mais ce n'est pas considéré comme une garantie absolue que mon code est exempt de bugs. J'ai l'impression que le juste équilibre est à l'épreuve de la norme de comportement et peut-être un cas limite ou deux avant de passer à la prochaine partie de ma conception.
J'accepte que cela ne couvre pas tous les bugs et d'utiliser d'autres méthodes de test traditionnelles pour capturer ces.
Généralement, je commence petit, avec des entrées et des sorties qui, je le sais, travail. Ensuite, comme je l'ai corriger les bugs, je peux ajouter plus de tests pour s'assurer que les choses que j'ai fixe sont testés. C'est bio, et fonctionne bien pour moi.
Pouvez-vous test trop? Probablement, mais il est probablement préférable de pécher par excès de prudence en général, mais ça dépend de la façon dont la mission essentielle de votre demande.
Je pense qu'il faut tout tester dans votre "base" de votre logique métier. Getter sna Setter trop parce qu'ils ne pouvaient accepter la valeur négative ou nulle de la valeur de ce que vous pourriez ne veux pas l'accepter. Si vous avez le temps (toujours dépendre de votre patron) il est bon de tester une autre logique métier et tout contrôleur qui appellent ces objets (vous allez à partir de l'unité de test d'intégration test lentement).
Je n'ai pas de tests unitaires simples méthodes setter/getter qui n'ont pas d'effets secondaires. Mais je ne l'unité de test de chaque autre méthode publique. J'essaie de créer des tests pour toutes les conditions aux limites dans mon algorthims et de vérifier la couverture de mes tests unitaires.
C'est beaucoup de travail mais je pense que sa vaut le coup. Je serais plutôt d'écrire du code (même code de test) que le code pas à pas dans un débogueur. - Je trouver le code-build-déployer-debug cycle très long et la plus exhaustive de l'unité des tests que j'ai intégré dans mon construire la, moins je passe de temps va par le biais de ce code, la construction, le déploiement de débogage cycle.
Vous n'avez pas dit pourquoi architecture vous sont de codage trop. Mais pour Java j'utilise Maven 2, JUnit, DbUnit, Cobertura, & EasyMock.
Plus j'ai lu plus je pense que certains tests unitaires sont juste comme certains modèles: l'odeur de l'insuffisance des langues.
Lorsque vous avez besoin de tester si votre trivial de lecture renvoie en fait à la valeur de droite, c'est parce que vous pouvez mélanger getter nom et le nom de variable membre. Entrez "attr_reader :" nom de ruby, et cela ne se peut plus. Tout simplement pas possible en java.
Si votre getter est non trivial, vous pouvez encore ajouter un test pour elle alors.
Tester le code source qui vous rend inquiet à ce sujet.
N'est pas utile pour tester des portions de code dans lequel vous êtes très très à l'aise avec, tant que vous ne pas faire des erreurs en elle.
Test de corrections de bugs, de sorte que c'est la première et dernière fois que vous avez corrigé un bug.
Test pour obtenir la confiance d'un obscur parties du code, de sorte que vous créez des connaissances.
Test avant de lourdes et moyennes refactoring, de sorte que vous ne cassez pas les fonctionnalités existantes.
Cette réponse, c'est plus pour comprendre comment de nombreux tests unitaires à utiliser pour une méthode donnée que vous savez que vous voulez de test de l'unité en raison de sa criticité/importance. À l'aide de Base Chemin de Tests technique par McCabe, vous pouvez effectuer les opérations suivantes sur le plan quantitatif, ont une meilleure couverture du code de la confiance que de la simple "déclaration de couverture" ou "direction générale de couverture":