Yury Pukhov, YuSMP Group
Yury Pukhov CEO & Mobile Engineering Lead, YuSMP Group
Ajouter YuSMP comme source préférée sur Google
TL;DR : Le smoke test en développement logiciel est une courte série de vérifications exécutée sur chaque nouveau build pour confirmer que ses fonctions les plus critiques marchent avant le début des tests approfondis. Si l’application démarre, que les utilisateurs peuvent se connecter et que le parcours principal aboutit, le build est accepté ; si une seule vérification échoue, il est rejeté immédiatement, ce qui épargne des heures de QA perdues.

Qu’est-ce que le smoke test en développement logiciel ? C’est le premier coup d’œil rapide sur un build tout neuf : une poignée de vérifications qui répondent à une seule question, « ce build est-il assez stable pour mériter d’être testé ? » Si l’application refuse de démarrer, si la page de connexion affiche une erreur ou si le paiement n’aboutit jamais, inutile de lancer une suite de régression de deux heures. Le smoke test le détecte en quelques minutes et renvoie le build directement aux développeurs.

Les smoke tests sont une pièce modeste mais porteuse de tout dispositif sérieux de services de test logiciel. Ils se placent entre les tests unitaires, dont les développeurs ont la charge, et les suites fonctionnelles, de régression et de bout en bout, plus lentes, et ils servent de barrière qui décide si ces suites plus lentes seront exécutées. Les équipes qui sautent cette étape découvrent généralement les builds cassés de la manière la plus coûteuse, après que les testeurs ou les clients y ont déjà perdu du temps.

Ce guide couvre la définition, l’origine du terme, la différence entre smoke test, test de vérification du build, sanity test et test de régression, le bon moment pour en lancer un, un processus étape par étape, une checklist type, la mise en place en CI/CD avec un exemple de pipeline, les outils de 2026, les avantages et les limites, ainsi que les bonnes pratiques qui gardent une suite de smoke tests rapide et fiable.

Qu’est-ce que le smoke test en développement logiciel ?

Le smoke test (ou test de fumée) est une vérification large et superficielle d’un nouveau build logiciel qui contrôle que ses fonctions les plus importantes marchent, afin que l’équipe puisse décider d’accepter le build pour la suite des tests ou de le rejeter. Il ne cherche pas à trouver tous les bugs. Il cherche les bugs qui rendent tous les autres tests inutiles.

Le Glossaire ISTQB, vocabulaire de référence des testeurs logiciels dans le monde entier, définit le smoke test comme « une suite de tests qui couvre les fonctionnalités principales d’un composant ou d’un système afin de déterminer s’il fonctionne correctement avant le début des tests planifiés ». Trois idées de cette définition comptent en pratique :

  • Uniquement les fonctionnalités principales. Un smoke test couvre les chemins critiques : lancer l’application, se connecter, charger l’écran principal et réaliser la transaction centrale. Les cas limites sont laissés pour plus tard.
  • La largeur plutôt que la profondeur. Il effleure de nombreuses zones du système au lieu d’en explorer une seule en détail.
  • Avant les tests planifiés. Il s’exécute en premier, comme critère d’entrée. Un smoke test en échec arrête le pipeline ; un smoke test réussi ouvre la voie aux tests fonctionnels, de régression et de performance.

Le résultat d’un smoke test est binaire : soit le build « passe le smoke » et continue, soit il « échoue au smoke » et retourne au développement. C’est ce résultat simple qui rend les smoke tests si faciles à automatiser et si utiles comme barrière.

Qu’est-ce qu’un smoke test en développement logiciel, en termes simples ?

En termes simples, un smoke test en développement logiciel est un bilan de santé rapide d’un nouveau build. Pensez au mécanicien qui tourne la clé, vérifie que le moteur démarre, que les phares s’allument et que les freins répondent avant de programmer une révision complète. Personne ne fait une révision complète sur une voiture qui ne démarre pas, et personne ne devrait lancer un cycle de tests complet sur un build qui ne démarre pas non plus.

D’où vient le terme « smoke test » ?

Le terme vient de l’électronique et de la plomberie, bien avant le logiciel. Les ingénieurs électroniciens mettaient sous tension une carte fraîchement assemblée pour la première fois et guettaient la fumée : pas de fumée signifiait que la carte pouvait au moins être testée sérieusement sans danger. Les plombiers envoyaient une fumée inoffensive dans une nouvelle installation pour repérer les fuites.

