Tests boîte noire, boîte grise et boîte blanche

Le test boîte noire ne regarde que les entrées et les sorties et ignore l'écriture du code. Le test boîte blanche lit le code et ses branches. Le test boîte grise se situe entre les deux : la personne qui teste connaît une partie des informations internes — API, logs, structures de données, événements analytics — sans lire l'implémentation ligne par ligne. Les trois vérifient la même fonctionnalité ; ce qui change, c'est la quantité d'information interne disponible, et donc les questions que l'on peut poser. Le mauvais choix coûte concrètement. Chercher en boîte noire un problème que seule la boîte grise peut voir — un type de champ modifié, par exemple — ne donnera rien après cent passes. À l'inverse, exiger que des testeurs métier lisent le code transforme le test en activité annexe des développeurs.

Les trois boîtes comparées

Dimension Boîte noire Boîte grise Boîte blanche
Connaissance interne Quasi nulle : exigences et interface API, logs, structures de données, une partie de l'implémentation Code et structure complets
Ce qui est vérifié La conformité du comportement Le comportement plus la cohérence interne Branches, bornes, couverture
Qui teste Testeurs métier, produit, customer success Testeurs connaissant l'API, développeurs Développeurs
Techniques typiques Partition d'équivalence, valeurs limites, tables de décision, transitions d'état, pairwise Vérification d'API, contrôle des logs, validation analytics, tests de contrat Tests unitaires, couverture, analyse statique
Coût Le plus faible, démarrage immédiat Moyen, nécessite environnement et documentation Le plus élevé, demande de lire du code
Ce qui échappe Les problèmes liés à des données ou environnements précis Les problèmes de synchronisation entre systèmes Les problèmes que les utilisateurs ne perçoivent pas
Un fait souvent oublié : ce qu'une équipe web fait au quotidien est majoritairement de la boîte grise, sans que ce soit nommé ainsi. Ouvrir le panneau Réseau pour lire un code de statut ou la console pour lire une erreur, c'est déjà utiliser de l'information interne.

Les cinq techniques de boîte noire

Sur l'exemple d'un formulaire de connexion :
  • Partition d'équivalence : découper les entrées en « numéro valide / format invalide / vide » et prendre un représentant de chaque.
  • Valeurs limites : un mot de passe de 8 à 20 caractères impose de tester 7, 8, 20 et 21.
  • Tables de décision : combiner « compte existant × mot de passe correct × compte verrouillé » et vérifier chaque ligne.
  • Transitions d'état : non vérifié → vérifié → verrouillé, en contrôlant chaque chemin et chaque saut illégal.
  • Pairwise : navigateur × système × langue × rôle, par paires, pour couvrir le plus de combinaisons avec le moins de cas.
  • Aucune ne demande d'information interne, et ensemble elles transforment « cliquer un peu partout » en un jeu de cas réutilisable. La rédaction des cas est traitée dans Modèles de cas de test avec exemples.

    La boîte grise en équipe web, concrètement

    Pas besoin de lire du code. Les outils de développement suffisent :
    • Requêtes : vérifier dans Réseau que l'API renvoie 200 avec un champ modifié, ou directement 4xx / 5xx ;
    • Erreurs : le texte rouge de la console est souvent plus proche de la cause que le symptôme visuel ;
    • Contrats : la doc annonce price: number, la réponse contient "12.00" — seule la boîte grise le voit ;
    • Analytics : un événement qui ne part jamais est invisible dans l'interface, mais fausse les décisions.
    Leur point commun : aucun n'est un « symptôme visible », et chacun décide si le bug est corrigé et par qui.

    Pourquoi les rapports boîte noire reviennent

    Faute de preuves. Le même incident, deux versions :
    Version Ce que fait le développeur
    « La connexion ne fait rien » Demande quel compte, quel navigateur, et si la console affiche quelque chose
    « Chrome 141 / Windows 11, compte de test A saisit le bon mot de passe sur https://example.com/login, la page ne navigue pas ; Réseau montre POST /api/login en 500, console Unhandled promise rejection » Va directement dans les logs serveur
    La différence n'est pas le style : c'est la présence des trois faits de boîte grise — environnement, requête en échec, texte d'erreur. Il y a ici une vraie tension : les testeurs boîte noire — métier, support, clients — ne devraient pas avoir à lire la console. La réponse n'est pas la formation, c'est la capture automatique : installer une extension de navigateur, ou intégrer un point d'entrée de feedback sur le site, et laisser l'outil joindre les erreurs console, les requêtes en échec, le navigateur et le viewport. C'est exactement la couche que fournit BugCapturer : la personne reste en boîte noire, le rapport arrive avec les détails de boîte grise.

    Quand la boîte noire suffit, quand la boîte grise s'impose

    Situation Recommandation Pourquoi
    Recette d'une nouvelle fonctionnalité Boîte noire On vérifie le comportement, pas l'implémentation
    Parcours de régression avant mise en ligne Boîte noire plus boîte grise sur les chemins critiques Le flux par le comportement, connexion et paiement par la requête
    Changements de champs API, intégration Boîte grise L'interface peut sembler correcte alors que les données sont fausses
    Performance et timeouts Boîte grise Il faut les durées et le taux d'échec des requêtes
    Sécurité et permissions Surtout boîte grise Une élévation de privilèges est généralement invisible dans l'interface
    Pages statiques, changements de texte Boîte noire Il n'y a pas de chaîne interne à inspecter
    La boîte blanche n'apparaît pas dans ce tableau car elle est rarement le travail du testeur : tests unitaires, couverture et analyse statique relèvent de l'auto-contrôle du développeur, sur une autre voie que la recette.

    Un exemple : un callback de paiement vu par les trois boîtes

    Même symptôme, trois profondeurs de réponse.
    • Boîte noire : le client paie, la commande reste « en attente ». Le comportement ne correspond pas, on ouvre un bug.
    • Boîte grise : Réseau montre POST /api/pay/callback en 200, mais le corps contient status: "pending" ; la console est propre. Le problème est côté serveur, dans le traitement du statut.
    • Boîte blanche : le handler écrit un log puis met à jour la commande ; l'échec de mise à jour est avalé par un catch vide. Défaut de logique, et probablement pas le seul.
    Conclusion pratique : un rapport qui atteint le deuxième niveau permet au développeur de démarrer ; un rapport bloqué au premier coûte trois allers-retours. Atteindre le niveau deux ne demande pas de lire le code, seulement de joindre cette requête.

    Inscrire les boîtes dans le plan de test

    Étape Boîte principale Livrable
    Après la revue des exigences Boîte noire Conception des cas et critères d'acceptation
    Intégration, premier build Boîte grise Vérification du contrat, inventaire des champs et codes d'erreur
    Régression avant mise en ligne Boîte noire plus boîte grise sur les chemins critiques Checklist de régression, instantanés des requêtes critiques
    Après la mise en ligne Boîte grise (logs et supervision) plus boîte noire (retours réels) Règles d'alerte, rapports utilisateurs
    L'intérêt est la répartition des responsabilités : la boîte noire répond « est-ce correct », la boîte grise « pourquoi est-ce faux », la boîte blanche « le code est-il risqué ».

    Trois prérequis pour la boîte grise

    La boîte grise ne se décrète pas. S'il manque un de ces trois points, on retombe en boîte noire :
  • Accès à l'environnement : environnement de recette joignable, compte autorisé, sinon la requête ne part même pas.
  • Visibilité sur les logs et requêtes : au minimum les outils de développement, idéalement les logs serveur.
  • Connaissance du contrat : champs, codes d'erreur et valeurs obligatoires documentés, ou quelqu'un pour répondre.
  • Le troisième manque le plus souvent. Sans contrat, on peut juger « la page est-elle correcte » mais pas « les données sont-elles correctes » — et c'est ainsi que des problèmes de champ atteignent la production.

    Trois malentendus

    • Boîte blanche égale tests unitaires : c'est l'usage le plus courant, mais la boîte blanche couvre aussi la revue de code, l'analyse de couverture et l'analyse statique.
    • Boîte grise égale lire le code : le cœur est la connaissance interne. Lire les logs et les requêtes compte ; lire l'implémentation non.
    • Automatisation égale boîte blanche : l'automatisation d'interface est généralement de la boîte noire (elle n'agit que sur l'écran), l'automatisation d'API est plus proche de la boîte grise. Technique et boîte sont deux axes distincts.

    FAQ

    Le test boîte noire demande-t-il des compétences techniques ? Pas de code, mais il faut décrire précisément un symptôme, préparer des données et juger si un comportement est attendu. Le reste des preuves peut venir d'un outil. La boîte grise exige-t-elle une documentation d'API ? Cela aide, mais ce n'est pas obligatoire : ouvrir le panneau Réseau et lire les vraies requêtes et réponses est déjà de la boîte grise. Une petite équipe peut-elle se limiter à la boîte noire ? Oui, avec deux ajouts : vérifier les requêtes des chemins critiques avant mise en ligne, et faire porter automatiquement les erreurs console et les requêtes en échec par les rapports. Les deux coûtent bien moins qu'un poste dédié. Les trois boîtes s'excluent-elles ? Non. Boîte noire en recette, boîte grise en intégration, boîte blanche en auto-contrôle : c'est une combinaison courante sur la même fonctionnalité. Comment savoir si un rapport est « assez boîte grise » ? En se demandant si un développeur peut commencer sans poser de question : environnement, requête en échec, texte d'erreur. Si les trois sont là, oui.