Comment gérez-vous les tests unitaires / de régression susceptibles d'échouer au cours du développement?

https://stackoverflow.com/questions/155911

automated-tests

03-07-2019
|

Question

Pendant le développement du logiciel, il peut y avoir des bogues dans la base de code qui sont des problèmes connus. Ces bugs provoqueront l’échec des tests de régression / unité si les tests ont été bien écrits.

Il existe un débat constant au sein de nos équipes sur la façon de gérer les tests qui échouent:

Commentez les tests en échec avec un commentaire REVISIT ou TODO.
- Avantages : nous saurons toujours quand un nouveau défaut a été introduit et nous ne le connaissons pas déjà.
- Inconvénient : vous risquez d'oublier de REVISITER le scénario de test commenté, ce qui signifie que le défaut pourrait glisser entre les mailles du filet.
Laissez les tests échouer.
- Avantages : n'oubliez pas de corriger les défauts, car les échecs de script vous rappelleront constamment qu'un défaut est présent.
- Inconvénient : Difficile à détecter lorsqu'un nouveau nouveau défaut est introduit, en raison d'un bruit de défaillance.

J'aimerais explorer les meilleures pratiques à cet égard. Personnellement, je pense qu'une solution à trois États est la meilleure pour déterminer si un script réussit. Par exemple, lorsque vous exécutez un script, les éléments suivants peuvent s'afficher:

Pourcentage atteint: 75%
Pourcentage ayant échoué (prévu): 20%
Pourcentage ayant échoué (inattendu): 5%