Nouvelle carte électronique mise sous tension pour la première fois avec des sondes de test branchées, l’origine matérielle du smoke test

Le logiciel a repris l’idée dans les années 1990. L’article de Steve McConnell « Daily Build and Smoke Test », publié dans IEEE Software en juillet 1996, la décrivait comme « une pratique courante chez Microsoft et dans d’autres éditeurs de logiciels grand public ». Dans ce processus, le produit entier était compilé chaque jour, puis soumis à une vérification relativement simple pour voir s’il « fume » à l’exécution. McConnell prenait l’exemple du projet Windows NT 3.0 : environ 5,6 millions de lignes de code réparties dans 40 000 fichiers source, avec un build complet pouvant durer jusqu’à 19 heures, et une équipe de build de quatre personnes qui réalisait malgré tout le build quotidien et le smoke test.

Le principe n’a pas changé depuis. Ce qui a changé, c’est la vitesse : en 2026, un pipeline construit et soumet au smoke test une application web en quelques minutes, à chaque merge, au lieu d’une fois par nuit.

Smoke test et test de vérification du build : est-ce la même chose ?

Oui, dans la plupart des équipes, smoke test et test de vérification du build (BVT, build verification test) désignent la même chose : un ensemble de vérifications qui décide si un nouveau build est assez bon pour être testé. La seule nuance tient à l’accent. « BVT » souligne que la vérification est automatisée et s’exécute sur chaque build ; « smoke test » est le terme courant, plus large.

Le Glossaire ISTQB définit le test de vérification du build comme « un test automatisé qui valide l’intégrité de chaque nouveau build et vérifie ses fonctionnalités clés ou centrales, sa stabilité et sa testabilité ». Comparez avec la définition du smoke test ci-dessus et le recouvrement saute aux yeux. On rencontre aussi, pour la même idée, les noms de test d’admission (intake test), test de confiance (confidence test) et test d’acceptation du build.

Pourquoi le sanity test est parfois appelé smoke test

La terminologie varie selon les sources, ce qui sème la confusion dans beaucoup d’équipes. Le Glossaire ISTQB cite sanity test, intake test et confidence test comme synonymes de smoke test. La plupart des praticiens et des éditeurs d’outils emploient pourtant « sanity test » pour quelque chose de plus étroit : une vérification rapide d’un correctif ou d’une fonctionnalité précise après une modification mineure. Ce guide suit l’usage des praticiens et compare les deux en détail plus bas. Quels que soient les mots retenus par votre équipe, fixez-les dans votre stratégie de test pour que « le smoke a échoué » signifie la même chose pour tout le monde.

Pourquoi le smoke test est-il important ?

Le smoke test est important parce qu’il arrête les builds cassés au moment le moins coûteux possible, avant que les testeurs, les environnements de staging et les clients n’y consacrent du temps. Une vérification de cinq minutes qui rejette un mauvais build peut épargner à une équipe QA une journée entière d’investigation, et à une équipe de release un rollback d’urgence.

Le coût des défauts détectés tard est bien documenté. Le Planning Report 02-3 du NIST (2002) estimait qu’une infrastructure de test logiciel insuffisante coûtait à l’économie américaine environ 59,5 milliards de dollars par an, dont près de 22,2 milliards auraient pu être évités grâce à des tests plus précoces et de meilleure qualité. Les smoke tests ne remplacent pas des tests approfondis, mais ils comptent parmi les moyens les moins chers d’avancer la détection des défauts.

Au quotidien, une suite de smoke tests fiable apporte à l’équipe :

  • Un signal clair, go ou no-go. Personne ne débat de la testabilité d’un build ; c’est la barrière qui tranche.
  • Un temps QA protégé. Les testeurs commencent chaque cycle sur un build dont on sait qu’il démarre et réalise son parcours principal.
  • Un retour plus rapide aux développeurs. Un merge cassé est signalé en quelques minutes, tant que la modification est encore fraîche.
  • Des déploiements plus sûrs. Les smoke tests post-déploiement détectent les erreurs de configuration et d’environnement qui n’apparaissent jamais dans les tests unitaires.
  • Une référence qualité visible. L’évolution du taux de réussite du smoke montre si la branche principale gagne ou perd en stabilité.

