Unité de test de code de la couverture - avez-vous une couverture de 100%?

Pas pour plusieurs raisons :

• Il est vraiment trop cher pour atteindre les 100% de couverture, par rapport aux 90% ou de 95% pour une prestation qui n'est pas évident.
• Même avec 100% de couverture, votre code est pas parfait. Jetez un oeil à cette méthode (en fait, cela dépend du type de couverture dont vous parlez - direction de couverture, la couverture en ligne...):

public static String foo(boolean someCondition) {
    String bar = null;
    if (someCondition) {
        bar = "blabla";
    }
    return bar.trim();
}

et de l'unité de test:

assertEquals("blabla", foo(true));

Le test réussit, et votre code de couverture est de 100%. Toutefois, si vous ajoutez un autre test:

assertEquals("blabla", foo(false));

alors vous obtiendrez un NullPointerException. Et comme vous avez été à 100% avec le premier test, vous n'avez pas nécessairement écrire le second!

Généralement, je considère que le critique code doit être couvert à près de 100%, tandis que l'autre code peut être couvert à 85-90%

Non, car il existe un compromis entre l'idéal de l'unité des tests et effectivement la finition d'un projet 🙂

Oui nous faisons.

Cela dépend de la langue et le cadre que vous utilisez comme facile, qui est de parvenir à bien.

Nous sommes à l'aide de Ruby on Rails pour mon projet actuel. Ruby est très "mockable" que vous pouvez stub/se moquer de grands morceaux de votre code, sans avoir à construire en trop compliqué de la classe de composition et de construction des conceptions que vous avez à faire dans d'autres langues.

Cela dit, nous n'avons que 100% ligne de couverture (en gros ce rcov vous donne). Vous avez encore de penser à tester toutes les branches.

Ce n'est possible que si vous l'inclure dès le départ comme une partie de votre version d'intégration continue, et briser la construction si la couverture est inférieur à 100%, incitant les développeurs à corriger immédiatement il. Vous pouvez bien sûr choisir un autre numéro de la cible, mais si vous êtes de départ frais, il n'y a pas beaucoup de différence pour les efforts visant à obtenir à partir de 90% à 100%

Nous avons aussi un tas d'autres paramètres qui cassent le construire si elles franchissent un seuil donné (de la complexité cyclomatique, la duplication par exemple) ces vont tous ensemble et les aider à se renforcer les unes les autres.

Encore une fois, vous avez vraiment à avoir ce genre de choses en place depuis le début de continuer à travailler à un niveau strict - c'est ça ou définir une cible, vous pouvez frapper, et peu à peu à cliquet jusqu'à vous arrivez à un niveau que vous êtes heureux avec.

Ne faisant cela, ajouter de la valeur? J'étais sceptique au début, mais je peux honnêtement dire que oui, il le fait. Pas principalement parce que vous avez testés code (même si c'est certainement un avantage), mais plus en termes d'écrire du code simple qui est facile à tester et à raison. Si vous savez que vous ont d'avoir 100% de couverture de test, vous arrêter d'écrire trop complexe if/else/tout/try/catch monstruosités et Keep It Simple Stupid.

Personnellement, je trouve 100% de couverture de test pour être problématique sur plusieurs niveaux. D'abord et avant tout, vous devez vous assurer que vous sont de plus tangible, de réduction des coûts des prestations de l'unité de tests que vous écrivez. En outre, les tests unitaires, comme tout autre code, sont CODE. Cela signifie que, à l'instar de tout autre code, doivent être vérifiés pour l'exactitude et maintenu. Que plus de temps de la vérification de code supplémentaire de la justesse et de l'entretenir et de garder ces tests valides en réponse à des changements de code de commerce, et augmente le coût. Atteindre 100% de couverture de test et de s'assurer que vous tester, vous êtes le code de manière aussi approfondie que possible est un louable effort, mais d'atteindre à tout prix...eh bien, est souvent trop coûteuse.

Il y a beaucoup de moments où couvrant d'erreur et de contrôle de la validité qui sont en place pour couvrir frange ou extrêmement rare, mais possible, les cas exceptionnels sont un exemple de code qui n'a pas nécessairement besoin d'être couvert. Le montant de temps, effort (et en fin de compte de l'argent) qui doit être investi pour atteindre un niveau de couverture de ces rares frange est souvent gaspillage à la lumière des autres besoins de l'entreprise. Les propriétés sont souvent une partie de code, surtout avec C# 3.0, n'a pas besoin d'être testés comme la plupart, si pas tous, les propriétés se comportent exactement de la même façon, et sont excessivement simples (une seule instruction de retour ou de l'ensemble.) Investir d'énormes quantités de temps d'habillage des tests unitaires autour de milliers de propriétés pourraient très probablement être mieux investi ailleurs, un plus grand, plus de valeur tangible en terme de retour sur investissement peut être réalisé.

Au-delà de la simple réalisation de 100% de couverture de test, il y a des problèmes similaires avec la tentative de définition de la "perfection" de l'unité. Se moquant des cadres ont progressé à un degré étonnant de nos jours, presque tout peut se moque (si vous êtes prêt à payer de l'argent, TypeMock peut réellement se moquer de tout et de rien, mais il coûte beaucoup.) Cependant, il arrive souvent que les dépendances de votre code n'ont pas été écrits dans un simulacre de la mesure moyen (c'est en fait un problème majeur de la grande masse de la .NET framework lui-même.) Investir du temps pour atteindre le champ d'application d'un test est utile, mais en les plaçant dans des quantités excessives de temps à se moquer de tout et de rien sous le visage du soleil, de l'ajout de couches d'abstraction et d'interfaces pour le rendre possible, est de nouveau le plus souvent un gaspillage de temps, d'effort et de l'argent.

Le but ultime avec des tests ne devrait pas vraiment être d'atteindre le summum de la couverture de code. Le but ultime devrait être la réalisation de la plus grande valeur par unité de temps investi dans l'écriture de tests unitaires, tout en couvrant autant que possible en ce moment. La meilleure façon d'y parvenir est de prendre l'approche BDD: Indiquez vos préoccupations, de définir le contexte, et de vérifier les résultats attendus se produire pour n'importe quel morceau de comportement en cours de développement (comportement...pas d'unité.)

Sur un nouveau projet, je pratique du TDD et conserver 100% de la couverture en ligne. Il se produit principalement naturellement par la DRT. Des lacunes dans la couverture sont généralement en valeur l'attention et sont facilement remplies. Si l'outil de couverture je suis aide fournie direction de couverture ou quelque chose d'autre, je ferais attention à ce que, bien que je n'ai jamais vu branche de la couverture me dire quelque chose, probablement parce que l'ATS a obtenu en premier.

Mon principal argument en faveur du maintien de la couverture de 100% (si vous vous souciez de la couverture à tous), c'est que il est beaucoup plus facile de maintenir une couverture de 100% à gérer à moins de 100% de couverture. Si vous avez une couverture de 100% et il tombe, vous savez tout de suite pourquoi et peut facilement réparer, parce que la chute est dans le code que vous venez de travailler. Mais si vous vous arrêtez à 95% ou que ce soit, il est facile de rater la couverture des régressions et vous êtes toujours re-examiner connu des lacunes. C'est la raison exacte pour laquelle les meilleures pratiques actuelles requiert l'un de la suite de test à passer complètement. Rien de moins est plus difficile, non pas plus facile à gérer.

Mon attitude est certainement renforcé par le fait d'avoir travaillé dans le Rubis pour un certain temps, où il y a d'excellentes infrastructures de test et d'essai, les chambres doubles sont faciles. 100% de couverture est également facile en Python. Je pourrais avoir à baisser mes normes dans un environnement avec des prête moins d'outils.

J'aimerais avoir les mêmes normes sur les anciens projets, mais je n'ai jamais trouvé pratique pour emporter une grande application avec la médiocre couverture jusqu'à 100% de couverture; j'ai eu à régler pour 95% à 99%. Il a toujours été juste trop de travail pour revenir en arrière et de couvrir l'ensemble de l'ancien code. Cela ne contredit pas mon argument selon lequel il est facile de garder une base de code à 100%; il est beaucoup plus facile lorsque vous maintenez que la norme depuis le début.

J'ai l'habitude de gérer de frapper 93..100% avec ma couverture, mais je ne suis pas objectif à 100% plus. J'ai l'habitude de le faire et tout c'est faisable, ça ne vaut pas l'effort au-delà d'un certain point car les essais aveuglément évident n'est généralement pas nécessaire. Bon exemple de cela pourrait être le véritable évaluation de la direction de code suivant ciselée

public void method(boolean someBoolean) {
    if (someBoolean) {
        return;
    } else {
        /* do lots of stuff */
    }
}

Cependant ce qui est important à atteindre est de près de 100% de couverture sur fonctionnelle parties de la classe que possible, car ce sont les eaux dangereuses de votre application, la brume de la tourbière de ramper de bugs et de comportements indéfinis et bien sûr de l'argent de décisions de cirque de puces.

Je n'ai que 100% de couverture sur les nouveaux morceaux de code qui ont été écrits avec testabilité à l'esprit. Avec une bonne encapsulation, chaque classe et la fonction peut avoir fonctionnelle tests unitaires qui, simultanément, de donner à près de 100% de couverture. C'est alors qu'une question de l'ajout de certains examens complémentaires qui couvrent certains cas limites pour vous à 100%.

Vous ne devriez pas écrire des tests juste pour obtenir une couverture. Vous devriez écrire des tests fonctionnels que le test de l'exactitude ou de la conformité. Par une bonne spécification fonctionnelle qui couvre tous les motifs et une bonne conception de logiciel, vous pouvez obtenir une bonne couverture pour gratuit.

