Smoke test, sanity test ou test de non-régression : lequel exécuter, et quand

Smoke test, sanity test ou test de non-régression : ce que vérifie chacun, quand l'exécuter, et comment exécuter les trois à partir des mêmes tests enregistrés.

Par Ait Nohaila, Chargée de développement commercial 9 min de lecture

Un smoke test vérifie qu'un nouveau build démarre et que ses fonctionnalités principales répondent. Un sanity test vérifie en profondeur un correctif ou un changement. Un test de régression vérifie que rien de ce qui fonctionnait avant n'est cassé. Ils diffèrent par leur largeur, leur profondeur et leur moment.

La plupart des équipes connaissent les trois noms et exécutent pourtant les trois à la main, quand il reste du temps. Quand une livraison est en retard, la longue passe de régression est la première chose supprimée, et un vieux bug revient sous les yeux d'un client.

Smoke test, sanity test et test de régression : la réponse courte

Imaginez votre application comme une grille : ses fonctionnalités de gauche à droite, et la profondeur à laquelle chacune est testée de haut en bas. Les trois types de tests allument des parties différentes de cette grille.

Smoke test

Large et peu profond

Ce build vaut-il la peine d'être testé ?

Sanity test

Étroit et profond

Ce correctif fonctionne-t-il ?

Test de régression

Large et profond

Autre chose est-il cassé ?

Chaque grille représente la même application : ses fonctionnalités de gauche à droite, la profondeur de test de haut en bas. Les cases allumées sont ce que regarde chaque type de test.

Qu'est-ce qu'un smoke test ?

Définition

Le smoke test, ou test de fumée, est une courte série de tests qui vérifie si un nouveau build est assez stable pour être testé.

  • Il lance l'application et touche une fois chaque fonctionnalité principale : l'application s'ouvre, un utilisateur peut se connecter, les écrans principaux se chargent, l'action clé répond.
  • Il ne regarde pas les détails.

Un build qui échoue à son smoke test retourne aussitôt chez les développeurs, et personne ne perd une journée à le tester.

Le smoke test s'appelle aussi test de vérification de build (build verification test), parce qu'il s'exécute juste après la création d'un build. Sa valeur, c'est sa rapidité : quelques minutes, à chaque build, avec un oui ou un non clair à la fin.

Qu'est-ce qu'un sanity test ?

Définition

Le sanity test est un contrôle rapide et ciblé : un correctif ou un petit changement fonctionne, et la partie de l'application qui l'entoure se comporte toujours normalement.

  • Il s'exécute sur un build qui apporte une correction de bug ou un petit changement.
  • Il va en profondeur sur cette seule partie et laisse le reste tranquille.

Quand il réussit, le build mérite la longue exécution de régression.

Fait à la main, un sanity test est souvent improvisé : le testeur clique de mémoire autour de la partie corrigée. C'est rapide, mais il ne reste aucune trace de ce qui a été regardé, et deux testeurs regardent rarement les mêmes choses.

Qu'est-ce qu'un test de régression (ou de non-régression) ?

Définition

Le test de régression exécute à nouveau les tests existants après un changement, pour vérifier que rien de ce qui fonctionnait déjà n'est cassé.

  • Il est large et profond : chaque parcours important, avec ses résultats vérifiés.
  • C'est le plus long des trois, et c'est pourquoi il s'exécute la nuit ou avant une livraison.

Cet article fait court exprès.Le guide complet, avec les types de tests de régression et ce qui a sa place dans une suite, c'est Qu'est-ce qu'un test de non-régression.

Smoke test, sanity test et test de régression, côte à côte

Ce que l'on compareSmoke testSanity testTest de régression
La question poséeCe build vaut-il la peine d'être testé ?Ce correctif fonctionne-t-il ?Autre chose est-il cassé ?
Quelle largeurToute l'applicationUne fonctionnalité ou un correctifToute l'application
Quelle profondeurPeu profond : un seul passage par fonctionnalitéProfond, à un seul endroitProfond, partout où cela compte
Quand il s'exécuteÀ chaque buildAprès un correctif ou un petit changementChaque nuit et avant une livraison
Combien de temps il prendQuelques minutesQuelques minutesUne heure ou plus, sans surveillance
Ce que signifie un échecLe build est rejetéLe correctif est renvoyéUne régression est attrapée avant que les utilisateurs la voient

