it-swarm-fr.com

Comment savoir quand arrêter de tester?

Je sais que c'est une question très très fondamentale. Pour certaines applications logicielles, il existe un grand nombre de cas de test presque infiniment élevé pour une application. Il n'est pas pratique de tester tous ces cas de test. Comment décidons-nous quand arrêter de tester? (autre que "quand l'argent fonctionne").

23
rsman

Le livre de Glenford Myers L'art des tests logiciels a une règle simple mais bien fondée pour cela: le test est terminé lorsque vous avez cessé de trouver des bugs. Ou, plus pratiquement, lorsque la vitesse à laquelle vous trouvez de nouveaux bugs ralentit grandement.

Les bugs ont tendance à "cluster" dans certains modules et certaines fonctions: au moment où vous trouvez un bogue dans un, vous savez que vous devriez examiner plus loin pour plus de bugs. Pour trouver des bugs, vous pouvez tilisez les techniques du test Blackbox, des tests de Whitebox et des tests de mutation. Tant que vous trouvez des bogues, vous savez que votre processus de test fonctionne!

Pour visualiser vos progrès, graphiquez le nombre de bogues que votre équipe a trouvé par jour. Si la carte est descendue, alors vous connaissez les techniques que votre équipe utilise ne les trouvera pas de toute façon. Bien sûr, si vous croyez que vos techniques ne sont pas à la hauteur, veuillez lire le livre de Myers et appliquer les principes.

Maintenant, il est possible que vous puissiez simplement manquer un nouveau correctif de bogues, et le taux de recherche de bogues aurait considérablement augmenté si vous avez continué à tester un peu plus. Cependant, si vous croyez que vos techniques sont saines, cela est peu probable.

3
Macneil

La réponse simple est que cela dépend du système. Si vous écrivez des logiciels embarqués pour un moniteur cardiaque ou des outils de surveillance de sécurité pour un réacteur nucléaire, la norme est bien supérieure à celle que si vous écrivez une plate-forme de blogging.

C'est vraiment une question pour un bon testeur de système (et je ne suis pas un) mais je vais lui donner un coup.

Votre mesure de base va être une couverture de test: quelle quantité de la demande a été testée (à la fois par test d'unité et fonctionnellement).

Vous devez évaluer chaque cas d'utilisation potentielle (et les paramètres de cet étui d'utilisation) pour le risque d'être utilisé réellement (afin que vous puissiez déposer des cas de bord), la complexité (des choses plus simples étant moins susceptibles de contenir des bugs ou plutôt moins susceptibles de contenir durement Pour trouver des bugs), le coût pour tester (en termes de temps) et l'impact potentiel d'un défaut si découverte dans cette zone (c'est là que le réacteur nucléaire vs. Plate-forme de blogging est disponible).