Dans de nombreux cas, ce n'est pas la peine d'obtenir 100% l'état de la couverture, mais dans certains cas, il est la peine. Dans certains cas 100% l'état de la couverture est bien trop lax une exigence.

La principale question à se poser est: "quel est l'impact si le logiciel ne parvient pas (produit le mauvais résultat)?". Dans la plupart des cas, l'impact d'un bug est relativement faible. Par exemple, vous avez peut-être d'aller corriger le code dans un délai de quelques jours, puis exécutez de nouveau quelque chose. Toutefois, si l'impact est "quelqu'un pourrait mourir dans les 120 secondes", alors que c'est un impact énorme, et vous devriez avoir un beaucoup plus d'essai de couverture de juste 100% l'état de la couverture.

Je mène la Core Infrastructure Initiative Des Meilleures Pratiques De L'Insigne pour la Linux Foundation. Nous ne 100% l'état de la couverture, mais je ne dirais pas que c'est strictement nécessaire. Pendant longtemps, nous étions très proches de 100%, et simplement décidé de faire le dernier petit pour cent. Nous ne pouvions pas vraiment justifier la dernière quelques pour cent sur l'ingénierie des raisons, cependant; ces derniers pour cent ont été ajoutés uniquement comme "la fierté de la main d'œuvre". Je fais un très petit morceau de l'esprit d'avoir une couverture de 100%, mais en réalité il n'était pas nécessaire. Nous étions plus de 90% l'état de la couverture seulement à partir des tests normaux, et c'était bon pour nos fins. Cela dit, nous voulons le logiciel afin d'être solide comme le roc, et avoir 100% l'état de la couverture nous a aidé à y arriver. Il est également plus facile d'obtenir 100% l'état de la couverture aujourd'hui.

Il est toujours utile de mesurer la couverture, même si vous n'avez pas besoin de 100%. Si vos tests n'ont pas de couverture convenable, vous devrait être concernés. Une mauvaise suite de tests pour avoir une bonne instruction de la couverture, mais si vous n'avez pas la bonne instruction de la couverture, alors, par définition, vous avez une mauvaise suite de tests. Combien vous avez besoin est un compromis: quels sont les risques (probabilité et de l'impact) à partir du logiciel qui est totalement non testés? Par définition, il est plus susceptible d'avoir des erreurs (vous n'avez pas le tester!), mais si vous et vos utilisateurs peuvent vivre avec ces risques (probabilité et de l'impact), c'est correct. Pour beaucoup de bas-impact des projets, je pense que 80%-90% l'état de la couverture est bien, avec du mieux-être mieux.

D'autre part, si les gens risquent de mourir de erreurs dans votre logiciel, puis à 100% l'état de la couverture n'est pas assez. J'aurais au moins ajouter la branche de la couverture, et peut-être plus, pour vérifier la qualité de vos tests. Les normes comme DO-178C (pour les systèmes embarqués) de prendre cette approche - si une défaillance est mineur, pas une grosse affaire, mais si une défaillance pourrait avoir des conséquences catastrophiques, alors beaucoup plus de tests rigoureux est nécessaire. Par exemple, DO-178C nécessite MC/DC couverture pour la plupart des logiciels critiques (le logiciel qui peut rapidement tuer des gens si il fait une erreur). MC/DC, c'est bien plus ardu que l'énoncé de la couverture ou de la même branche de la couverture.

Il y a un moment j'ai fait une petite analyse de la couverture du JUnit mise en œuvre, le code écrit et testé par, entre autres, Kent Beck et David Saff.

De l'conclusions:

L'application de la couverture en ligne de l'un des meilleurs testé projets dans le monde, ici est ce que nous avons appris:

1. Soigneusement l'analyse de couverture de code touchés par votre pull request est plus utile que le suivi de la couverture globale des tendances par rapport à des seuils.

2. Il peut être OK pour réduire vos normes de tests de code obsolète, mais ne laissez pas cela affecte le reste du code. Si vous utilisez la couverture des seuils sur un serveur d'intégration continue, à envisager différemment pour obsolète code.

3. Il n'y a pas de raison d'avoir des méthodes avec plus de 2-3 non testé lignes de code.

4. Les suspects habituels (simple code, le code mort, mauvais temps, comportement, ...) correspondent à environ 5% de code non couvert.

En résumé, si vous surveillez la couverture en ligne? Pas toutes les équipes de développement n', et même dans les JUnit projet, il ne semble pas être une pratique courante. Toutefois, si vous voulez être aussi bon que le JUnit développeurs, il n'ya aucune raison pourquoi votre ligne de la couverture serait en dessous de 95%. Et le suivi de la couverture est une première étape simple pour vérifier tout cela.