C’est aussi une application directe de l’approche shift-left : exécuter les vérifications les plus importantes le plus tôt et le plus souvent possible.

Quand faut-il lancer des smoke tests ?

Lancez un smoke test chaque fois que le logiciel change d’une manière qui pourrait casser son fonctionnement de base : à chaque nouveau build, avant tout cycle de tests planifié et juste après chaque déploiement. Dans un pipeline CI/CD, cela signifie généralement plusieurs fois par jour. Les déclencheurs habituels sont les suivants :

  1. Un nouveau build est produit, qu’il provienne d’un merge sur la branche principale ou d’un build nocturne.
  2. Avant le début des tests fonctionnels ou de régression, comme critère d’entrée du cycle QA.
  3. Après un déploiement sur un environnement de test ou de staging, pour confirmer que l’environnement, la configuration et les données sont correctement branchés.
  4. Immédiatement après une mise en production, comme vérification post-déploiement des chemins critiques en ligne.
  5. Après des changements d’infrastructure, comme une mise à niveau de base de données, une nouvelle région cloud, une rotation de certificat ou une montée de version de dépendance.
  6. Après un hotfix, pour confirmer que le correctif n’a cassé ni le démarrage ni le parcours principal.

L’étape de staging mérite une attention particulière : un build peut réussir tous les tests sur le poste d’un développeur et échouer quand même dans un environnement aux secrets, feature flags ou données différents. Notre guide du staging en développement logiciel explique comment garder cet environnement assez proche de la production pour que les résultats du smoke aient un sens.

Qui réalise les smoke tests ?

Le smoke test relève généralement des ingénieurs QA ou d’automatisation des tests qui conçoivent la suite, mais dans les équipes modernes il s’exécute automatiquement et toute l’équipe agit en fonction du résultat. Qui le lance réellement dépend de la maturité de l’équipe :

  • Les ingénieurs QA choisissent les chemins critiques, écrivent les cas de smoke test et maintiennent la suite en bon état.
  • Les développeurs exécutent la suite en local avant de pousser et corrigent immédiatement un smoke en échec, car il bloque tout le monde.
  • Les ingénieurs DevOps ou plateforme intègrent la suite au pipeline CI/CD et aux vérifications post-déploiement.
  • Les release managers considèrent un smoke réussi comme une condition obligatoire pour promouvoir un build.

Dans les petites équipes sans testeurs dédiés, les développeurs prennent en charge tout le processus. Cela fonctionne, à condition qu’une personne soit explicitement responsable de garder la suite courte et fiable.

Comment réaliser un smoke test : 6 étapes

Pour réaliser un smoke test, identifiez les quelques fonctions sans lesquelles le produit ne peut pas vivre, transformez-les en cas de test courts et reproductibles, exécutez-les sur chaque nouveau build dans un environnement proche de la production, puis acceptez ou rejetez le build sur la base d’un résultat unique, réussite ou échec. Les étapes ci-dessous s’appliquent aux produits web, mobiles et API.

  1. Identifiez les chemins critiques. Listez les parcours qui rendraient le produit inutilisable s’ils étaient cassés : démarrage, connexion, écran principal, transaction centrale (paiement de panier, réservation, règlement, envoi de fichier) et toute intégration dont dépend l’activité.
  2. Écrivez des cas de test courts et indépendants. Un test par vérification critique, chacun capable de s’exécuter seul avec des données de test connues. Limitez le nombre d’étapes et gardez des résultats attendus sans ambiguïté.
  3. Préparez l’environnement et les données. Utilisez un environnement stable, proche de la production, avec des comptes préremplis et des moyens de paiement de test. Les smoke tests qui dépendent de données partagées et changeantes deviennent vite instables.
  4. Exécutez la suite sur le nouveau build. Déclenchez-la automatiquement depuis le pipeline, ou déroulez la checklist à la main pour les produits très jeunes.
  5. Prenez une décision go ou no-go. Tout échec rejette le build. Pas de « réussite avec exceptions » : si une vérification n’est pas critique, elle n’a pas sa place dans la suite de smoke tests.
  6. Signalez et corrigez. Transmettez l’échec, les logs et les captures d’écran aux développeurs à l’origine de la modification, corrigez le build et relancez le smoke avant tout autre test.