Le smoke test et le sanity test sont les deux que l'on confond le plus. Le moyen de les distinguer, c'est ce qu'ils regardent : un smoke test regarde tout le build, un sanity test regarde un seul changement.

Lequel exécuter, et à quel moment d'une livraison

Les trois ne sont pas rivaux. Chacun a son moment dans une livraison, et chacun décide si le suivant vaut la peine d'être exécuté.

Chaque build

Suite de smoke tests

Quelques tests courts, quelques minutes. Un échec rejette le build.

Après un correctif ou un petit changement

Sanity test

Le test qui couvre le correctif, exécuté à nouveau, avec son résultat vérifié.

Chaque nuit, et avant une livraison

Suite de régression

Tous les tests, sans surveillance. Le rapport se lit le matin.

Plus un test est court, plus il s'exécute souvent. Le plus long s'exécute quand personne ne l'attend.

L'ordre est toujours le même.

  • D'abord le smoke test : si le build ne démarre pas ou ne connecte pas un utilisateur, rien d'autre ne vaut la peine d'être exécuté.
  • Ensuite le sanity test : si le correctif ne fonctionne pas, le build repart avant la longue exécution.
  • Enfin les tests de régression : une fois le build stable et le correctif bon, tout le reste est vérifié.

Une semaine, une application : les trois en pratique

ExempleUne application de facturation, trois jours

Les chiffres ci-dessous sont une illustration, arrondis pour l'exemple.

QuandCe qui a été exécutéCe qui a été trouvé
Lundi, un nouveau build arriveLa suite de smoke tests : se connecter, ouvrir un client, créer une facture, l'exporter. Cinq tests, quatre minutes.Tous réussissent. Le build vaut la peine d'être testé.
Mardi, un bug d'arrondi sur la TVA est corrigéUn sanity test : le test de la facture exécuté à nouveau, avec son total vérifié.Il réussit. Le correctif fonctionne.
Mardi, dans la nuitLa suite de régression : les quarante tests.Un test échoue : le total d'un avoir est faux. Le correctif l'a touché.

Le bug de l'avoir est trouvé mercredi matin par un rapport, et non trois semaines plus tard par un client. Sans l'exécution de nuit, le correctif serait parti en production avec lui.

Pourquoi les tests de régression sont les premiers sacrifiés

Faits à la main, les trois se disputent les mêmes heures.

  • Une passe de smoke tests à chaque build éloigne un testeur du vrai test plusieurs fois par jour.
  • Un sanity test fait de mémoire ne laisse aucune trace de ce qui a été regardé.
  • Une passe de régression complète prend des jours, alors elle se réduit aux écrans dont quelqu'un se souvient quand la livraison est en retard.
  • Les bugs qui reviennent sont dans les écrans pour lesquels personne n'a eu le temps.
Personne ne décide de sauter les tests de régression. Ils se font évincer, une livraison en retard après l'autre.

Automatiser les trois avec un framework codé comme Selenium ou Playwright déplace le travail vers les programmeurs : quelqu'un écrit les scripts, les marque comme smoke ou régression dans le code, et les répare chaque fois qu'un écran change.Les testeurs qui connaissent le mieux le produit ne peuvent pas y toucher.Tests manuels ou tests automatisés examine ce compromis en détail.

Avec des tests enregistrés, les trois sont les mêmes tests, regroupés autrement

GUI Test Studio automatise les tests de bout en bout de toute application sans code. Vous faites un parcours une fois dans votre application pendant que GUI Test Runner-Recorder l'enregistre, et le test se rejoue ensuite tout seul : les mêmes étapes, dans le même ordre, à chaque exécution.

Une fois vos parcours devenus des tests enregistrés, smoke tests, sanity tests et tests de régression cessent d'être trois chantiers. Ce sont trois façons de regrouper et d'exécuter les mêmes fichiers de test.

Suite de smoke tests

3 tests sur 6

Se connecterRechercher un produitPaiementHistorique des commandesRemboursementExporter les factures

À chaque build

Sanity test

1 test sur 6

Se connecterRechercher un produitPaiementHistorique des commandesRemboursementExporter les factures

Après un correctif du paiement

Suite de régression

6 tests sur 6

Se connecterRechercher un produitPaiementHistorique des commandesRemboursementExporter les factures

Chaque nuit

