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.
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é ?
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 compare | Smoke test | Sanity test | Test de régression |
|---|---|---|---|
| La question posée | Ce build vaut-il la peine d'être testé ? | Ce correctif fonctionne-t-il ? | Autre chose est-il cassé ? |
| Quelle largeur | Toute l'application | Une fonctionnalité ou un correctif | Toute l'application |
| Quelle profondeur | Peu profond : un seul passage par fonctionnalité | Profond, à un seul endroit | Profond, partout où cela compte |
| Quand il s'exécute | À chaque build | Après un correctif ou un petit changement | Chaque nuit et avant une livraison |
| Combien de temps il prend | Quelques minutes | Quelques minutes | Une heure ou plus, sans surveillance |
| Ce que signifie un échec | Le 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.
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
Les chiffres ci-dessous sont une illustration, arrondis pour l'exemple.
| Quand | Ce qui a été exécuté | Ce qui a été trouvé |
|---|---|---|
| Lundi, un nouveau build arrive | La 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 nuit | La 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
À chaque build
Sanity test
1 test sur 6
Après un correctif du paiement
Suite de régression
6 tests sur 6
Chaque nuit
| Type d'exécution | Ce que c'est, avec des tests enregistrés | Comment elle se lance |
|---|---|---|
| Suite de smoke tests | Quelques tests courts, un par fonctionnalité principale. | Par gtr-cli, à chaque build. |
| Sanity test | Le seul test qui couvre le correctif, exécuté à nouveau. | Avec Exécuter le test, ou depuis le milieu du test. |
| Suite de régression | Tous 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
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
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
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
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
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
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.
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.
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
| Limite | Ce que cela signifie |
|---|---|
| Une exécution utilise le vrai écran | Les 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épart | Un 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érifier | Une 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.
À lire aussi
Tous les articles
Automatisation des tests
Tests de bout en bout : qu'est-ce que c'est ? Un guide simple avec un exemple réel
10 min de lecture

Automatisation des tests
Qu'est-ce qu'un test fonctionnel ? Exemples, types, et différence avec le test de bout en bout
9 min de lecture

Automatisation des tests
Tests manuels ou tests automatisés : pourquoi les tests manuels ne suffisent pas pour les tests de bout en bout
15 min de lecture