Vitesse d’exécution des tests unitaires (combien de tests par seconde ?)

https://stackoverflow.com/questions/10486

08-06-2019
|

Question

Quel type de taux d'exécution visez-vous avec vos tests unitaires (# test par seconde) ?Quelle est la durée trop longue pour un test unitaire individuel ?

J'aimerais savoir si les gens ont des seuils spécifiques pour déterminer si leurs tests sont trop lents, ou est-ce juste lorsque la friction d'une longue suite de tests prend le dessus sur vous ?

Enfin, lorsque vous décidez que les tests doivent s'exécuter plus rapidement, quelles techniques utilisez-vous pour accélérer vos tests ?

Note:les tests d'intégration sont évidemment encore une autre affaire.Nous parlons strictement de tests unitaires qui doivent être exécutés aussi fréquemment que possible.

Résumé des réponses : Merci pour les excellentes réponses jusqu'à présent.La plupart des conseils semblent être de ne pas vous soucier de la vitesse, de vous concentrer sur la qualité et de les exécuter de manière sélective s'ils sont trop lents.Les réponses avec des chiffres spécifiques incluent le fait de viser <10 ms jusqu'à 0,5 et 1 seconde par test, ou simplement de maintenir l'ensemble de la suite de tests couramment exécutés sous 10 secondes.

Je ne sais pas s'il est correct d'en marquer une comme "réponse acceptée" alors qu'elles sont toutes utiles :)

La solution

Tous les tests unitaires doivent s'exécuter en moins d'une seconde (c'est-à-dire que tous les tests unitaires combinés doivent s'exécuter en 1 seconde).Maintenant, je suis sûr que cela a des limites pratiques, mais j'ai eu un projet avec 1 000 tests qui s'exécutent aussi rapidement sur un ordinateur portable.Vous aurez vraiment besoin de cette vitesse pour que vos développeurs n'aient pas peur de refactoriser une partie essentielle du modèle (c'est-à-dire, laissez-moi aller prendre un café pendant que j'exécute ces tests... 10 minutes plus tard, il revient).

Cette exigence vous oblige également à concevoir correctement votre application.Cela signifie que votre modèle de domaine est pur et ne contient aucune référence à tout type de persistance (E/S de fichier, base de données, etc.).Les tests unitaires visent à tester ces relations commerciales.

Cela ne signifie pas que vous ignorez le test de votre base de données ou de votre persistance.Mais ces problèmes sont désormais isolés derrière des référentiels qui peuvent être testés séparément avec des tests d'intégration situés dans un projet distinct.Vous exécutez vos tests unitaires en permanence lors de l'écriture du code de domaine, puis exécutez vos tests d'intégration une fois lors de l'enregistrement.

Autres conseils

Si nous parlons strictement de tests unitaires, je viserais davantage l'exhaustivité que la vitesse.Si le temps d'exécution commence à provoquer des frictions, séparez le test en différents projets/classes, etc., et exécutez uniquement les tests liés à ce sur quoi vous travaillez.Laissez le serveur d'intégration exécuter tous les tests lors de l'enregistrement.

L’objectif est de 100 s de tests par seconde.Pour y arriver, suivez les conseils de Michael Feather. règles des tests unitaires.

Un point important qui est revenu dans le passé CITCON La discussion est que si vos tests ne sont pas aussi rapides, il est fort probable que vous ne bénéficiez pas des avantages de conception des tests unitaires.

J'ai tendance à me concentrer davantage sur la lisibilité de mes tests que sur la vitesse.Cependant, j'essaie toujours de les faire assez rapidement.Je pense que s'ils fonctionnent de l'ordre de quelques millisecondes, tout va bien.S'ils exécutent une seconde ou plus par test...alors vous faites peut-être quelque chose qui devrait être optimisé.

Les tests lents ne deviennent un problème qu'à mesure que le système mûrit et que la construction prend des heures, auquel cas vous êtes plus susceptible de rencontrer un problème de nombreux types de tests lents plutôt qu'un ou deux tests que vous pouvez optimiser facilement. .vous devriez donc probablement faire attention IMMÉDIATEMENT si vous voyez de nombreux tests s'exécutant pendant des centaines de millisecondes chacun (ou pire, des secondes chacun), plutôt que d'attendre qu'il arrive aux centaines de tests prenant ce long point (auquel cas il va être vraiment difficile de résoudre le problème).

Même ainsi, cela ne fera que réduire le temps entre le moment où votre build automatisé émet des erreurs...ce qui est bien si c'est une heure plus tard (ou même quelques heures plus tard), je pense.Le problème est de les exécuter avant votre enregistrement, mais cela peut être évité en sélectionnant un petit sous-ensemble de tests à exécuter en rapport avec ce sur quoi vous travaillez.Assurez-vous simplement de corriger la version si vous archivez du code qui interrompt des tests que vous n'avez pas exécutés !

Nous en sommes actuellement à 270 tests en environ 3 secondes.Il existe probablement environ 8 tests qui effectuent des E/S sur les fichiers.

