Quelles sont les "lignes fonctionnelles de code" normales pour "tester les lignes de test de code"?
Je suis plutôt nouvelle à l'approche TDD et mes premières expériences disent que la rédaction de 1 ligne de code fonctionnel signifie écrire environ 2-3 lignes de code de test. Donc, au cas où je vais écrire 1000 loc, toute la base de code, y compris les tests, va être quelque chose comme ~ 3500 loc.
Est-ce considéré comme normal? Quel est le rapport dans le code que vous écrivez?
1: 3 est normal avec TDD.
De mon expérience, et aussi d'autres citations que je me souviens.
Il existe des variations basées sur différents styles de codage et langues. Cependant, quelle que soit la langue que vous utilisez, la plus grande variation est de vous.
Robert Martin a dit une fois dit:
"Comme les tests deviennent plus précis, le code devient plus générique."
Cela m'a fait penser. Des tests plus spécifiques signifient plus de code de test. Plus de code de production générique signifie moins de code, de sorte que les rapports de test/de code doivent augmenter à mesure que le code évolue.
Mais attendez, ce n'est pas bon non plus. Dans certains cas particuliers, par exemple lorsque vous définissez un certain algorithme, vous n'avez peut-être que 6 à 10 lignes de code contenant un couple de "si", un certain temps et peut-être 2-3 récursions. Je peux vous dire que ce code aura probablement plus de 100 lignes de code de test.
Dans un projet réel, quelque chose de plus grand que de quelques algorithmes, le rapport test/code doit être quelque part entre 1: 1 et 2: 1. Si cela devient au-dessus de 2: 1, c'est une odeur que vous avez des tests qui doivent être refacturés ou supprimés (ou peut-être que le code est difficile à tester). Vous devez toujours investir le même montant de soins et refactoring dans vos tests comme dans votre code de production.
Toute façon, la meilleure réponse à votre question peut-être est "complexité cyclomatique" . Plus la complexité cyclomatique est élevée de votre méthode, le test exponentiellement plus important que vous devez écrire pour couvrir tous les cas.
Le rapport va varier en fonction de la taille de vos méthodes. La taille de vos méthodes variera par le style de programmation, la langue et le domaine problématique.
Si vos méthodes sont courtes, alors 3: 1 est raisonnable. Si vos méthodes sont longues, alors 3: 1 est du haut.
Donc, pour répondre à votre question, cela dépend. :-)
Pour une application critique logicielle, le ratio habituel est un jour de test pour chaque 10 LOC fonctionnel.
Et cela ne compte pas TDD qui ne concerne pas le test, mais sur la spécification.
La taille de mon code de test est d'environ la moitié de ce que le code "réel" est globalement. Cela signifie que vos tests sont trop complexes et/ou que votre code est trop difficile à tester et/ou que votre code est trop dense/complexe.
Ou vous testez simplement trop et gaspillez votre temps sur des rendements décroissants.
Voir également "Quand le test de l'unité est-il inapproprié ou inutile?"