Accueil / Articles

Les tests précoce avec des agents de codage : choisir le niveau de test le plus fiable et le moins coûteux.

Testage décalé vers la gauche à l’aide d’agents de codage : les ingénieurs QA lisent le dépôt, choisissent le niveau de test le plus fiable pour chaque scénario et éliminent les tests de navigateur lents. Avec un exemple.

Éditeur : REACTAPP.TOP7 min de lecture1577 mots

Sources: Shift-Left Testing in the AI Era: How Coding Agents Can Change the QA Engineer’s Role

Il est conseillé depuis des années de tester tôt dans le cycle de développement, mais cette recommandation est rarement suivie correctement. Les agents de codage basés sur l’IA pourraient enfin offrir aux ingénieurs en QA un moyen pratique de la mettre en œuvre avec confiance.

Le principe du « shifting left » consiste à intégrer la validation dès les premières étapes, c’est-à-dire dans les tests unitaires, de composants, d’API et d’intégration, plutôt que de détecter chaque défaut grâce à des tests end-to-end ou à l’automatisation de l’interface utilisateur. L’idée en elle-même n’est pas nouvelle. La mettre en pratique a toujours été plus difficile que de la décrire, et l’une des principales raisons réside dans l’écart entre les connaissances en QA et les connaissances au niveau du code.

Un ingénieur en QA peut comprendre en profondeur un scénario métier. Les questions typiques sont les suivantes :

  • Que se passe-t-il si la remise a expiré ?
  • Que se passe-t-il si le montant du paiement dépasse la limite autorisée ?
  • Que se passe-t-il si une API renvoie une valeur non prise en charge ?
  • Que se passe-t-il si un calcul produit un résultat invalide ?

Ces sont de bons scénarios. La question plus difficile est de déterminer où chacun devrait être testé. Un test unitaire suffit-il ? Faut-il l’inclure dans la couche des composants ? Un test d’intégration est-il nécessaire ? Ou bien a-t-on vraiment besoin d’un navigateur du début à la fin ? Historiquement, c’est là que les ingénieurs en QA se sont heurtés à des difficultés.

Pourquoi les équipes de QA ont eu du mal à se déplacer vers le début du cycle de développement

Les tests unitaires et d’intégration sont étroitement liés à l’implémentation. Le développeur qui a créé une fonctionnalité sait où se trouve la logique métier, quelles classes ou fonctions y participent, ce qui peut être simulé et quelles dépendances se trouvent en dehors du code.

Un ingénieur QA peut connaître précisément ce qui doit être validé, mais il peut manquer de connaissances en matière d’implémentation pour affirmer avec certitude qu’un scénario ne doit pas passer par l’interface utilisateur, car la couche unitaire peut le gérer directement. Ainsi, dans de nombreuses équipes, le QA rédige les scénarios, demande aux développeurs quels tests unitaires ou d’intégration existent déjà, puis dépend de leurs réponses, car il est difficile de vérifier de manière indépendante la couverture au niveau du code.

Personne n’a raison ni tort dans cet échange. Il s’agit d’un problème de visibilité. Le QA gère les risques métier, les développeurs s’occupent de l’implémentation, et lorsque ces deux parties restent séparées, le shift-left devient un sujet de discussion plutôt qu’une stratégie efficace. Les scénarios se concentrent alors sur la couche UI simplement parce que c’est la couche que le QA sait comment piloter. C’est l’une des raisons pour lesquelles les suites d’automatisation s’encombrent : plus d’exécutions de navigateurs, plus de dépendances envers des environnements, plus de problèmes avec les données de test, plus de maintenance et un retour d’information plus lent.

Ce que changent les agents de codage

Des outils tels que Claude Code et GitHub Copilot peuvent désormais fonctionner directement sur un dépôt, en lisant sa structure et son contenu. Imaginez une fonctionnalité disposant de 20 scénarios de test prêts. Au lieu de décider immédiatement quels d’entre eux automatiser avec Playwright ou Selenium, un ingénieur QA peut d’abord demander à un agent de codage d’analyser le dépôt pour indiquer où chaque scénario est le mieux couvert : lesquels relèvent du niveau unitaire, lesquels nécessitent des tests de composant ou d’intégration, lesquels conviennent aux API et lesquels exigent réellement une automatisation bout en bout.