Six tests enregistrés, créés une seule fois. Une suite de smoke tests, un sanity test et une suite de régression sont trois façons de choisir parmi eux.
Type d'exécutionCe que c'est, avec des tests enregistrésComment elle se lance
Suite de smoke testsQuelques tests courts, un par fonctionnalité principale.Par gtr-cli, à chaque build.
Sanity testLe seul test qui couvre le correctif, exécuté à nouveau.Avec Exécuter le test, ou depuis le milieu du test.
Suite de régressionTous les tests que vous avez.Par gtr-cli, chaque nuit et avant une livraison.

Trois choses gardent les mêmes tests utilisables dans les trois rôles.

  • Chaque assertion attend ce qu'elle doit trouver et passe à la suite dès que c'est là, donc un test court reste court.
  • Un groupe d'étapes comme Se connecter est un scénario que d'autres tests réutilisent, donc il est enregistré une seule fois.
  • Le GTS Engine trouve chaque élément d'abord par les informations d'accessibilité de l'application, et à vue quand l'application ne dit rien, donc un test survit aux petits changements de l'écran.

Pourquoi une assertion qui attend vaut mieux qu'une pause de durée fixe, c'est expliqué dans Les pauses fixes dans les tests, et Scénarios montre comment les étapes d'un test sont réutilisées dans un autre.

Un sanity test n'a pas à rejouer un long test depuis son début.Dans GUI Test Studio, placez la tête de lecture là où commence la partie corrigée et choisissez Sauvegarder et exécuter depuis la tête de lecture : une fois l'application mise dans l'état qu'elle avait à ce moment, seules les étapes à partir de là s'exécutent.Exécuter un test l'explique.

Comment construire une suite de smoke tests et une suite de régression à partir des mêmes tests

Toute la mise en place tient en six petites étapes, et la première est la seule qui prend vraiment du temps.

  1. 1

    Enregistrer chaque parcours une fois

    Cliquez sur Enregistrer dans GUI Test Runner-Recorder et faites le parcours dans votre application, comme le ferait un utilisateur. Chaque parcours qui compte devient un fichier de test, avec des assertions sur ce que l'écran a montré.

  2. 2

    Partager les étapes communes sous forme de scénario

    Regroupez les étapes par lesquelles chaque test commence, comme la connexion, dans un scénario nommé Se connecter. Ajoutez ce test aux autres comme scénario, pour que la connexion soit enregistrée une fois et réutilisée.

  3. 3

    Choisir les smoke tests

    Choisissez un test court par fonctionnalité principale : l'application s'ouvre, un utilisateur se connecte, l'écran principal se charge, l'action clé répond. Gardez leurs fichiers de test ensemble dans un dossier, par exemple tests\smoke.

  4. 4

    Garder les tests plus approfondis dans un second dossier

    Mettez tous les autres tests dans un dossier tel que tests\regression. La suite de régression, ce sont les deux dossiers ensemble : tous les tests que vous avez.

  5. 5

    Exécuter les smoke tests à chaque build et tous les tests la nuit

    Sur la machine de build, gtr-cli exécute le dossier smoke après chaque build et les deux dossiers chaque nuit. Un test en échec fait échouer le build, et chaque exécution garde son rapport, sa vidéo et ses images.

  6. 6

    Après un correctif, exécuter à nouveau un seul test

    Ouvrez le test qui couvre le correctif et cliquez sur Exécuter le test : c'est votre sanity test. Sur un long test, lancez l'exécution depuis la tête de lecture dans GUI Test Studio, une fois l'application mise dans l'état qu'elle avait à ce moment.

Un sanity test, c'est un clic sur Exécuter le test, et la carte Exécutions garde le résultat à côté des précédents.

Exécuter les smoke tests à chaque build et les tests de régression chaque nuit

Sur une machine de build, gtr-cli exécute les tests en ligne de commande dans n'importe quel outil CI/CD. Il prend des fichiers de test, des dossiers et des motifs de noms, autant que vous en listez. Un dossier exécute les fichiers de test qu'il contient.

Les mêmes tests, deux moments
gtr-cli run tests\smoke --countdown 0 --junit results\smoke.xml
gtr-cli run tests\smoke tests\regression --countdown 0 --junit results\regression.xml
  • La première ligne appartient au job de build, et un test en échec fait échouer le build par le code de sortie.
  • La seconde ligne appartient à un job de nuit.
  • Chaque exécution écrit un fichier de résultats que votre outil de CI lit, et garde son rapport de confiance, sa vidéo et ses images.