En gros, vous marquez tous les tests élémentaires dont vous attendez à échouer (en raison d'un défaut) avec des métadonnées. Cela garantit que vous voyez toujours le résultat de l'échec à la fin du test, mais que vous savez immédiatement s'il y a un échec nouveau auquel vous ne vous attendiez pas. Cela semble prendre la meilleure partie des deux propositions ci-dessus.

Quelqu'un a-t-il des bonnes pratiques pour gérer cela?

La solution

Je laisserais vos scénarios de test dans. Selon mon expérience, commenter du code avec quelque chose comme

// TODO:  fix test case

revient à faire:

// HAHA: you'll never revisit me

Très sérieusement, au fur et à mesure que vous approchez de l’expédition, le désir de revisiter les TODO dans le code a tendance à s’affaiblir, en particulier pour les tests unitaires, car vous vous concentrez sur la correction des autres parties du code.

Laissez les tests dans peut-être avec votre " tri-state " Solution. Cependant, j’encourage fortement à régler ces cas dès que possible. Mon problème avec les rappels incessants, c’est qu’après que les gens les voient, ils ont tendance à les dissimuler et à dire: "ah oui, nous avons ces erreurs tout le temps ..."

Exemple - dans certains de nos codes, nous avons introduit l'idée de "déclarations pouvant être ignorées". - des assertions qui sont là pour vous faire savoir qu'il y a un problème, mais permettent à nos testeurs de les dépasser dans le reste du code. Nous sommes venus découvrir que QA commençait à dire des choses telles que "oh oui, nous recevons cette affirmation tout le temps et on nous a dit que c'était skippable". et les bugs n'ont pas été signalés.

Je suppose que ce que je suggère, c’est qu’il existe une autre solution, qui consiste à corriger les bogues détectés immédiatement par vos scénarios de test. Il peut y avoir des raisons pratiques de ne pas le faire, mais adopter cette habitude maintenant pourrait être plus bénéfique à long terme.

Autres conseils

Corrigez le bogue immédiatement.

Si c'est trop complexe à faire immédiatement, c'est probablement une unité trop grande pour les tests unitaires.

Perdez le test unitaire et mettez le défaut dans votre base de données de bogues. De cette façon, il a de la visibilité, peut être priorisé, etc.

Je travaille généralement dans Perl et les modules Test :: * de Perl vous permettent d'insérer des blocs TODO:

TODO: {
  local $TODO = "This has not been implemented yet."

  # Tests expected to fail go here
}

Dans la sortie détaillée de l'exécution du test, le message dans $ TODO est ajouté au rapport de réussite / échec pour chaque test du bloc TODO, afin d'expliquer pourquoi il était sur le point d'échouer. Pour le résumé des résultats des tests, tous les tests TODO sont considérés comme ayant réussi, mais, s’ils en obtiennent un, les résultats sont également comptabilisés et le nombre de tests ayant abouti de manière inattendue.

Ma recommandation serait donc de trouver un outil de test doté de fonctionnalités similaires. (Ou utilisez simplement Perl pour vos tests, même si le code testé est dans une autre langue ...)

Nous avons procédé comme suit: Mettez une hiérarchie sur les tests.

Exemple: vous devez tester 3 choses.

Testez les informations de connexion (identifiez-vous, récupérez le nom d'utilisateur, obtenez la "date de la dernière connexion" ou quelque chose de familier, etc.)
Tester la récupération de la base de données (rechercher une balise "schnitzelmitkartoffelsalat" donnée, rechercher les balises les plus récentes)
Testez les services Web (connectez-vous, obtenez le numéro de version, récupérez des données simples, récupérez des données détaillées, modifiez les données)

Chaque point de test comporte des sous-points, comme indiqué entre parenthèses. Nous divisons ces hiérarchiques. Prenons le dernier exemple:

3. Connect to a web service
    ...
3.1. Get the version number
    ...
3.2. Data:
    3.2.1. Get the version number
    3.2.2. Retrieve simple data
    3.2.3. Retrieve detailed data
    3.2.4. Change data

Si un point échoue (pendant son développement), donnez un message d'erreur exact . C'est à dire. 3.2.2. échoué. Ensuite, l'unité de test n'exécutera pas les tests pour 3.2.3. et 3.2.4. . De cette manière, vous obtenez un message d'erreur (exact): "3.2.2 échec". Laissant ainsi le programmeur pour résoudre ce problème (en premier) et non pour gérer 3.2.3. et 3.2.4. parce que cela ne marcherait pas.

Cela a beaucoup aidé à clarifier le problème et à préciser ce qui doit être fait au début.

J'ai tendance à les laisser à l'intérieur, avec un attribut Ignorer . (Ceci utilise NUnit ) - le test est mentionné dans le résultat du test donc visible, ce qui signifie que nous ne l’oublierons pas. Envisagez d’ajouter l’ID du numéro / du ticket dans le champ "Ignorer". message. De cette façon, le problème sous-jacent sera résolu si le problème sous-jacent est considéré comme mûr. Il serait bien de corriger immédiatement les tests qui échouent, mais parfois de petits bugs doivent attendre que le moment soit venu.

J'ai examiné l'attribut Explicit , qui possède L’avantage de pouvoir être exécuté sans recompiler, mais cela ne prend pas une "raison". argument, et dans la version de NUnit que nous exécutons, le test n’apparaît pas dans la sortie comme non exécuté.

Je pense que vous avez besoin d’un observateur TODO qui produise le "TODO". commentaires de la base de code. Le TODO est votre métadonnée de test. C'est une ligne devant le message d'échec connu et très facile à corréler.

Les TODO sont bons. Utilise les. Gérez-les activement en les mettant régulièrement dans l'arriéré.

# 5 sur " 12 étapes pour améliorer le code de Joel corrige des bugs avant d'écrire un nouveau code:

Si vous rencontrez un bogue dans votre code que vous voyez la première fois que vous essayez de l'exécuter, vous pourrez le réparer en un rien de temps, car tout le code est encore frais dans votre esprit.

Si vous trouvez un bogue dans un code que vous avez écrit il y a quelques jours, il vous faudra un certain temps pour le rechercher, mais lorsque vous relisez le code que vous avez écrit, vous vous souviendrez de tout et vous pourrez pour corriger le bogue dans un délai raisonnable.

Mais si vous trouvez un bogue dans le code que vous avez écrit il y a quelques mois, vous aurez probablement oublié beaucoup de choses à propos de ce code et il est beaucoup plus difficile à corriger. À ce moment-là, vous corrigez peut-être le code de quelqu'un d'autre et celui-ci se trouve peut-être à Aruba en vacances. Dans ce cas, corriger le bogue ressemble à de la science: vous devez être lent, méthodique et méticuleux et vous ne pouvez pas savoir comment. il faudra longtemps pour découvrir le remède.

Et si vous trouvez un bogue dans le code qui a déjà été livré, vous allez encourir des dépenses incroyables pour le réparer.

Mais si vous voulez vraiment ignorer les tests qui échouent, utilisez l'attribut [Ignorer] ou son équivalent dans la structure de test que vous utilisez. Dans la sortie HTML de MbUnit, les tests ignorés sont affichés en jaune, par rapport au rouge des tests ayant échoué. Cela vous permet de remarquer facilement un test qui a récemment échoué, mais vous ne perdrez pas la trace des tests ayant échoué.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow