Accueil / Articles

Des scripts aux objectifs : l’IA agente pour les tests de qualité sur le web, les API et les bases de données.

IA agente pour le contrôle qualité : automatisation des tests qui vise un objectif plutôt que des étapes, avec des agents pour le web, les API et les bases de données, MCP en tant que lien, une mémoire et ses limites réelles.

Éditeur : REACTAPP.TOP6 min de lecture1429 mots

Sources: The Day My Test Scripts Stopped Listening — And My Agents Started Thinking : —

Qu’est-ce qui change lorsque l’automatisation de tests cesse de recevoir des instructions sur quels boutons appuyer pour recevoir plutôt des objectifs à atteindre ? Cette question a donné naissance à une petite expérience open source en matière d’IA agente pour l’ingénierie de qualité, et ce texte explique ce que tente cette expérience, où elle est utile et où elle ne l’est pas.

Un mardi ordinaire

On lance le paquet de tests de régression et des croix vertes apparaissent une à une. Tout le monde se détend, mais un bug finit quand même par être intégré, car le script ne savait faire que ce qui lui était explicitement demandé, et dans l’ordre précis indiqué.

La question persistante est de savoir si l’automatisation pourrait raisonner plutôt que de se contenter de répéter des actions. Personne ne promet ici de miracle. L’objectif est de voir si des agents IA peuvent compléter le jugement d’un testeur sans prétendre le remplacer.

Automatisation scriptée et automatisation axée sur des objectifs

La plupart des suites de tests actuelles suivent une séquence bien définie : cas de test, script, exécution, vérification, rapport. Ce processus est déterministe, prévisible et sûr. Cependant, il est également rigide, fragile et incapable de gérer tout ce que le script ne mentionne pas. Une suite de tests basée sur des scripts est comme un train sur des rails fixes : rapide et fiable tant que les rails ne bougent pas.

La version agente inverse cette organisation :

  • On donne à l’agent un objectif de test plutôt qu’un script prédéfini.
  • On le laisse déterminer ce qui doit être fait.
  • On le laisse choisir les outils (navigateur, client API, base de données) en fonction du contexte.
  • On le laisse observer les résultats et ajuster ses prochaines actions.
  • On le laisse valider et générer un rapport.

Ainsi, la demande cesse d’être « exécutez ces étapes prédéfinies » pour devenir « voici l’objectif, trouvez un moyen d’y parvenir ». Il s’agit davantage d’un changement de mentalité que d’un changement d’outils.

Pourquoi le QA est un choix adapté

Les logiciels modernes ne se limitent rarement à une seule couche. Un seul défaut peut exister dans l’interface utilisateur, l’API et la base de données, et ne se manifester qu’en vérifiant ces trois éléments ensemble. On attend de plus en plus des testeurs qu’ils pensent comme des ingénieurs en systèmes, et la question est passée de « le bouton fonctionne-t-il ? » à « le système distribué dans son ensemble se comporte-t-il correctement dans des conditions réelles ? ».

Imaginons qu’un seul agent puisse coordonner ces différentes couches autour d’un objectif commun, plutôt que trois ensembles indépendants. La conception se divise alors en :

  • Un agent web qui pilote le navigateur.
  • Un agent API qui envoie des requêtes et analyse les réponses.
  • Un agent de base de données qui vérifie les données en arrière-plan.
  • Une couche de raisonnement qui planifie et décide quel agent appeler et quand.
  • Une couche de validation qui fusionne tout cela en un résultat exploitable.

Plutôt que de devoir reconstituer mentalement trois rapports, on obtient un seul verdict coordonné.

Esquisse de l’architecture

Le flux présenté ci-dessous est encore en évolution délibérée. Il s’agit d’une expérience en cours, et non d’un cadre finalisé, et les progrès réels en ingénierie arrivent rarement déjà complètement formés.

User / Goal
     ↓
Agentic AI Layer (Reasoning + Planning)
     ↓
   ┌──────────┬──────────┬──────────┐
   │ Web Agent│ API Agent│ DB Agent │
   └──────────┴──────────┴──────────┘
     ↓            ↓            ↓
  Browser       APIs       Database
     ↓            ↓            ↓
        Validation / Result

MCP en tant que tissu conjonctif

Le Model Context Protocol, MCP, est la composante de cet écosystème qui mérite une attention particulière. Pensez-y comme un connecteur standard entre les agents et les capacités réelles, permettant à un agent non seulement de décrire ce qu’il ferait, mais aussi de le faire réellement.

Cela ouvre des possibilités pour les tests de qualité :

  • la connexion des agents à de véritables outils de test ;
  • une interaction structurée avec le navigateur ;
  • des opérations API directes ;
  • un accès aux bases de données sans avoir à créer constamment des solutions sur mesure ;
  • une mémoire et un contexte persistants ;
  • des bibliothèques réutilisables d’outils d’automatisation.

Le processus devient alors : comprendre l’objectif, choisir une capacité, utiliser l’outil, observer le résultat, décider de la prochaine étape. Cela diffère fortement de la méthode « étape un, étape deux, étape trois ».

Les tests API en tant que capacité

Les tests API ne disparaîtront pas, mais leur forme évolue. Plutôt que d’utiliser une collection Postman statique qui effectue toujours les mêmes vérifications, un agent pourrait :

  • envoyer des requêtes dérivées d’un objectif précis ;
  • évaluer la réponse dans son contexte, au-delà de la simple correspondance des codes d’état ;
  • créer de nouveaux scénarios en temps réel ;
  • collaborer avec d’autres agents lorsque des pannes nécessitent une analyse approfondie à plusieurs niveaux.