Le matin, un test de régression en échec se lit, il ne se devine pas : le rapport de confiance montre l'étape qui a échoué, ce qui était attendu à côté de ce qui a été obtenu, et l'historique des exécutions précédentes.Comment lire un rapport de test montre quoi regarder en premier, et Exécuter des tests dans votre pipeline liste toutes les options de gtr-cli.

Ce qu'il faut savoir avant de commencer

LimiteCe que cela signifie
Une exécution utilise le vrai écranLes tests s'exécutent l'un après l'autre sur une machine, sauf si un test web s'exécute sans fenêtre de navigateur. Donnez à l'exécution de régression de nuit une machine de build que personne n'utilise.
Le même point de départUn test se rejoue à partir de l'état dans lequel il a été enregistré. Chaque suite doit remettre l'application dans cet état, et un test web ouvre sa propre fenêtre de navigateur vierge.
Un test vérifie ce qu'on lui a dit de vérifierUne suite de smoke tests au vert dit que les fonctionnalités principales répondent. Elle ne dit pas que chaque détail est juste : c'est le travail de la suite de régression.

Points clés

  • 1Le smoke test est large et peu profond. Il décide en quelques minutes si un build vaut la peine d'être testé.
  • 2Le sanity test est étroit et profond. Il confirme un correctif avant que la longue exécution commence.
  • 3Le test de régression est large et profond. Il prouve que le changement n'a rien cassé de ce qui fonctionnait.
  • 4Chacun a son moment : les smoke tests à chaque build, un sanity test après un correctif, les tests de régression chaque nuit et avant une livraison.
  • 5Avec des tests enregistrés, ils forment un seul ensemble de fichiers de test. GUI Test Studio les regroupe et les exécute de trois façons, sans code.

Questions

Quelle est la différence entre un smoke test et un sanity test ?

Un smoke test vérifie tout le build en surface, pour décider s'il est assez stable pour être testé. Un sanity test vérifie en profondeur un correctif ou un petit changement. Le smoke test vient en premier, à chaque build, et le sanity test suit un build qui apporte un correctif.

Quelle est la différence entre un smoke test et un test de régression ?

Un smoke test touche une fois chaque fonctionnalité principale et prend quelques minutes. Un test de régression exécute chaque parcours important avec ses résultats vérifiés, et peut prendre des heures. Un smoke test dit que le build est vivant, et un test de régression dit que rien de ce qui fonctionnait n'est cassé.

Le sanity test fait-il partie des tests de régression ?

En pratique, oui. Un sanity test est une petite tranche de la suite de régression : les tests qui couvrent la partie qui a changé. Il s'exécute juste après le correctif, et la suite de régression complète s'exécute plus tard, la nuit ou avant une livraison.

Lequel vient en premier : smoke test, sanity test ou test de régression ?

Le smoke test vient en premier, à chaque nouveau build. Le sanity test vient ensuite, quand le build apporte un correctif ou un petit changement. Les tests de régression viennent en dernier, la nuit ou avant une livraison, parce que ce sont les plus longs des trois.

Qu'est-ce qu'un test de vérification de build (build verification test) ?

Test de vérification de build est un autre nom du smoke test. Il s'exécute juste après la création d'un build et répond à une seule question : ce build est-il assez stable pour être testé plus avant.

Combien de tests faut-il dans une suite de smoke tests ?

Peu : un test court par fonctionnalité principale, en général cinq à dix en tout, pour que toute la suite s'exécute en quelques minutes. Une suite de smoke tests qui devient lente cesse d'être exécutée à chaque build, et alors elle ne protège plus rien.

Un smoke test en échec doit-il faire échouer le build ?

Oui. Un build qui échoue à son smoke test ne vaut pas la peine d'être testé plus avant, donc le pipeline doit s'arrêter et l'équipe doit être prévenue. Avec GUI Test Studio, gtr-cli se termine par un code de sortie que le pipeline lit, donc un test en échec fait échouer le build.

Peut-on automatiser les smoke tests et les tests de régression sans code ?

Oui. Avec GUI Test Studio, vous enregistrez chaque parcours une fois en le faisant dans votre application, et le test se rejoue tout seul. La suite de smoke tests et la suite de régression sont alors deux groupes des mêmes fichiers de test, exécutés par gtr-cli à chaque build et chaque nuit.

Selenium, Playwright et Windows sont des marques de leurs propriétaires respectifs.

Tous les articles