Nous commençons une campagne pour obtenir une couverture de code ici dans mon travail et cela m’a amené à penser ... Combien de couverture de code est suffisante?

Quand arrivez-vous au point de rendements décroissants sur la couverture de code? Quel est le bon compromis entre une bonne couverture et pas assez? Cela varie-t-il en fonction du type de projet que vous réalisez (c.-à-d. WPF, WCF, Mobile, ASP.NET)? (Ce sont des classes C # que nous écrivons.)

Nous visons au moins 70%. Sur les choses qui sont plus facilement testables (structures de données fonctionnelles, par exemple), nous visons 90% et la plupart des individus visent aussi près que possible de 100%. En ce qui concerne les éléments liés à WPF et les autres cadres très difficiles à tester, nous obtenons une couverture beaucoup plus faible (à peine 70%).

Je suis d'avis que la couverture de code à elle seule est une métrique médiocre. Il est facile de produire des tonnes de tests inutiles qui couvrent le code, mais ne vérifient pas correctement le résultat, ou ne testent pas les cas extrêmes, par exemple. Le code de couverture signifie simplement qu'il ne jette pas une exception, pas que c'est juste. Vous avez besoin de tests de qualité - la quantité n'est pas si importante.

"Assez", c'est quand vous pouvez modifier votre code avec l'assurance de ne rien casser. Sur certains projets, cela pourrait être 10%, sur d'autres, cela pourrait être 95%.

Ce n'est presque jamais à 100%. Cependant, parfois, essayer d'obtenir une couverture de code à 100% peut être un excellent moyen de supprimer les éléments cruels de la base de codes. N'oubliez pas qu'il existe deux manières d'augmenter la couverture de code: rédigez davantage de tests ou supprimez du code. Si le code n'est pas couvert parce qu'il est difficile à tester, il y a de fortes chances pour que vous puissiez le simplifier ou le refactoriser pour le rendre plus facile. S'il est trop obscur pour prendre la peine de tester, il y a généralement de bonnes chances que rien d'autre dans le code ne l'utilise.

La couverture de code approche 100% de façon asymptotique. Par conséquent, les 5% restants représentent probablement plus d'effort que de valeur, car vous commencez à obtenir des rendements extrêmement faibles pour les efforts déployés.

La couverture est un paramètre à surveiller, mais ce ne devrait pas être l'objectif ultime. J'ai vu (et certes écrit!) Beaucoup de code de couverture élevée - couverture à 100% (TDD, bien sûr), mais:

• les bugs sont toujours présents
• le design peut encore être médiocre
• vous pouvez vraiment vous tuer en tirant pour une cible de couverture arbitraire - choisissez vos batailles: p

Il y a une entrée "The Way of Testivus" que je pense qu'il est approprié de faire référence ici :)

Seulement 20% de la plupart du code fonctionnera 80% du temps . Une analyse de la couverture de code n'est pas très utile si elle n'est pas associée à un graphe d'appels pour déterminer ce qui doit être testé le plus. Cela vous indique où sont susceptibles vos cas extrêmes. Vous pouvez proposer 100 tests uniquement pour les cas extrêmes, qui représentent moins de 5% du code réel.

Assurez-vous donc de couvrir 100% des 20% qui définissent les chemins critiques et au moins 50% du reste (selon le graphe d'appels). Cela devrait vous procurer une couverture totale (environ) de 70% à 75%, mais cela varie.

Ne perdez pas de temps à essayer d'obtenir une couverture totale de plus de 70% tout en laissant les cas critiques sans vérifications.

Utilisez la couverture comme guide pour indiquer les zones non testées. Plutôt que d'avoir un mandat de couverture, il est plus sage de comprendre la raison pour laquelle le code n'est pas couvert. Enregistrer une raison du manque est une bonne discipline qui permet d’équilibrer les risques.

Parfois, la raison n’est pas souhaitable «par exemple, il n’ya pas assez de temps», mais elle peut convenir à une version anticipée. Il est préférable de signaler les zones sur lesquelles revenir pour une augmentation de la couverture plus tard.

Je travaille sur un logiciel de vol critique dans lequel une couverture de 100% des déclarations est considérée comme appropriée pour des systèmes non critiques. Pour les systèmes plus critiques, nous vérifions la couverture des branches / décisions et utilisons un appel technique MC / DC qui n’est parfois pas assez strict.

Nous devons également nous assurer que nous avons également couvert le code objet.

C'est un équilibre entre le risque, dans notre cas très élevé, et le rapport qualité / prix. Un choix éclairé est nécessaire en fonction du risque de rater un bogue.

Lorsque vous commencez à envisager des modifications susceptibles d'avoir une incidence sur les performances d'exécution, la sécurité, la flexibilité ou la facilité de maintenance afin de permettre une couverture accrue du code, il est temps de mettre fin à la quête d'une couverture accrue.

J'ai des projets où ce point est égal à 0% parce que la couverture est impossible à calculer sans nuire à la conception et à d'autres projets dans lesquels elle atteint 92%.

Les métriques de couverture de code ne sont utiles que pour indiquer si vous avez peut-être manqué certains tests. Ils ne vous disent rien sur la qualité de vos tests.

Un logiciel essentiel nécessite une couverture de relevé de 100%.

Au début, cela n'a aucun sens. Tout le monde sait qu'une couverture de test complète ne signifie pas que le code est entièrement testé et qu'il n'est pas si difficile d'obtenir une couverture à 100% sans tester réellement l'application.

Néanmoins, une couverture à 100% est une limite inférieure: bien qu'une couverture à 100% ne soit pas la preuve d'un logiciel exempt de bogues, il est certain qu'avec une couverture moindre, le code n'est pas entièrement testé et c'est tout simplement inacceptable pour les logiciels critiques en espace.

J'aime beaucoup la réponse de @ RevBingo, car il suggère que la lutte à 100% peut vous amener à nettoyer ou à supprimer le code inutilisé. Ce que je n'ai pas vu dans les autres réponses, c'est une idée du moment où vous avez besoin d'une couverture élevée ou non. J'ai pris un coup de poignard pour commencer ceci. Je pense que l'ajout de détails à un tableau comme celui-ci serait une tâche plus utile que de trouver un numéro de couverture de test qui convient à tous les codes.

100%

Pour une API publique, telle que les Collections java.util, qui n'est pas couplée à une base de données et ne renvoie pas le code HTML, je pense qu'une couverture à 100% est un objectif de départ noble, même si vous vous contentez de 90 à 95% pour des raisons de temps ou autre. contraintes. L'augmentation de la couverture de test une fois que vous avez terminé la fonctionnalité oblige à un niveau de contrôle plus détaillé que d'autres types de révision de code. Si votre API est populaire, les gens l'utiliseront, la sous-classeront, la désérialiseront, etc. d'une manière inattendue. Vous ne voulez pas que leur première expérience soit de trouver un bogue, ou de superviser la conception!

90%

Pour le code d'infrastructure d'entreprise, qui prend en charge des structures de données et renvoie des structures de données, l'objectif de 100% reste probablement un bon objectif de départ, mais si ce code n'est pas suffisamment public pour inviter à une utilisation abusive excessive, peut-être que 85% est toujours acceptable?

75%

Pour le code qui récupère et renvoie Strings, je pense que le test unitaire est beaucoup plus fragile, mais peut toujours être utile dans de nombreuses situations.

50% ou moins

Je déteste écrire des tests pour des fonctions qui renvoient du HTML car il est si fragile. Et si quelqu'un change le CSS, le JavaScript ou tout le blob de HTML et d'anglais que vous renvoyez n'a aucun sens pour les utilisateurs finaux humains? Si vous pouvez trouver une fonction qui utilise beaucoup de logique métier pour produire un peu de HTML, cela peut valoir le coup d’être testé. Mais la situation inverse ne vaut peut-être pas la peine d'être testée.

Près de 0%

Pour certains codes, la définition de "correct" est "a un sens pour l'utilisateur final". Vous pouvez effectuer des tests non traditionnels sur ce code, tels que la vérification grammaticale automatisée ou la validation HTML de la sortie. J'ai même mis en place des instructions grep pour les petites incohérences dont nous sommes souvent la proie au travail, comme dire «Connexion» lorsque le reste du système l'appelle «Connexion». Cet homme ne doit pas être strictement un test unitaire, mais un moyen utile de détecter les problèmes sans attendre un résultat spécifique.

En fin de compte cependant, seul un humain peut juger de ce qui est sensible à l'homme. Les tests unitaires ne peuvent pas vous aider là-bas. Parfois, il faut plusieurs humains pour en juger avec précision.

0% absolu

C'est une catégorie triste et je me sens moins comme une personne pour l'écrire. Mais dans tout projet suffisamment important, il y a des terriers de lapin qui peuvent aspirer des semaines-personnes sans fournir d'avantages commerciaux.

J'ai acheté un livre car il prétendait montrer comment simuler automatiquement des données pour tester Hibernate. Mais il n’a testé que les requêtes Hibernate HQL et SQL. Si vous devez utiliser beaucoup de HQL et de SQL, vous n’obtenez pas vraiment l’avantage d’Hibernate. Il existe une forme de base de données Hibernate en mémoire, mais je n’ai pas investi le temps nécessaire pour comprendre comment l’utiliser efficacement lors des tests. Si cela fonctionnait, je souhaiterais bénéficier d’une couverture de test élevée (50% à 100%) pour toute logique d’entreprise qui calcule des données en naviguant sur un graphe d’objets, ce qui oblige Hibernate à exécuter certaines requêtes. Ma capacité à tester ce code est proche de 0% pour le moment et c'est un problème. J'améliore donc la couverture des tests dans d'autres domaines du projet et essaie de préférer les fonctions pures à celles qui accèdent à la base de données, principalement parce qu'il est plus facile d'écrire des tests pour ces fonctions. Encore,

Je pense que cela dépend de la partie de l'application que vous testez. Par exemple, pour la logique métier ou tout composant impliquant des transformations de données complexes, je viserais une couverture de 90% (aussi élevée que possible). J'ai souvent trouvé des bugs mineurs mais dangereux en testant le plus de code possible. Je préférerais trouver de tels bogues lors des tests que de les laisser se produire sur le site d’un client un an plus tard. En outre, une couverture de code élevée a pour avantage d'empêcher les personnes de modifier trop facilement le code de travail, car les tests doivent être adaptés en conséquence.

D'autre part, je pense qu'il existe des composants pour lesquels la couverture de code est moins adaptée. Par exemple, lors du test d’une interface graphique, il est très fastidieux d’écrire un test qui couvre tout le code qui est exécuté lorsque vous cliquez sur un bouton afin d’envoyer l’événement aux bons composants. Je pense que dans ce cas, il est beaucoup plus efficace d'utiliser l'approche traditionnelle consistant à effectuer un test manuel dans lequel il suffit de cliquer sur le bouton et d'observer le comportement du programme (la fenêtre de dialogue de droite s'ouvre-t-elle? L'outil sélectionné est-il sélectionné ?)

Je n'ai pas cette opinion très élevée sur l'utilisation de la couverture de code pour savoir quand votre suite de tests dispose d'une couverture suffisante.

La raison principale en est que si vous avez un processus dans lequel vous écrivez d'abord du code, puis des tests, puis que vous examinez la couverture de code pour savoir où vous avez manqué un test, c'est votre processus qui doit être amélioré. Si vous faites du vrai TDD, vous avez une couverture de code 100% prête à l'emploi (certes, il y a quelques anecdotes que je ne teste pas). Mais si vous regardez la couverture de code pour savoir quoi tester, alors vous écrirez probablement les mauvais tests.

La seule chose que vous puissiez conclure de la couverture de code, c'est que s'il est trop bas, vous n'avez pas assez de tests. Mais s'il est élevé, rien ne garantit que vous avez tous les bons tests.