Que contient une suite de smoke tests ? Une checklist type

Une bonne suite de smoke tests ne contient que les vérifications dont l’échec rendrait la suite des tests inutile, en général entre 5 et 30 cas de test exécutés en quelques minutes. La liste exacte dépend du produit, mais la plupart des suites couvrent le démarrage, l’authentification, la navigation, la transaction centrale et les intégrations clés.

Exemple de smoke test : une application web e-commerce

Le tableau ci-dessous présente une checklist de smoke test réaliste pour une boutique en ligne. Chaque ligne correspond à une vérification unique avec une condition de réussite claire.

#VérificationCondition de réussite
1La page d’accueil se chargeHTTP 200, navigation principale et grille de produits visibles
2L’utilisateur peut se connecterLe compte de test se connecte et voit son nom de compte
3La recherche renvoie des résultatsUn produit connu apparaît pour une requête connue
4La fiche produit s’ouvrePrix, images et bouton « Ajouter au panier » s’affichent
5Le panier fonctionneL’article est ajouté et le total du panier se met à jour
6La commande aboutitLe paiement par carte de test réussit en sandbox, le numéro de commande s’affiche
7La confirmation de commande est envoyéeL’événement ou l’e-mail de confirmation arrive dans la boîte de test
8L’endpoint de santé est au vertL’API, la base de données et le prestataire de paiement sont signalés en bonne santé

Remarquez ce qui manque : les cas limites de remises, les règles de validation d’adresse, chaque moyen de paiement, la compatibilité navigateurs. Tout cela relève des suites fonctionnelles et de régression. Le smoke test prouve seulement que la boutique peut prendre une commande.

Exemples de smoke tests pour les applications mobiles et les API

Pour une application mobile, une suite de smoke tests vérifie généralement que l’application s’installe et se lance sans plantage, que l’écran d’onboarding ou de connexion apparaît, qu’un utilisateur peut se connecter, que l’écran d’accueil charge les données du backend et que l’inscription aux notifications push réussit. Pour une API, elle vérifie que le service démarre, que l’endpoint de santé répond, que l’authentification renvoie un jeton, et qu’un appel en lecture et un appel en écriture sur la ressource principale réussissent avec les codes de statut et la forme de réponse attendus.

Types de smoke tests : manuels, automatisés et hybrides

Le smoke test peut être manuel, automatisé ou un mélange des deux. Les smoke tests automatisés sont le choix standard pour tout produit doté d’un pipeline CI/CD, tandis que les vérifications manuelles gardent leur intérêt pour les produits très jeunes et pour les contrôles visuels ou propres à un appareil, difficiles à automatiser.

TypeFonctionnementIdéal pourPrincipal inconvénient
ManuelUn testeur suit une courte checklist écrite sur chaque buildPrototypes, MVP, versions peu fréquentesLent, irrégulier, ne tient pas la cadence de nombreux builds par jour
AutomatiséDes scripts exécutent les vérifications depuis le pipeline CI/CD sur chaque buildProduits aux merges et déploiements fréquentsDemande un effort initial et une maintenance continue
HybrideVérifications centrales automatisées plus quelques contrôles manuels des visuels ou des appareilsApplications mobiles, produits riches en interfaceLa partie manuelle peut être discrètement sautée sous la pression des délais

Le smoke test aux différents niveaux de test

Les smoke tests ne se limitent pas au système complet. Les équipes lancent souvent un smoke à plusieurs niveaux : un smoke d’intégration confirme que les services démarrent et communiquent entre eux, un smoke système confirme que les parcours critiques de bout en bout fonctionnent dans un environnement déployé, et un smoke d’acceptation confirme qu’une release candidate est prête pour les utilisateurs métier. Les tests unitaires s’exécutent déjà à chaque modification, on les appelle donc rarement smoke tests, même si une étape unitaire en échec bloque le pipeline de la même façon. Pour voir comment les tests unitaires s’inscrivent dans l’ensemble, consultez notre article sur le test unitaire en développement logiciel.

Smoke test, sanity test et test de régression

Le smoke test vérifie qu’un nouveau build est assez stable pour être testé, le sanity test vérifie qu’un correctif précis ou une petite modification fonctionne comme prévu, et le test de régression vérifie que les fonctionnalités existantes marchent toujours après n’importe quel changement. Ils s’échelonnent dans cet ordre de profondeur : le smoke est le plus large et le plus superficiel, la régression la plus profonde et la plus lente.

AspectSmoke testSanity testTest de régression
Question à laquelle il répondCe build est-il testable ?Ce correctif ou ce changement fonctionne-t-il ?Autre chose a-t-il cassé ?
PérimètreLarge et superficiel, tous les chemins critiquesÉtroit, centré sur la zone modifiéeLarge et profond, tout le produit
QuandÀ chaque nouveau build et déploiementAprès une correction de bug ou une modification mineureAvant les releases et après des changements importants
Durée typiqueQuelques minutesDe quelques minutes à une heureDes heures, parfois des jours en manuel
Scénarisé ?Oui, une suite fixe et stableSouvent non scénarisé ou ad hocOui, une grande suite maintenue
Généralement automatisé ?Presque toujoursParfoisEn majorité, avec quelques contrôles manuels
Conséquence d’un échecBuild rejeté, aucun autre testCorrectif renvoyé au développeurRelease bloquée jusqu’à la correction des défauts

Un moyen simple de retenir la différence : le smoke demande « est-ce que ça tourne ? », le sanity demande « ce que nous venons de modifier tient-il la route ? » et la régression demande « tout ce qui marchait marche-t-il encore ? » Pour une vue d’ensemble des types de tests et de la façon dont les équipes QA les combinent, consultez notre guide de l’assurance qualité dans le développement logiciel.

Comment le smoke test fonctionne-t-il dans un pipeline CI/CD ?

Dans un pipeline CI/CD, la suite de smoke tests s’exécute automatiquement juste après les étapes de build et de tests unitaires, puis de nouveau juste après chaque déploiement ; si elle échoue, le pipeline s’arrête et le build n’est pas promu. Le smoke test passe ainsi d’une habitude manuelle à une barrière qualité imposée.

Ingénieur consultant un écran de pipeline où chaque vérification smoke d’un nouveau build est au vert

Une séquence typique ressemble à ceci : build, tests unitaires, déploiement sur un environnement de test, smoke tests, puis suites fonctionnelles et de régression plus longues, puis déploiement en production, puis smoke test post-déploiement sur la production. Les deux étapes de smoke détectent des problèmes différents. Le smoke avant release attrape le code cassé ; le smoke post-déploiement attrape la configuration, les secrets, les migrations et l’infrastructure cassés.

Voici un job GitHub Actions simplifié qui exécute une suite de smoke tests Playwright sur un environnement de staging fraîchement déployé et fait échouer le pipeline si un seul smoke test échoue :

smoke-test:
  needs: deploy-staging
  runs-on: ubuntu-latest
  timeout-minutes: 10
  steps:
    - uses: actions/checkout@v4
    - run: npm ci
    - run: npx playwright install --with-deps chromium
    - name: Run smoke suite against staging
      run: npx playwright test --grep @smoke
      env:
        BASE_URL: https://staging.example.com

Deux détails font que cela fonctionne en pratique. Le tag @smoke permet à l’équipe de garder les smoke tests dans le projet de test principal tout en n’exécutant que le sous-ensemble tagué, et la limite timeout-minutes empêche un environnement bloqué de paralyser le pipeline pendant une heure. Le même principe s’applique à GitLab CI, Jenkins, Azure DevOps ou tout autre runner. Pour la conception complète du pipeline, consultez notre guide du CI/CD en développement logiciel.

Combien de temps doit durer une suite de smoke tests ?

Une suite de smoke tests devrait en général se terminer en moins de 5 à 10 minutes, et beaucoup d’équipes visent moins de 5. Au-delà, elle ne fournit plus de retour rapide, et les développeurs commencent à l’ignorer ou à la contourner. Quand une suite dépasse cette limite, déplacez les vérifications les plus lentes ou les moins critiques vers la suite de régression plutôt que d’accepter une barrière plus lente.

Les outils de smoke test en 2026

La plupart des équipes construisent leurs smoke tests avec les outils d’automatisation qu’elles utilisent déjà pour les tests fonctionnels, puis taguent un petit sous-ensemble comme suite de smoke. Le bon outil dépend de ce que vous testez : une interface web, une application mobile ou une API.

CoucheOutils courantsVérifications smoke typiques
Interface webPlaywright, Cypress, Selenium WebDriverChargement des pages, connexion, parcours utilisateur principal
MobileAppium, Espresso (Android), XCUITest (iOS), MaestroInstallation, lancement sans plantage, connexion, données de l’écran d’accueil
APIPostman avec Newman, REST Assured, pytest avec requests, k6Endpoint de santé, jeton d’authentification, un appel en lecture et un en écriture
Exécuteurs de testsJUnit, TestNG, pytest, Jest, VitestRegroupement et tag du sous-ensemble smoke
CI/CDGitHub Actions, GitLab CI, Jenkins, Azure DevOpsExécution de la suite comme barrière après build et déploiement
Contrôles en productionMonitoring synthétique de votre plateforme d’observabilitéVérifications planifiées de type smoke sur les chemins critiques en ligne

Le choix de l’outil compte moins que la discipline. Une suite Playwright de dix tests exécutée à chaque merge vaut davantage qu’un framework sophistiqué que personne ne maintient.

Avantages et limites du smoke test

Le principal avantage du smoke test est de détecter en quelques minutes, pour un coût très faible, les défauts qui cassent le build ; sa principale limite est qu’il ne dit presque rien de la qualité de tout ce qui se trouve en dehors des chemins critiques. Un smoke test réussi signifie « digne d’être testé », pas « prêt pour la release ».

AvantagesLimites
Détecte les défaillances critiques quelques minutes après un buildSuperficiel par conception, passe à côté de la plupart des défauts fonctionnels
Fait gagner du temps à la QA en rejetant les builds non testablesPeut donner une fausse confiance s’il est traité comme une validation de release
Facile à automatiser et à exécuter à chaque modificationDemande de la maintenance à mesure que les parcours critiques évoluent
Détecte les erreurs d’environnement et de configuration après déploiementLes tests instables érodent vite la confiance dans la barrière
Fournit un signal go ou no-go simple et partagéRalentit si les équipes continuent d’ajouter des vérifications non critiques

Bonnes pratiques du smoke test

Les meilleures suites de smoke tests sont courtes, stables, automatisées et strictement limitées aux chemins critiques ; la plupart des échecs du smoke test viennent de suites devenues trop grosses ou trop instables pour inspirer confiance. Ces sept pratiques gardent une suite utile :

  1. Restez petit. Commencez avec 5 à 15 vérifications et n’en ajoutez une nouvelle que si son échec rendrait la suite des tests inutile.
  2. Fixez un budget de temps. Mettez-vous d’accord sur une durée maximale, par exemple 5 minutes, et traitez tout dépassement comme un défaut.
  3. Rendez chaque test indépendant. Chaque vérification doit créer ou réinitialiser ses propres données et pouvoir s’exécuter dans n’importe quel ordre.
  4. Corrigez ou supprimez immédiatement les tests instables. Une barrière qui échoue au hasard apprend aux gens à relancer et à ignorer.
  5. Exécutez la suite dans un environnement proche de la production. Même style de configuration, mêmes intégrations en mode sandbox, données réalistes.
  6. Lancez un smoke test sur la production après chaque release. Utilisez des comptes en lecture seule ou dédiés aux tests pour que les vérifications en ligne ne touchent jamais les données réelles des clients.
  7. Révisez la suite chaque trimestre. Supprimez les vérifications des fonctionnalités retirées et ajoutez-en pour les nouveaux parcours critiques.

Les indicateurs à suivre pour votre suite de smoke tests

Suivez quelques chiffres simples pour savoir si la suite de smoke tests fait son travail : le taux de réussite du smoke sur la branche principale, la durée médiane de la suite, le taux d’échecs instables (des échecs qui passent à la relance) et le nombre de défauts trouvés à des étapes ultérieures qu’un smoke test aurait dû attraper. Ils s’inscrivent naturellement à côté des indicateurs de livraison comme le taux d’échec des changements, que notre guide des KPI du développement logiciel explique.

Les erreurs courantes de smoke test