Celles-ci sont exécutées automatiquement lors d'une construction réussie de nos bibliothèques sur chaque machine d'ingénieur.Nous effectuons des tests de fumée plus approfondis (et plus longs) qui sont effectués chaque nuit par la machine de construction, ou qui peuvent être démarrés manuellement sur une machine d'ingénieur.

Comme vous pouvez le constater, nous n'avons pas encore résolu le problème des tests trop longs.Pour moi, 10 secondes, c'est le moment où cela commence à devenir intrusif, lorsque nous commençons à nous en approcher, ce sera quelque chose que nous examinerons.Nous allons probablement déplacer les bibliothèques de niveau inférieur, qui sont plus robustes car elles changent rarement et ont peu de dépendances, vers les builds nocturnes ou vers une configuration où elles ne sont exécutées que par la machine de build.

Si vous constatez que l'exécution d'une centaine de tests prend plus de quelques secondes, vous devrez peut-être examiner ce que vous classez comme test unitaire et s'il serait mieux traité comme un test de fumée.

votre kilométrage sera évidemment très variable en fonction de votre domaine d'évolution.

Point de données – Tests de régression Python

Voici les numéros sur mon ordinateur portable pour exécuter "make test" pour Python 2.5.2 :

nombre d'essais :3851 (environ)
temps d'exécution:9 minutes, 6 secondes
taux d'exécution :7 essais/sec

Je juge mes tests unitaires test par test, et non par nombre de tests par seconde.Le taux que je vise est de 500 ms ou moins.Si c’est au-dessus, j’examinerai le test pour découvrir pourquoi cela prend autant de temps.

Quand je pense qu’un test est trop lent, cela signifie généralement qu’il en fait trop.Par conséquent, il suffit généralement de refactoriser le test en le divisant en plusieurs tests.Les autres fois où j'ai remarqué que mes tests s'exécutaient lentement, c'est lorsque le test montre un goulot d'étranglement dans mon code, alors une refactorisation du code s'impose.

Il y avait un bon article à ce sujet des jeux Power Of Two, les auteurs de TestUnit++.

Combien de temps dure trop pour un test unitaire individuel?

Je dirais que cela dépend de la vitesse de compilation.On exécute généralement les tests à chaque compilation.L'objectif des tests unitaires n'est pas de ralentir, mais d'apporter un message"rien de cassé, continue" (ou "quelque chose s'est cassé, STOP").

Je ne me soucie pas de la vitesse d'exécution des tests jusqu'à ce que cela commence à devenir ennuyeux.

Le danger est d'arrêter de faire les tests car ils sont trop lents.

Enfin, lorsque vous décidez que les tests doivent fonctionner plus rapidement, quelles techniques utilisez-vous pour accélérer vos tests?

La première chose à faire est de parvenir à découvrir pourquoi ils sont trop lents, et si le problème vient des tests unitaires ou du code testé ?

J'essaierais de diviser la suite de tests en plusieurs parties logiques, en exécutant uniquement la partie qui est soi-disant affecté par le code que j'ai modifié à chaque compilation.Je ferais moins souvent appel aux autres suites, peut-être une fois par jour, ou en cas de doute, j'aurais pu casser quelque chose, et au moins avant d'intégrer.

Certains frameworks permettent l'exécution automatique de tests unitaires spécifiques basés sur des heuristiques telles que l'heure de la dernière modification.Pour Ruby et Rails, AutoTest permet une exécution des tests beaucoup plus rapide et réactive - lorsque j'enregistre un modèle Rails. app/models/foo.rb, les tests unitaires correspondants dans test/unit/foo_test.rb courez.

Je ne sais pas si quelque chose de similaire existe pour d'autres plateformes, mais cela aurait du sens.

L'une des règles les plus importantes concernant les tests unitaires est qu'ils doivent être exécutés rapide.

Quelle est la durée trop longue pour un test unitaire individuel ?

Les développeurs devraient être capables d’exécuter toute la suite de tests unitaires en quelques secondes, et certainement pas en quelques minutes et minutes.Les développeurs devraient de toute façon pouvoir les exécuter rapidement après avoir modifié le code.Si cela prend trop de temps, ils ne prendront pas la peine de les exécuter et vous perdrez l'un des principaux avantages des tests.

Quel type de taux d'exécution visez-vous avec vos tests unitaires (# test par seconde) ?

Vous devez viser à ce que chaque test s'exécute en millisecondes, tout ce qui dépasse 1 seconde est probablement trop de tests.

Nous avons actuellement environ 800 tests qui s'exécutent en moins de 30 secondes, soit environ 27 tests par seconde.Cela inclut le temps de lancement de l’émulateur mobile nécessaire à leur exécution.La plupart d'entre eux prennent chacun 0 à 5 ms (si je me souviens bien).

Nous en avons un ou deux qui prennent environ 3 secondes, qui sont probablement candidats à la vérification, mais l'important est que l'ensemble de la suite de tests ne prend pas si longtemps qu'elle décourage les développeurs de l'exécuter et ne ralentit pas considérablement notre travail continu. construction d’intégration.

Nous avons également un délai d'expiration configurable fixé à 5 secondes : tout ce qui prend plus de temps échouera.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow