Playwright : attendre la réponse après un clic
Corrigez l’attente de réponse Playwright : abonnez-vous avant le clic, identifiez le POST, contrôlez son statut HTTP puis vérifiez l’interface obtenue.
BotBrowser Team
Vous voulez la documentation structurée pour Démarrage ?
Cet article fait partie de la bibliothèque éditoriale. Pour les étapes de configuration, la référence et les mises à jour continues, passez directement à la section docs.
Une attente de réponse Playwright peut expirer après un clic sur Enregistrer alors que la page affiche un message de réussite. Créez la promesse de réponse avant le clic, identifiez la requête attendue, puis contrôlez séparément son statut et l’interface obtenue. BotBrowser permet de piloter un navigateur avec Playwright et un profil déclaré ; il ne peut ni rejouer un événement de réponse auquel le test s’est abonné trop tard, ni décider quelle requête de l’application représente l’enregistrement.
TL;DR
- Appelez
page.waitForResponse()sans l’attendre avant de déclencher l’action. Attendez la promesse conservée après le clic. - Identifiez d’abord la requête :
/api/saveassocié àPOSTdistingue l’écriture duGETprécédent vers le même chemin. - Contrôlez
response.status()séparément. Un filtre limité à201peut faire apparaître une véritable réponse503comme une expiration du délai. - Vérifiez indépendamment le corps de la réponse et le résultat dans
role=status. Un message de réussite ne prouve pas à lui seul un stockage durable.
Sommaire
- La séquence d’enregistrement produit trois signaux distincts
- Reproduire un abonnement réellement trop tardif
- S’abonner avant le clic et vérifier le POST
- Un prédicat limité au chemin accepte la mauvaise première réponse
- Garder les erreurs HTTP visibles
- Diagnostiquer le signal manquant
- Conclusion pratique
La séquence d’enregistrement produit trois signaux distincts
Prenons un éditeur de révisions que vous maîtrisez, dont le gestionnaire d’enregistrement lit d’abord la révision actuelle avant d’envoyer la nouvelle valeur. Les deux requêtes utilisent /api/save. La lecture renvoie GET /api/save avec HTTP 200 et la révision 6 ; l’écriture renvoie POST /api/save avec HTTP 201 et la révision 7. Le gestionnaire ne remplace le texte de l’élément de statut par Saved revision 7 qu’après avoir lu la réponse à l’écriture.
Ces observations sont différentes. Le GET établit que la lecture initiale a reçu une réponse. Le POST établit que le point d’accès d’écriture a répondu avec un statut et un corps précis. Le DOM final établit que l’application a affiché un message donné. L’ordre compte, car le même chemin apparaît deux fois et la mise à jour du DOM survient après les deux événements de réponse.
La documentation réseau de Playwright crée la promesse de réponse avant le clic déclencheur, sans await sur cette première ligne. Il s’agit d’un abonnement aux événements, pas d’une recherche dans l’historique des opérations réseau déjà terminées du navigateur. Une réponse correspondante arrivée avant l’abonnement ne peut pas satisfaire la nouvelle attente. À l’inverse, une réponse arrivée après peut correspondre, que le test ait déjà cliqué sur un bouton ou non.
Le diagramme temporel distingue un abonnement précoce au POST d’un abonnement créé après la vérification de l’interface finale. Les valeurs littérales décrivent la séquence de l’exemple maîtrisé, pas des durées mesurées. Le premier abonnement ignore le GET ; le second n’a plus aucun POST à observer.
L’application n’a pas besoin d’intercepter les requêtes pour produire cette différence. Un petit serveur HTTP et un gestionnaire utilisant fetch() natif suffisent. Le guide de simulation réseau pour les tests maîtrisés explique comment remplacer une dépendance par des réponses contrôlées ; ici, la variable utile est le moment où le test s’abonne et la réponse qu’il accepte. Le caractère séquentiel du gestionnaire rend reproductible la première correspondance incorrecte sans dépendre de la vitesse du réseau.
Un véritable éditeur peut aussi envoyer des données analytiques, des requêtes préliminaires ou des actualisations en arrière-plan. Leur présence ne change pas la signification d’un enregistrement réussi. Définissez celle-ci à partir du contrat de votre API, au lieu de choisir la requête qui se termine à proximité du clic. Dans cet exemple, une écriture réussie renvoie précisément 201, contient { revision: 7 } et produit le texte de statut correspondant.
Reproduire un abonnement réellement trop tardif
Le cas d’échec minimal exige une réponse terminée avant l’abonnement. Placer waitForResponse() sur la ligne qui suit await button.click() ne garantit pas cet ordre : l’opération réseau peut encore être en cours lorsque le clic se termine. Ce code comporte une course, mais une exécution donnée peut réussir. Une démonstration déterministe attend d’abord le statut final, car cette page maîtrisée ne l’affiche qu’après avoir consommé le corps du POST.
Avec l’objet page de Playwright et le module d’assertions de Node disponibles, la variante volontairement tardive suivante rend cet ordre explicite. Elle suppose une nouvelle instance du formulaire maîtrisé, un seul bouton nommé Save, un élément de statut et aucun POST répété automatiquement. Le délai de 400 ms borne une vérification négative ; ce n’est pas une durée conseillée pour les attentes en production.
const assert = require('node:assert/strict');
const savePost = response => new URL(response.url()).pathname === '/api/save' && response.request().method() === 'POST';
await page.getByRole('button', { name: 'Save', exact: true }).click();
await page
.getByRole('status')
.filter({ hasText: /^Saved revision 7$/ })
.waitFor();
await assert.rejects(page.waitForResponse(savePost, { timeout: 400 }), error => error.name === 'TimeoutError');
L’assertion négative appartient uniquement à cet exemple d’échec. Un test d’application doit échouer lorsque la réponse requise manque, plutôt qu’accepter toute expiration de délai. Le nom de l’exception est vérifié pour qu’une page fermée, un prédicat mal formé ou une autre erreur de programmation ne puisse pas passer pour le résultat négatif attendu.
La condition essentielle réside dans le gestionnaire de la page. Il exécute await fetch('/api/save'), consomme ce JSON, effectue le POST, consomme son JSON, puis affiche la révision. Si une autre application affiche un message de réussite optimiste avant la fin de la requête, attendre ce message n’établirait pas le même ordre. Inspectez le gestionnaire réel ou corrélez sa trace avant d’utiliser un état de l’interface comme preuve qu’une réponse a déjà eu lieu.
Ce formulaire n’effectue ni interrogation périodique ni nouvelle tentative après la mise à jour. Dans une application avec des POST en arrière-plan, une attente tardive pourrait se résoudre sur une opération ultérieure plutôt qu’expirer. Cela ne prouverait toujours pas qu’elle a observé l’enregistrement initial. Identifiez les écritures simultanées ou répétées au niveau de l’application lorsque nécessaire, et réinitialisez l’état entre les variantes défaillante et corrigée pour qu’une exécution ne fournisse pas l’événement de l’autre.
La conclusion de ce cas négatif reste limitée : un événement de réponse terminé n’est pas rejoué pour une attente nouvellement créée. Il ne prouve pas que toutes les attentes placées immédiatement après tous les clics échoueront. Un serveur plus lent peut rendre l’ordre dangereux apparemment fiable pendant des mois ; un serveur local plus rapide peut révéler la même course sans changement de navigateur.
S’abonner avant le clic et vérifier le POST
La correction place l’abonnement avant l’action et conserve sa promesse. Pour une page maîtrisée déjà chargée à l’URL du formulaire, voici le modèle copiable avec Playwright autonome. Il utilise les assertions de Node ; un projet Playwright Test peut employer ses propres assertions expect pour les valeurs de réponse et ses assertions à réessai automatique pour l’état du DOM. Si Save correspond à plusieurs contrôles, corrigez la violation du mode strict du localisateur avant d’attribuer l’absence du POST au moment de l’abonnement.
const assert = require('node:assert/strict');
const responsePromise = page.waitForResponse(
response => new URL(response.url()).pathname === '/api/save' && response.request().method() === 'POST'
);
const [, response] = await Promise.all([
page.getByRole('button', { name: 'Save', exact: true }).click(),
responsePromise,
]);
assert.equal(response.status(), 201);
assert.deepEqual(await response.json(), { revision: 7 });
await page
.getByRole('status')
.filter({ hasText: /^Saved revision 7$/ })
.waitFor();
assert.equal(await page.getByRole('status').innerText(), 'Saved revision 7');
L’appel à waitForResponse() crée immédiatement l’abonnement. Conserver cette promesse ne bloque pas le clic suivant. Promise.all() observe ensuite les deux opérations ensemble, de sorte que le clic et l’attente de réponse conservent chacun leur propre chemin d’échec. N’écrivez pas await page.waitForResponse(...) avant de déclencher le clic : cela suspend le test avant l’opération censée produire la réponse.
La référence de l’API Response définit url(), request(), status() et json(). Le prédicat utilise le pathname analysé de l’URL de réponse pour éviter des correspondances partielles accidentelles telles que /api/save-preview. Il vérifie la méthode de la requête d’origine, car les lectures et les écritures partagent le point d’accès. L’assertion de statut répond ensuite à une autre question : cette écriture précise a-t-elle renvoyé le code de réussite promis par l’exemple ?
Pour une page qui contacte plusieurs origines avec le même chemin, comparez aussi new URL(response.url()).origin à l’origine attendue de l’API. Conservez les paramètres de requête pertinents lorsqu’ils identifient l’opération ; analyser uniquement pathname les ignore délibérément. L’exemple suppose une seule origine maîtrisée et une écriture par clic : ces règles d’identité supplémentaires n’y apporteraient donc aucune discrimination.
Si une application peut envoyer plusieurs POST simultanés à /api/save, le chemin et la méthode ne suffisent pas. Un identifiant d’enregistrement maîtrisé, un champ du corps de la requête ou un identifiant d’opération fourni par l’application peuvent les distinguer. Validez le champ attendu au lieu de journaliser des corps complets susceptibles de contenir des données utilisateur. L’identité d’une requête peut être exacte alors que son résultat côté serveur est un échec ; gardez ces deux décisions séparées.
L’assertion du DOM suit la validation du corps parce que la mise à jour de l’interface est indépendante de la disponibilité de la réponse. Attendre une réponse ne signifie pas que le gestionnaire de promesse de l’application a déjà affiché son résultat. Un bref intervalle peut donc exister pendant lequel le POST est accessible au test alors que le statut indique encore Saving. Attendre le résultat précis gère cette transition sans pause d’une durée arbitraire.
Contrat minimal du serveur maîtrisé
La reproduction peut utiliser tout serveur HTTP sur l’interface de bouclage qui sert le formulaire suivant et renvoie du JSON pour les deux méthodes. Configurez GET /api/save en 200 avec { "revision": 6 }, et POST /api/save en 201 avec { "revision": 7 }. Le POST accepte { "revision": 7 } ; il n’a pas besoin de stocker quoi que ce soit pour démontrer la sélection de réponse. Rechargez le formulaire avant chaque variante de test.
<form>
<label>Revision <input name="revision" type="number" value="7" /></label>
<button type="submit">Save</button>
</form>
<p role="status">Not saved</p>
<script>
document.querySelector('form').addEventListener('submit', async event => {
event.preventDefault();
const status = document.querySelector('[role="status"]');
status.textContent = 'Saving';
try {
const current = await fetch('/api/save');
if (!current.ok) throw new Error('Read failed');
await current.json();
const response = await fetch('/api/save', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
revision: Number(document.querySelector('input').value),
}),
});
if (!response.ok) throw new Error('Save failed');
const saved = await response.json();
status.textContent = 'Saved revision ' + saved.revision;
} catch {
status.textContent = 'Save failed';
}
});
</script>
Servez le formulaire en HTTP plutôt que de l’ouvrir comme un fichier local : ses URL fetch relatives nécessitent l’origine du serveur. Ce gestionnaire est un code de démonstration original, pas une implémentation de formulaire destinée à la production. Il expose volontairement l’ordre lecture-écriture ; la validation, l’autorisation, le stockage et la gestion des envois en double relèvent du contrat de l’application réelle.
Le 2026-11-18, l’exemple maîtrisé sur l’interface de bouclage a été exécuté avec Playwright 1.58.0 et Chrome standard 157.0.8103.79 sous macOS arm64. Les trois variantes ont satisfait leurs assertions. L’abonnement volontairement tardif a produit TimeoutError avec une limite configurée de 400 ms. Avec les abonnements précoces, l’attente limitée au chemin a sélectionné GET 200, tandis que celle vérifiant la méthode a sélectionné POST 201 et que l’interface a atteint Saved revision 7. Dans la variante d’erreur, l’attente vérifiant la méthode a sélectionné POST 503 et l’interface a atteint Save failed. Il s’agit de résultats locaux de sélection d’événements, pas de mesures de persistance en production ou de capacités de BotBrowser.
Un prédicat limité au chemin accepte la mauvaise première réponse
Un abonnement peut démarrer au bon moment et néanmoins observer la mauvaise opération. Avec le gestionnaire séquentiel d’enregistrement, le prédicat suivant se résout sur GET /api/save avec 200, car il s’agit de la première réponse correspondante. Attendre la promesse plus longtemps ensuite ne peut pas remplacer la réponse sélectionnée par le POST ultérieur.
const responsePromise = page.waitForResponse(response => new URL(response.url()).pathname === '/api/save');
const [, response] = await Promise.all([
page.getByRole('button', { name: 'Save', exact: true }).click(),
responsePromise,
]);
console.log(response.request().method(), response.status());
Dans cet exemple, GET 200 est une réponse valide à la lecture, pas une erreur intermittente du navigateur. Vérifier uniquement response.ok() l’accepterait, puisque 200 et 201 sont tous deux des codes HTTP de réussite. Cette assertion prouverait la réussite du GET sélectionné sans rien établir sur l’écriture suivante. La correction consiste à préciser le prédicat de requête, pas à allonger le délai.
De même, une sous-chaîne du point d’accès associée à status() === 200 peut induire en erreur lorsque le contrat d’écriture exige 201. Un prédicat doit exprimer l’opération nécessaire au test, pas le statut qui paraît familier dans les outils du navigateur. Relevez ensemble le chemin, la méthode et le statut pour diagnostiquer une mauvaise correspondance ; une URL seule masque la différence précise démontrée ici.
Une redirection peut également produire plusieurs réponses associées à une action. Identifiez l’opération d’API prévue et son statut documenté au lieu de considérer une destination de redirection comme équivalente à l’écriture. Si le produit modifie volontairement son contrat d’API, mettez à jour ensemble les assertions d’identité et de résultat. N’acceptez pas silencieusement tous les codes 2xx, sauf si le contrat autorise réellement ces possibilités.
Garder les erreurs HTTP visibles
Pour le diagnostic, identifiez le POST avant de vérifier la réussite. Si le serveur renvoie 503 pour cette écriture, une attente sur le chemin et la méthode peut se résoudre, puis assert.equal(response.status(), 201) signale le code inattendu. La requête a été observée ; l’opération de l’application n’a pas satisfait son contrat de réussite. Une réponse portant une erreur HTTP est différente d’une réponse que l’abonnement n’a jamais reçue.
Cette variante attend uniquement la réponse de réussite :
const successPromise = page.waitForResponse(
response =>
new URL(response.url()).pathname === '/api/save' &&
response.request().method() === 'POST' &&
response.status() === 201
);
Ce filtre peut convenir lorsque le besoin consiste réellement à attendre un futur 201 parmi plusieurs tentatives connues. Il modifie toutefois le résultat du diagnostic. Un 503 ne satisfait pas le prédicat ; si aucune réponse admissible ne suit, la promesse finit par expirer. L’expiration signifie alors qu’aucune réponse n’a satisfait toutes les conditions, pas nécessairement que le POST était absent ou que l’abonnement a commencé trop tard.
Gardez le statut de la réponse en échec accessible avant d’interpréter son corps. Un document d’erreur HTML peut faire échouer response.json() et masquer l’échec HTTP, plus utile, derrière une exception d’analyse. Dans la correction principale, l’assertion de statut s’exécute d’abord. Si des détails supplémentaires sont nécessaires, conservez un diagnostic réduit et expurgé plutôt que de déverser des pages arbitraires du serveur ou des corps de réponses authentifiées dans les journaux de test.
Le gestionnaire fetch de la page vérifie lui aussi response.ok. Son état d’échec est donc Save failed lorsque le POST renvoie un code sans réussite. Le test ne doit pas continuer à attendre indéfiniment Saved revision 7 après avoir déjà observé une écriture infructueuse. Un test du chemin d’erreur peut vérifier volontairement la réponse d’erreur et l’interface d’échec ; un test du cas nominal doit échouer sur le statut inattendu.
Les défaillances de transport nécessitent une observation différente : une erreur de connexion peut ne produire aucun objet de réponse HTTP à inspecter. Playwright expose des événements de requête pour ce diagnostic. Un délai d’attente de réponse plus long ne peut pas créer un statut HTTP pour une connexion qui n’en a jamais reçu. Distinguez le traitement des erreurs HTTP, les défaillances réseau et le moment de sélection de réponse lors de l’analyse d’une exécution en échec.
Diagnostiquer le signal manquant
Commencez par l’observation minimale qui distingue les cas. Confirmez si l’attente a été enregistrée avant l’action, puis inspectez la réponse qu’elle a effectivement sélectionnée. Un test qui a retenu GET 200 présente un défaut différent de celui qui a sélectionné POST 503, même si les deux finissent par échouer sur une assertion d’enregistrement. Les choix suivants correspondent au contrat de ce formulaire maîtrisé.
| Observation | Ce qu’elle établit | Vérification suivante |
|---|---|---|
| L’interface finale apparaît, puis une nouvelle attente de POST expire | Cet abonnement n’a pas observé l’écriture terminée | Placer l’abonnement avant le clic |
L’attente limitée au chemin renvoie GET 200 | La première lecture correspondante a été sélectionnée | Ajouter la méthode à l’identité de la requête |
L’attente de POST renvoie 503 | L’écriture prévue a répondu sans succès | Inspecter l’échec du point d’accès maîtrisé |
Le POST renvoie 201, l’interface reste sur Saving | La réponse réussie n’a pas établi la fin du rendu | Inspecter le traitement du corps et la transition d’interface |
L’interface affiche Saved revision 7 | Cet état du DOM a été rendu | Vérifier séparément la réponse et la persistance requise |
Utilisez la procédure de traces Playwright lorsque l’échec dépend du rythme d’une application réelle. Comparez l’action, les entrées réseau et les états rendus de la même exécution défaillante. Une trace peut montrer qu’une réponse a précédé des actions ultérieures du test ; une nouvelle exécution réussie ne reconstitue pas la réponse sélectionnée par un abonnement antérieur. Ajoutez des diagnostics ciblés du prédicat lorsque la trace seule ne permet pas d’établir la sélection. Si un message de la console de la page manque aussi, vérifiez l’abonnement aux événements console avant la navigation et distinguez ces événements de la sortie du script Node.
Évitez d’ajouter waitForTimeout() entre le clic et l’attente de réponse. Cela augmente le risque de manquer une réponse rapide sans apporter d’identité à l’opération. Attendre un calme réseau global répond aussi à une autre question qu’observer un POST précis. Une page peut garder des connexions sans rapport actives après la fin de l’enregistrement, ou devenir silencieuse alors que le gestionnaire de l’application a encore du travail.
L’intégration Playwright de BotBrowser documente le pilotage de son exécutable par Playwright et l’utilisation d’un profil pour l’environnement du navigateur. Cela permet une comparaison contrôlée des navigateurs une fois le test d’application bien défini. Elle ne corrige pas l’ordre des abonnements, ne choisit pas le bon POST, ne fournit pas la persistance côté serveur et ne garantit pas que le point d’accès acceptera l’écriture. L’exemple HTTP local concerne les événements Playwright, pas une mesure de capacité de BotBrowser.
Enfin, distinguez l’accusé de réception de la durabilité. Cet exemple renvoie la révision 7 sans base de données : même un 201 valide associé à l’interface finale ne prouve pas que le stockage survivrait à un redémarrage ou à une autre session. Lorsque la persistance est l’exigence métier, ajoutez après l’écriture une relecture indépendante adaptée au service maîtrisé. Définissez explicitement ses attentes de cohérence et d’autorisation plutôt que de relire le même DOM optimiste.
Questions fréquentes
L’attente automatique du clic inclut-elle la réponse de l’API d’enregistrement ?
Les conditions d’interaction du clic déterminent si Playwright peut effectuer l’action sur sa cible. Elles n’identifient pas une réponse arbitraire de l’API de l’application et ne vérifient pas son schéma JSON. Enregistrez une attente de réponse dédiée à l’opération dont le test nécessite le résultat, puis conservez à ses côtés l’assertion du résultat visible.
Le prédicat doit-il utiliser response.ok() plutôt qu’un statut exact ?
ok() accepte les statuts de 200 à 299. Utilisez-le lorsque toute cette plage est valide pour l’opération. Pour un contrat exigeant 201, l’égalité exacte détecte un 200 ou 202 inattendu qu’une vérification générale de réussite accepterait. Aucun des deux choix ne distingue le GET du POST sans identité de requête.
Pourquoi une attente de réponse peut-elle se résoudre avant la mise à jour de l’interface ?
L’événement de réponse et le processus de rendu de l’application sont des étapes différentes. La lecture du corps, la validation applicative et les mises à jour du DOM peuvent se poursuivre après que la réponse est devenue observable. response.json() vérifie les données reçues ; une assertion dédiée au localisateur vérifie l’élément de statut final. Aucune ne remplace l’autre.
Sources
- Playwright : réseau
- Playwright : API Response
- Playwright : page.waitForResponse
- Playwright : événements Request
- Playwright : conditions d’interaction
- BotBrowser : intégration Playwright
Conclusion pratique
Pour attendre une réponse Playwright après un clic sur Enregistrer, enregistrez d’abord l’attente, identifiez l’écriture prévue et contrôlez son résultat HTTP avant de vérifier l’interface. Essayez les variantes tardive et précoce avec le formulaire séquentiel maîtrisé : la première manque volontairement un événement terminé, tandis que la seconde conserve le POST. Ajoutez une relecture indépendante du service uniquement lorsque l’exigence inclut la persistance.
Cet article fait partie du guide : Débuter avec l'automatisation du navigateur : carte initiale
Articles Connexes
Chrome DevTools MCP ou Playwright MCP pour déboguer
DémarrageSelenium element not interactable : causes et correctifs
DémarrageTimeout networkidle Playwright : attendre l’interface
DémarragePlaywright strict mode violation : corriger les doublons
DémarrageScraping avec Playwright : navigateur et profil
DémarrageConsole Playwright : messages absents
Exécutez la même vérification dans BotBrowser
Chargez un profil, gardez dans le navigateur les signaux que vous venez de lire, puis confirmez le résultat sur votre propre machine avant le déploiement.