Sur la base de cette évaluation, vous devez déterminer lequel de ceux qui vont être testés et dans la quantité de détails. Une fois que vous avez une liste comme celle-ci (y compris un gestionnaire de produit/gestionnaire de projet/représentant de l'utilisateur) peut passer par cette liste et hiérarchiser en fonction des contraintes que vous avez.

Une technique utile à réfléchir est que vous pouvez également varier les cas d'utilisation testés avec chaque version. Par exemple, vous pourriez avoir une liste de cas de test non critiques et de tester la moitié d'entre eux avec une libération et la moitié avec le prochain (ensuite alterner). De cette façon, vous augmentez la couverture de test totale que vous obtenez pour l'effort (bien que le risque de régression des bugs soit introduit).

Cela pourrait également s'étendre aux tests de plate-forme - si vous prenez en charge deux extrémités de dos de la base de données (ou plusieurs navigateurs), testez la moitié de l'application sur une, l'autre moitié de l'autre, puis échangez ensuite la version suivante.

(Je pense que cela est appelé striping mais ne me cite pas sur cela.)

Et puis la dernière chose à penser n'est pas ce que vous testez, mais ce que vous corrigez réellement lorsque des problèmes sont découverts. Il est courant de dire "corriger tous les bugs", mais la réalité est qu'il y a des pressions de temps et que tous les bugs ne sont pas égaux. Encore une fois, les gommages d'insectes réguliers avec toutes les parties concernées sont la meilleure voie à suivre. Cela est particulièrement pertinent lorsqu'un correction de bugs peut être particulièrement intrusif car les travaux supplémentaires dans les tests de réestification et de régression qu'il génère peut surpasser l'avantage du correctif.

14
Jon Hopkins

Lorsque le risque associé à l'utilisation du logiciel a été réduit à un niveau acceptable.

4
user4051

"Les tests de programme peuvent être utilisés pour montrer la présence de bugs, mais ne jamais montrer leur absence!" --Edsger Dijkstra

Quelque chose de bien à garder à l'esprit lorsque vous effectuez des tests, automatisés ou autrement. Vous ne pouvez prouver que vous n'avez pas trouvé plus de bugs, pas qu'il n'y en a plus.

Mais plus vous mettez des yeux sur une section de code, plus vous pouvez être confiant de sa bonne opération. C'est beaucoup comme la citation de Knuth sur l'optimisation à cet égard: vous pouvez tester très facilement les mauvaises choses et vous pouvez tester aux mauvais moments de votre développement.

Essentiellement, vous voulez être couvert dans deux grands endroits:

  1. Le logiciel transmet-il les tests BDD qui le démontrent-il répond aux exigences spécifiées. Le logiciel ne peut même pas être appelé si ce n'est pas vrai.

  2. Les segments les plus critiques, complexes et les plus sûrs ont-ils des tests adéquats pour assurer la confiance? Si c'est une boucle de base, ou quelque chose que vous avez dû optimiser ou pirater à: mettez-y un test dessus. Si c'est compliqué et qu'il a beaucoup de scissions logiques: mettre beaucoup de tests dessus. Si vous ne pouvez pas le tester unitaire, ou il est intégré trop profond pour tester pratiquement: assurez-vous que le code a été examiné et que le code a été testé indirectement à la main.

3
CodexArcanum

Si vous parlez de tests unitaires et que vous faites TDD (écrire d'abord les tests), il s'agit d'un non-problème: vous arrêtez simplement de tester lorsque les fonctionnalités sont effectuées.

En incrémental TDD, vous écrivez un test qui échoue, puis implémentez la plus petite quantité de code pouvant le faire passer, puis le refacteur. Continuez à ajouter des tests de cette manière jusqu'à ce que la méthode soit complète.

voici un excellent exemple.

2
Brad Cupit

Les statisticiens ont également examiné ce problème - en fait dès que dans les années 1970-1980. Compte tenu des hypothèses appropriées sur la découverte des bugs, ils tentent d'estimer le nombre de bogues à partir des données des tests. Ceci est ensuite utilisé pour déterminer quand arrêter de fonctionner en optimisant une fonction de perte. Voir par exemple https://rpubs.com/hoehle/1792 ... pour un bref traitement de l'un des documents sur cette question, y compris le code R sur la manière de le faire dans la pratique.

Bien sûr, un problème sera toujours les hypothèses sur le processus de découverte de bugs. Par exemple, dans le traitement ci-dessus, il est supposé que les bugs sont découverts indépendamment l'un de l'autre. En pratique, la fixation d'un gros bug peut, par exemple, provoquer de nouveaux bugs, etc., mais cela donne un démarrage et des suppléments de sensations intestinales.

2
mhatsu

Si vous attendez que le projet finisse, vous aurez effectivement un très grand nombre de cas de test. Si vous livrez continuellement, concentrez-vous sur de petites livraisons, vous aurez moins de cas de test à chaque itération et vous pourrez tout tester. Si vous ne pouvez pas faire de petites livraisons, priorisez-vous et commencez à tester à partir de la plus grande priorité et de tester jusqu'à ce que vous deviez vous arrêter.

2
Fernando

Jamais, je pense que vous ne finirez jamais de tester dans un système .. Il y a tellement de variables que vous ne pouvez pas gérer.

Mais comme nous le savons, vous ne pouvez pas tester "pour toujours", alors je pense que la limite dépend essentiellement de:

  • Lorsque le risque associé à l'utilisation du logiciel a été réduit à un niveau acceptable. (comme @graham Lee dit)
  • Qui est l'utilisateur du système? Cela peut être vous ou le président des États-Unis. Dans le premier cas, vous ne vous souciez pas beaucoup si un bogue apparaît parce que vous le résolvez et c'est fait. Dans le second cas, vous ne voulez pas que aucun bogue apparaisse.
  • Quelle est votre relation avec votre client? Peut-être que le client est votre père, donc ce n'est pas si terrible, ou peut-être que c'est une grande entreprise.
  • Quelle est la gravité pour les utilisateurs du système un bug? Cela causera-t-il la troisième guerre mondiale ou juste un message laid?
1
Diego

Les premières choses à tester constitueraient le "chemin heureux", les cas de bord et les entrées non valides. S'il y aura plus d'un utilisateur simultané, vous devrez tester des problèmes de concurrence, tels que des conditions de verrouillage et de course. Si l'application utilise des ressources externes, vous devrez tester comment l'application se comporte lorsque ces ressources sont indisponibles. Après cela, vous pouvez utiliser le code pour rechercher des choses qui pourraient le causer de casser et de tester pour ceux-ci. Lorsque tous ces tests passent, le rapport coûts/avantages de nouveaux tests commence à monter, il est donc raisonnable de s'arrêter à ce stade.

1
Larry Coleman

Tout se résume à une question de confiance. Vous êtes-vous convaincu que le système est suffisamment testé?

De toute évidence, le "niveau de confiance" est très subjectif puisque vous ne pouvez jamais vous sentir complètement certain, mais assez certain - et c'est ce que nous recherchons. Pour cela, vous devez créer une liste d'indicateurs, communément appelée définition de faite et devrait être quelque chose que toute votre équipe accepte.

Voici quelques tests "Indicateurs causés" liés:

  • Votre construction et votre installation sont-elles complètement automatisées et que tous les tests (unité, interface graphique, intégration) sont-ils automatiquement exécutés?
  • Écrivez-vous vos tests tandis que (ou de préférence avant) écriture du code plutôt qu'après?
  • Vous sentez-vous assez en sécurité pour faire refactoring important de code sans introduire des bugs?
  • Votre niveau de couverture de code est-il assez élevé?
  • Avez-vous un testeur dédié dans votre équipe? Est-il/elle impliquait quotidiennement tout au long du développement et non seulement à la fin?
  • Votre testeur a-t-il manuellement (exploratoire) essayé de le casser sans succès?

Si vous pouvez vérifier ces points, vous pouvez probablement dire que vous avez suffisamment testé.

1
Martin Wickman

Lorsque la date d'expédition est arrivée. Il n'y a pas de fin à tester un logiciel. Mais là encore, il y a quelque chose de connu sous le nom de calendrier. Vous devrez tester la plupart de vos fonctionnalités dans l'heure prévue et résoudre les bugs que vous rencontrez. Vous ne pouvez pas garantir que le logiciel est parfait.

1
Manoj R

Lorsque les personnes qui doivent signer sur le déploiement sont satisfaites.

ou dans certains cas, la majorité des parties responsables sont satisfaites.

0
Bill