Testing Objective → API Agent → Send Request → Analyze Response
        → Validate Result → Pass Result to Workflow

Il s’agit de tests API qui prennent en compte ce qu’ils vérifient, et non seulement le fait qu’un nombre corresponde ou non.

Les agents de base de données méritent plus de reconnaissance

Tout SDET connaît cette situation : l’interface affiche une confirmation de succès, l’API renvoie 200 OK, mais la ligne de la base de données n’est jamais enregistrée. Rien ne le signale à moins que quelqu’un n’examine directement les données.

Un agent conscient des particularités de la base de données peut interroger et valider automatiquement les données de test, vérifier le backend sans que quelqu’un ait à écrire constamment du SQL brut, prendre en charge des tests basés sur les données et inter-systèmes, ainsi que détecter le type d’erreur qui se produit entre les différentes couches du système.

UI → API → Business Logic → Database

Un défaut ne peut apparaître que lorsque les quatre couches sont validées ensemble, c’est là que les agents coordonnés trouvent leur utilité.

Le navigateur en tant qu’outil parmi d’autres

Le projet de exemple comprend un script web_surfer.py qui montre comment un agent fonctionne dans un environnement web réel, non pas en tant que script isolé, mais comme l’une des fonctionnalités d’un ensemble.

Testing Goal → Agent → Web Interaction → Observation
     → Decision → Validation

Le navigateur cesse d’être l’ensemble du test. Il devient un outil auquel l’agent a recours lorsque l’objectif l’exige.

Fournir une mémoire à l’automatisation

La plupart des systèmes d’automatisation ont une mémoire limitée, de sorte que chaque exécution commence à zéro. Le projet conserve un petit fichier memory.json pour y remédier. Ce fichier contient les actions précédentes, l’état du flux de travail, le contexte du test, les observations pertinentes ainsi que les résultats antérieurs.

Test Objective → Current Context → Previous Actions
     → Agent Decision → New Action → Updated Context

L’automatisation consciente du contexte ne perçoit pas le système comme un étranger à chaque exécution. Elle crée une mémoire de travail, ce qui correspond davantage au comportement d’un testeur expérimenté.

Ce que ce n’est pas

La fatigue liée au hype autour de l’IA est réelle, donc un peu de clarté est utile :

  • Ce n’est pas « l’IA qui remplace les testeurs ».
  • Ce n’est pas un bot de test prêt à l’emploi.
  • Ce n’est pas encore un framework de niveau production.

Il s’agit d’une expérience honnête et en évolution pour comprendre comment le raisonnement, les outils et la mémoire pourraient redéfinir le QA, ainsi que d’un rappel que le jugement technique reste celui qui guide le processus. L’objectif n’est pas d’automatiser tout, mais de le faire de manière intelligente.

Un bon QA dépend toujours de l’analyse des risques, de la stratégie de test, des connaissances sectorielles, des tests exploratoires, d’une conception d’automatisation solide, de l’observabilité et de la révision humaine des résultats. Les agents devraient servir de partenaire plus efficace, et non de substitut à la réflexion du testeur.

À quoi ressemble la structure du répertoire

Pour ceux qui souhaitent s’y plonger, voici la structure du projet de exemple. Les fichiers basics constituent des fondations progressives ; un fichier de scénario les applique, un fichier de sélecteur regroupe et choisit les fonctionnalités, et le fichier de mémoire stocke le contexte.

AgenticAIAutoGen/
│
├── Framework/
├── basics1.py → basics6.py     → progressive foundational examples
├── scenario1.py                 → applied automation scenario
├── selectorGroup.py             → capability grouping/selection logic
├── web_surfer.py                → web interaction experimentation
├── memory.json                  → agent memory/context storage
└── .gitignore

La stack comprend Python avec OpenAI Agents, une intégration MCP, des tests d’API, une validation de base de données et une automatisation du navigateur.

Qui en bénéficie

Cet experiment vise les ingénieurs en automatisation de QA et les SDETs, les responsables de la qualité, les architectes d’automatisation de tests, les ingénieurs en automatisation par IA, ainsi que les managers d’ingénierie qui évaluent l’utilisation de l’IA pour le QA.

Où cela peut mener

Le plan d’action est ambitieux car le domaine évolue rapidement :

  • flux de travail de QA multi-agents ;
  • génération plus intelligente de tests, y compris des données de test ;
  • tests d’API assistés par l’IA ;
  • tests de navigateur autonomes ;
  • agents de validation de base de données ;
  • analyse automatique des échecs et des défauts ;
  • intégration CI/CD ;
  • résumés des résultats des tests ;
  • orchestration complète des agents.

Rien de tout cela ne remplace les fondamentaux. Tout cela s’appuie sur eux.

Le point clé

Le futur de l’automatisation des tests ne réside probablement pas dans l’écriture plus rapide de scripts. Il consiste à créer des systèmes capables de :

  1. Comprendre un objectif de test.
  2. Évaluer l’approche la plus adaptée.
  3. Utiliser les outils appropriés sur le web, via des API et des bases de données.
  4. Évaluer les résultats obtenus.
  5. Se adapter et fournir aux ingénieurs des informations utiles.

Cela transforme l’automatisation d’un simple outil d’exécution en un partenaire capable de réfléchir aux côtés du testeur, offrant ainsi un partenaire technique plus intelligent plutôt qu’un remplaçant.