L’erreur la plus courante consiste à laisser la suite de smoke tests se transformer en mini-suite de régression, trop longue et trop souvent en échec. D’autres problèmes fréquents se repèrent facilement une fois qu’on les connaît :

  • Tester des cas limites dans la suite de smoke au lieu des parcours critiques nominaux.
  • Ne lancer le smoke qu’avant les releases plutôt qu’à chaque build, ce qui retarde le retour de plusieurs jours.
  • Sauter le smoke post-déploiement, si bien que les erreurs de configuration atteignent d’abord les utilisateurs.
  • Partager des données de test entre les tests, ce qui provoque des échecs aléatoires quand les tests tournent en parallèle.
  • Autoriser le contournement manuel d’un smoke en échec « juste pour cette fois », ce qui annule la barrière.

Si vos releases cassent encore dès le premier jour malgré une suite de smoke tests, un audit QA indépendant peut examiner quels chemins critiques sont réellement couverts, mesurer les taux d’instabilité et les durées, et reconstruire la barrière pour que l’équipe lui fasse de nouveau confiance.

Questions fréquentes

Qu’est-ce que le smoke test en développement logiciel ?

Le smoke test en développement logiciel est une série rapide de vérifications exécutée sur chaque nouveau build pour confirmer que ses fonctions les plus critiques marchent, comme le lancement, la connexion et la réalisation de la transaction centrale. Il décide si le build est assez stable pour des tests plus approfondis. Un smoke test en échec rejette le build immédiatement, pour que les testeurs ne perdent pas de temps sur un logiciel fondamentalement cassé.

Qu’est-ce qu’un smoke test en développement logiciel, avec un exemple ?

Un smoke test est une vérification courte, automatisée ou manuelle, des chemins critiques d’un build. Pour une boutique en ligne, un smoke test peut confirmer que la page d’accueil se charge, qu’un utilisateur de test peut se connecter, qu’un produit peut être ajouté au panier et qu’un paiement en sandbox aboutit avec un numéro de commande. Si l’une de ces vérifications échoue, le build retourne aux développeurs avant le début de tout autre test.

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

Le smoke test est une vérification large et superficielle qui confirme qu’un nouveau build complet est assez stable pour être testé. Le sanity test est une vérification ciblée qui confirme qu’un correctif de bug précis ou une petite modification fonctionne comme prévu. Le smoke test s’exécute sur chaque build et est presque toujours automatisé, tandis que le sanity test intervient après des modifications ciblées et se fait souvent à la main. Certains glossaires, dont celui de l’ISTQB, traitent les deux termes comme des synonymes.

Le smoke test est-il la même chose que le test de régression ?

Non. Le smoke test ne vérifie que les chemins critiques d’un nouveau build, en quelques minutes, pour décider s’il est testable. Le test de régression réexécute une suite beaucoup plus vaste pour confirmer que les fonctionnalités existantes marchent toujours après une modification, et il peut prendre des heures. Le smoke test s’exécute en premier, comme barrière ; le test de régression intervient plus tard, avant une release.

Combien de tests une suite de smoke tests doit-elle contenir ?

La plupart des suites de smoke tests contiennent entre 5 et 30 tests, et le bon nombre correspond au plus petit ensemble qui couvre chaque chemin critique du produit. Une règle utile consiste à n’inclure une vérification que si son échec rendrait inutile toute la suite des tests. Si la suite dure plus de 5 à 10 minutes environ, elle est probablement devenue trop grosse.

Les smoke tests peuvent-ils être automatisés ?

Oui, et pour tout produit doté d’un pipeline CI/CD, ils devraient l’être. Les smoke tests automatisés s’exécutent à chaque build et déploiement avec des outils comme Playwright, Cypress, Appium ou Postman avec Newman, et ils bloquent le pipeline quand une vérification critique échoue. Les checklists de smoke manuelles gardent leur intérêt pour les premiers prototypes et pour les contrôles visuels difficiles à automatiser.

Qui est responsable du smoke test ?

Les ingénieurs QA ou d’automatisation des tests conçoivent et maintiennent généralement la suite de smoke tests, les ingénieurs DevOps l’intègrent au pipeline CI/CD, et les développeurs corrigent tout build qui y échoue. Dans les petites équipes sans testeurs dédiés, les développeurs prennent en charge tout le processus. Quel que soit le responsable, une personne doit clairement répondre de la rapidité et de la fiabilité de la suite.

Sources