C’est une approche différente de l’automatisation des tests. Le QA ne considère plus l’application uniquement de l’extérieur. L’IA peut examiner l’implémentation et montrer où se trouve la véritable logique métier, ce qui rend la pyramide des tests bien plus pratique.

Un exemple de processus de paiement

Considérons un processus de paiement en e-commerce. Le QA prépare cinq scénarios :

  1. Un coupon expiré est rejeté.
  2. Un coupon invalide est rejeté.
  3. Le montant total de la commande est recalculé correctement.
  4. Une erreur de paiement est gérée comme il se doit.
  5. Une commande réussie affiche une confirmation.

Avec l’approche traditionnelle, ces cinq cas deviennent probablement tous des tests dans le navigateur. Supposons maintenant qu’un agent scanne le répertoire : il constate que la validation des coupons se trouve dans une fonction de logique métier isolée, ce qui fait des deux premiers scénarios des tests unitaires idéaux. Le calcul de la commande est également implémenté séparément et peut être vérifié sans navigateur, ce qui fait descendre le troisième scénario d’un niveau. Une erreur de paiement conviendrait mieux comme test d’intégration ou de niveau de service. Seul le processus de paiement complet et réussi nécessite un test end-to-end dans un navigateur.

Cinq tests d’interface deviennent un test d’interface plus quatre tests plus rapides au niveau inférieur. C’est exactement l’objectif visé par la stratégie de déplacement vers la gauche, et ce qui a changé, c’est que le service de contrôle qualité dispose désormais d’un moyen pratique pour orienter les décisions.

Le développeur reste impliqué

Faire confiance aveuglément à l’agent au lieu de faire confiance aveuglément au développeur n’est pas l’idée. L’IA peut se tromper : elle peut interpréter à tort une architecture, manquer des dépendances ou proposer des limites de test incorrectes, donc elle ne devrait pas devenir l’autorité finale.

Sa valeur constitue un point de départ bien plus solide. Au lieu de demander à un développeur si un scénario peut être couvert par des tests unitaires, le service de qualité peut dire quelque chose comme : cette validation fait référence à ce service et semble isolée de l’interface utilisateur, donc peut-elle être couverte au niveau unitaire au lieu d’ajouter un autre test dans le navigateur ? C’est une discussion technique bien plus pertinente. L’intelligence artificielle ne remplace pas le développeur dans les tests précoce. Elle donne au service de qualité une visibilité technique suffisante pour participer à la discussion avec confiance.

Fournir aux agents le contexte des tests

Les agents de codage deviennent bien plus utiles une fois qu’ils connaissent la philosophie de test d’une équipe et pas seulement son code. C’est là la fonction des instructions de répertoire, des fichiers d’instructions pour les agents ou des fichiers de compétences. De nombreux agents lisent un fichier d’instructions permanent qui se charge automatiquement. Un CLAUDE.md placé à la racine du répertoire est un tel fichier.

Une version simple pourrait commencer par un en-tête :

# Testing Strategy Instructions

Et poursuivons avec les règles elles-mêmes :

- Prefer the lowest reliable testing layer for any new scenario.
- Do not recommend UI automation if the same behavior can be
  validated reliably at a lower layer.
- Before suggesting a test, identify what unit, API, integration,
  and end-to-end frameworks already exist in this repo.
- Explain *why* a scenario belongs to a specific layer.
- Flag duplicate coverage — check if a scenario is already
  tested before recommending a new test.

Le format exact varie selon l’outil, mais le principe reste le même : fournir à l’agent suffisamment de contexte pour qu’il analyse le code du point de vue d’une stratégie de test et non seulement en tant que code.

Partir de la couche, pas de l’outil

Une erreur fréquente dans l’automatisation est de partir de l’outil. Une équipe utilisant Playwright se demande comment automatiser un scénario avec Playwright, tandis qu’une équipe utilisant Selenium pose la même question pour Selenium. La meilleure question est de savoir quelle est la couche la plus basse et la plus fiable sur laquelle le comportement peut être testé.

Parfois, la réponse reste l’interface utilisateur, car de nombreux flux nécessitent bien une validation au niveau du navigateur. La couche UI doit être choisie parce que le scénario l’exige, et non parce que le service de QA ne peut pas voir ce qui se trouve en dessous. Les agents sont idéalement placés pour combler cette lacune.

Quels changements pour les ingénieurs QA

Les compétences fondamentales restent les mêmes : comprendre les risques commerciaux, identifier les cas limites, concevoir des scénarios pertinents et savoir ce qui nécessite une couverture de bout en bout. Une nouvelle compétence gagne beaucoup en valeur, à savoir l’utilisation d’agents de codage pour comprendre comment l’application est réellement implémentée, puis vérifier ces constats avec l’équipe de développement. Avant d’automatiser un scénario, posez ces questions à l’agent :

  • Où se trouve la logique métier de ce scénario ?
  • Existe-t-il déjà un test qui le couvre ?
  • De quoi dépend le scénario, et est-il isolé ou fortement lié à l’interface utilisateur ?
  • Quel est le niveau le plus rapide et fiable pour obtenir des retours concrets ?

Cela est beaucoup plus proche d’un véritable testing shift-left.

Pourquoi cela pourrait enfin fonctionner

Le principe du décalage vers la gauche semblait toujours valable en théorie. Cependant, dans de nombreuses équipes, le service de contrôle qualité manquait de visibilité au niveau du code pour le mettre en œuvre. Les agents de codage changent cela en aidant le service de contrôle qualité à examiner les dépôts, à identifier les limites de l’implémentation, à examiner les tests existants et à proposer le niveau approprié pour chaque scénario.

Cela ne signifie pas pour autant que l’IA fournira une pyramide de tests parfaite. L’architecture de l’équipe, les systèmes hérités, les responsabilités, les délais et la culture d’ingénierie restent importants. Mais un obstacle diminue clairement : il devient de plus en plus difficile de justifier l’affirmation « Je ne connais pas suffisamment le code pour savoir à quel niveau ce test doit être placé » lorsque des outils existent pour aider à trouver la réponse. L’avenir de l’automatisation réside dans l’écriture des bons tests au bon niveau, et non dans leur multiplication.

Questions fréquentes

Qu’est-ce que le testing shift-left ? Il s’agit de tester plus tôt dans le cycle de vie, en déplaçant la validation vers les couches unitaire, de composants, API et d’intégration, au lieu de s’appuyer principalement sur l’automatisation bout en bout ou de l’interface utilisateur.

Pourquoi est-ce difficile pour les équipes de QA ? Les équipes de QA comprennent généralement bien les risques commerciaux, mais ne peuvent pas voir l’implémentation ; par conséquent, elles ne peuvent pas déterminer de manière indépendante à quelle couche appartient un scénario sans interroger les développeurs.

Comment les agents de codage aident-ils ? Un agent peut analyser un dépôt et indiquer où un scénario est le mieux couvert, que ce soit au niveau unitaire, des composants, de l’API, de l’intégration ou bout en bout, ce qui donne aux équipes de QA une visibilité sur l’implémentation qui n’était pas disponible auparavant.

Les agents remplacent-ils les développeurs dans la stratégie de test ? Non. Les agents peuvent se tromper dans l’évaluation de l’architecture ou manquer des dépendances, donc leurs recommandations doivent être validées avec l’équipe de développement et ne doivent pas être considérées comme définitives.

Quelles éléments doivent figurer dans un fichier de instructions axé sur le QA ? Une préférence pour la couche de test la plus fiable, une règle interdisant de recommander l’automatisation de l’interface utilisateur lorsque une couche inférieure fonctionne, une vérification préalable de la couverture existante, ainsi qu’une explication du pourquoi un scénario correspond à sa couche.