Retour au Centre de connaissances
Démarrage

Timeout networkidle Playwright : attendre l’interface

networkidle peut expirer sur une page utilisable ou aboutir avant l’initialisation. Distinguez les états de chargement et vérifiez le résultat dans l’interface.

BotBrowser Team

Documentation

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.

Un timeout networkidle de Playwright ne prouve pas que la page est inutilisable. Le silence du réseau et la disponibilité de l’application répondent à des questions différentes : une requête peut rester ouverte en arrière-plan pendant qu’un formulaire fonctionne, et une page sans trafic peut encore contenir un contrôle non initialisé. Attendez l’élément et le résultat nécessaires à la tâche. BotBrowser permet de piloter son navigateur avec Playwright. Cette connexion ne garantit pas que le formulaire accepte déjà les commandes.

Résumé

  • networkidle attend la condition documentée d’inactivité réseau ; Playwright déconseille de l’utiliser pour déterminer si un test peut continuer et recommande les assertions web.
  • Un clic par locator attend les vérifications d’actionnabilité correspondantes. L’initialisation et la réussite fonctionnelle nécessitent toujours un comportement applicatif et des assertions appropriés.
  • Sur une page de test contrôlée, un fetch en cours a maintenu l’attente de networkidle pendant qu’une commande aboutissait. Une autre page a atteint l’inactivité alors que son bouton restait désactivé.
  • Associez toBeVisible() à toHaveText() lorsque le résultat doit inclure une confirmation visible. Une assertion sur le texte ne démontre pas à elle seule la visibilité.

Sommaire

Distinguer les étapes du document de la disponibilité applicative

Le navigateur peut finir d’analyser un document avant que l’application ait fini de le remplir. Il peut charger ses ressources avant qu’une tâche ultérieure active un bouton. Il peut également maintenir une connexion active alors que tous les contrôles nécessaires à une interaction donnée sont déjà utilisables. Faire de l’une de ces étapes une définition universelle de la disponibilité lie le test à une activité parfois peu pertinente pour son objectif.

La documentation de navigation de Playwright distingue navigation et chargement, et explique que les pages modernes continuent à travailler après l’événement load. La documentation de waitForLoadState définit les états disponibles et déconseille networkidle pour les tests. Le choix de l’état détermine la condition de fin de l’attente ; il n’ajoute aucune vérification de la correction propre à l’application.

SignalCe qu’il établitCe qui nécessite une vérification distincte
domcontentloadedL’événement DOMContentLoaded du document a été émisDonnées nécessaires, initialisation du contrôle et résultat de l’interaction
loadL’événement load du document a été émisTravail applicatif ultérieur et fonctionnement du contrôle nécessaire
networkidleLa condition documentée d’absence de connexions réseau pendant au moins 500 millisecondes a été atteinteInitialisation de l’application et existence du résultat demandé
Actionnabilité du locatorLa cible satisfait les vérifications de l’action demandéeTraitement correct de l’action par la logique applicative
Assertion du résultat applicatifLa condition de résultat spécifiée a été observéeToute garantie supplémentaire du serveur ou de persistance absente de cette assertion

La ligne load donne une définition documentaire, pas un résultat mesuré dans l’expérience ci-dessous. Les deux navigations ont utilisé waitUntil: 'domcontentloaded' ; le programme de test n’a pas mesuré séparément l’émission de load. Les observations ultérieures comparent l’attente d’inactivité avec l’état du contrôle et le texte de confirmation. Leur attribuer un instant mesuré de load ajouterait une preuve qui n’a jamais été recueillie.

Un appel ultérieur à page.waitForLoadState() concerne lui aussi l’état du document. L’API exige que la navigation soit engagée de façon effective et se résout immédiatement si le document courant a déjà atteint l’état demandé. L’appeler après chaque action ne prouve pas que celle-ci a déclenché une nouvelle navigation de document. Une mise à jour côté client peut rester dans le document existant : une assertion explicite de son résultat constitue alors l’attente pertinente.

Pour préparer le navigateur, la configuration de Playwright pour l’extraction de données distingue le lancement et la configuration du navigateur de la lecture du contenu applicatif. Une connexion fonctionnelle établit le chemin de contrôle ; la condition d’attente doit encore décrire les données ou l’état de l’interface nécessaires à cette étape de la tâche.

Deux chronologies indépendantes : un fetch en arrière-plan maintient l’attente d’inactivité après la réussite d’une commande ; dans l’autre cas, le réseau devient inactif avant le signal de disponibilité et l’activation du bouton.

Un fetch en cours peut survivre à une interaction réussie

La première page de test contrôlée fournit un bouton, un élément de sortie avec role="status" et un script qui démarre fetch('/hold'). Son serveur HTTP envoie les en-têtes de réponse et un premier fragment de texte pour /hold, puis laisse volontairement la réponse inachevée. Cela crée une requête précise dont la durée est contrôlée par le test, sans dépendre du trafic ni de la disponibilité d’un site distant.

Le gestionnaire du clic utilise un autre endpoint. Il envoie un véritable POST /order, analyse la réponse JSON du serveur local et remplace le texte d’état par Order confirmed: PENDING-001. La réponse ouverte en arrière-plan n’empêche pas cette requête indépendante de se terminer. Un test attendant le silence global avant de cliquer retarderait une interaction déjà possible dans ce cas contrôlé.

Le 2026-11-18, le test local a été exécuté avec Playwright 1.58.0 et Chrome 157.0.8103.79 standard sur macOS arm64. Il utilisait Chrome ordinaire, pas BotBrowser, et uniquement des pages HTTP locales contrôlées. Les deux cas ont satisfait leurs vérifications programmées. Ces observations portent sur les conditions d’attente choisies, pas sur un profil BotBrowser ni sur un parcours de commande en production.

Le programme a démarré page.waitForLoadState('networkidle', { timeout: 1200 }) après la navigation, conservé cette promesse en cours et poursuivi l’interaction. Il a vérifié que le bouton était activé, cliqué dessus et vérifié le texte de confirmation. Il a ensuite recueilli le résultat de l’attente d’inactivité et vérifié qu’une réponse retenue restait ouverte.

Élément enregistréObservationInterprétation
Début du fetch en arrière-planHorloge de page à environ 9.8 millisecondesLa requête contrôlée a commencé tôt dans l’exécution du document
Clic de commandeHorloge de page à environ 118.9 millisecondesLe gestionnaire s’est exécuté pendant que la requête de fond était en cours
Mise à jour du texte de confirmationHorloge de page à environ 120.7 millisecondesLe gestionnaire a affecté la confirmation reçue à l’élément d’état
Résultat de l’attente d’inactivitéTimeoutError, environ 1201.6 millisecondes écouléesLe budget de 1200 millisecondes de cette attente a expiré
Réponses retenuesopenHeldResponses: 1La réponse volontairement inachevée était toujours présente

L’enregistrement identifie l’attente rejetée par :

"errorName": "TimeoutError"

L’horloge de page et la durée d’attente ont des origines différentes. Les événements utilisent performance.now() dans le navigateur, relativement à l’origine temporelle du document. La durée de l’attente est mesurée par l’horloge monotone du programme Node autour de l’appel. L’option 1200 désigne un budget autorisé, pas un instant de la page ni l’affirmation que l’initialisation doit finir dans cet intervalle.

L’étiquette receipt-visible du tableau d’événements marque l’instruction qui met à jour textContent. Ce n’est pas un événement de rendu du navigateur. De même, l’assertion du programme utilise toHaveText(), qui vérifie le texte plutôt que la visibilité. La capture finale montre séparément la confirmation affichée sous le bouton. Ces artefacts étayent ensemble une mise à jour du texte et un résultat visible observé dans cette capture ; l’étiquette seule ne le démontrerait pas.

Laisser /hold inachevé est la cause volontaire de l’activité persistante dans ce test. Un timeout réel nécessite ses propres preuves sur les requêtes avant de recevoir la même explication. L’exemple n’établit pas que tous les transports en arrière-plan, schémas d’interrogation périodique ou ressources bloquées se comportent de façon identique. Il ne justifie pas non plus d’annuler des requêtes sans rapport avec l’objectif simplement pour faire aboutir networkidle.

Un réseau inactif peut précéder l’initialisation

La deuxième page inverse la relation. Son HTML initial contient un bouton Place order désactivé et un état Initializing. Un minuteur local programme un événement app:ready après 1800 millisecondes. Son gestionnaire définit data-ready="true" sur l’élément racine du document, active le bouton et modifie l’état. Cette transition ne nécessite aucune requête réseau différée.

Il s’agit d’une simulation d’initialisation tardive, pas d’une expérience sur l’implémentation de l’hydratation d’un framework. Le gestionnaire du clic est enregistré pendant l’exécution initiale du script, et l’attribut disabled empêche l’interaction jusqu’à la transition du minuteur. Le test isole ainsi le fait plus simple qu’un état applicatif peut rester incomplet après que le réseau est devenu calme.

Le programme a navigué avec domcontentloaded, attendu networkidle avec le même budget de 1200, puis vérifié que le bouton restait désactivé et l’état égal à Initializing. Il a capturé cet état avant d’attendre l’attribut persistant data-ready. Ce n’est qu’après les vérifications de disponibilité et d’activation qu’il a cliqué et examiné la confirmation finale.

Élément enregistréObservationInterprétation
Fin de l’attente d’inactivitéEnviron 493.0 millisecondes écoulées dans NodeLa condition d’inactivité a abouti dans son budget
Lecture de l’horloge de page après l’inactivitéEnviron 521.3 millisecondesObservation distincte du temps du navigateur après l’attente
Vérification de l’état désactivéHorloge de page à environ 532.5 millisecondesBouton désactivé et texte d’initialisation vérifiés après l’inactivité
Émission de app:readyHorloge de page à environ 1812.1 millisecondesLa transition programmée a commencé plus tard
Exécution du gestionnaire de commandeHorloge de page à environ 2434.1 millisecondesL’interaction a eu lieu après les vérifications et la capture intermédiaire

La durée d’environ 493.0 millisecondes ne contredit pas l’intervalle documenté de 500 millisecondes. Le programme démarre son chronomètre après l’attente de navigation, alors que l’observation réseau du navigateur peut déjà avoir commencé. Ce chronomètre mesure le temps supplémentaire attendu par cet appel particulier, plutôt que la totalité de la période comptée par le mécanisme d’inactivité. Aucune de ces horloges n’établit un délai universel exact de démarrage.

La capture intermédiaire montre le bouton désactivé et Initializing. La capture finale montre Order confirmed: INITIALIZED-001. La capture et les opérations suivantes du programme contribuent au temps précédant le clic : l’événement à environ 2434.1 millisecondes ne mesure donc ni le délai minimal de disponibilité de l’application ni la latence intrinsèque du clic.

La documentation de navigation de Playwright aborde séparément la mauvaise hydratation : un contrôle peut apparaître activé avant l’enregistrement de ses listeners, permettant un clic sans effet applicatif. Ce problème documenté est distinct de cette simulation avec bouton désactivé. Un diagnostic propre à un framework nécessiterait des preuves provenant de l’application réelle, notamment sur le moment où le comportement requis devient disponible.

La même distinction importe pour l’extraction de données. Une liste peut exister avant de contenir les enregistrements recherchés, et d’autres lots peuvent arriver après que la première vue est utilisable. Le rendu JavaScript, la pagination et le défilement infini expliquent ces limites de chargement du contenu. Un locator visant un enregistrement précis, un résultat de lot défini ou un état de fin applicatif décrit mieux la tâche que le silence de toute la page.

Choisir des assertions pour l’action et son résultat

La documentation d’actionnabilité de Playwright décrit les vérifications automatiques associées aux actions par locator. Pour un clic, elles incluent une cible unique, visible, stable, activée et capable de recevoir les événements. Ces vérifications aident à éviter de cliquer sur un contrôle désactivé ou obstrué ; elles ne peuvent pas établir que le gestionnaire enregistrera une commande ou affichera la bonne confirmation.

Un petit exemple Playwright Test piloté par les données exprime les deux aspects pour chaque page contrôlée. Configurez baseURL pour le serveur de test avant de lancer ces tests. Les routes et confirmations appartiennent à la démonstration locale, et le code suppose que le serveur fournit déjà les pages ; ce ne sont pas les endpoints d’un service de commande externe.

import { test, expect } from '@playwright/test';

const cases = [
  { route: '/pending-fetch', receipt: 'PENDING-001', needsReady: false },
  { route: '/late-initialization', receipt: 'INITIALIZED-001', needsReady: true },
];

for (const scenario of cases) {
  test(`${scenario.route} produces a visible receipt`, async ({ page }) => {
    await page.goto(scenario.route, { waitUntil: 'domcontentloaded' });

    const orderButton = page.getByRole('button', { name: 'Place order' });
    const status = page.getByRole('status');

    if (scenario.needsReady) {
      await expect(page.locator('html')).toHaveAttribute('data-ready', 'true', {
        timeout: 4000,
      });
    }
    await expect(orderButton).toBeEnabled();
    await orderButton.click();

    await expect(status).toHaveText(`Order confirmed: ${scenario.receipt}`);
    await expect(status).toBeVisible();
  });
}

La valeur 4000 donne un budget fini à l’assertion d’état applicatif de cet exemple. Le test observé programme sa transition après 1800 millisecondes, mais le délai de programmation d’un minuteur ne garantit pas une échéance d’achèvement. Choisissez le budget de production selon le comportement pris en charge par l’application et l’environnement de test, plutôt que de copier une constante de simulation comme exigence de performance.

toBeEnabled() rend le préalable explicite pour le diagnostic ; click() conserve ses propres vérifications. Chaque cas vérifie le texte de sa confirmation avant de vérifier la visibilité du même élément d’état, au lieu d’accepter d’abord la visibilité du message initial. Aucun test ne prend networkidle comme préalable. Ces assertions renforcent les vérifications de texte du programme initial ; les observations historiques de visibilité proviennent de ses captures. Selon la documentation des assertions de Playwright, les assertions par locator réessaient jusqu’à satisfaction de la condition ou expiration du délai. Les attendre évite de transformer une lecture instantanée du DOM en test de synchronisation accidentel.

Ces assertions séquentielles ont également une limite pratique. Elles observent les conditions à leurs moments de vérification respectifs ; elles ne prouvent pas que la confirmation reste visible indéfiniment. Si une application l’affiche brièvement puis la retire à tort, testez explicitement la persistance exigée ou la suite du parcours. Dans cette simulation, la confirmation reste dans l’élément de sortie et la capture finale fournit une autre vue de cet état.

Un message de réussite visible ne suffit pas à prouver un stockage durable côté serveur. Le cas du fetch en cours enregistre au moins un véritable POST /order local et tire son texte de la réponse, tandis que le cas d’initialisation tardive affecte localement une chaîne fixe. Aucune des deux pages n’implémente de base de données. Si l’exigence concerne une écriture durable, ajoutez la vérification serveur ou la lecture ultérieure appropriée à l’application, plutôt que de prendre ces démonstrations pour une preuve de persistance.

Utiliser un signal explicite défini par l’application

Un marqueur de disponibilité contrôlé par l’application est utile lorsque le fonctionnement d’un contrôle dépend d’autre chose que de son apparence dans le DOM. Sa signification doit être définie. Pour la page contrôlée, data-ready="true" signifie que le gestionnaire de app:ready a activé le bouton et mis à jour l’état. Cela ne signifie pas que toutes les requêtes futures sont terminées ni que chaque fonction de la page est prête.

Préférez un état observable qui survive à la transition lorsqu’une étape ultérieure risque de commencer à observer après l’initialisation. Un événement unique app:ready peut survenir avant l’abonnement du test, laissant le listener attendre un événement qui ne se répétera pas. L’attribut persistant permet à l’assertion de réussir que la disponibilité arrive avant ou pendant l’attente. C’est pourquoi le programme vérifie l’attribut au lieu d’ajouter tardivement un abonnement limité à l’événement.

L’application doit garder le marqueur cohérent avec son comportement. Définir data-ready avant d’enregistrer un gestionnaire indispensable ne fait que déplacer la course initiale vers un autre nom. Pour une application contrôlée, activez le marqueur seulement après l’étape d’initialisation requise, et réinitialisez-le lorsqu’une route ou un parcours invalide cette disponibilité. Un marqueur obsolète au niveau du document est particulièrement trompeur lorsque l’action suivante vise un composant nouvellement monté.

Limitez le contrat à l’opération. Une page comportant un éditeur et un paiement indépendants peut nécessiter des conditions distinctes. Attendre un marqueur global app-ready peut bloquer inutilement une action indépendante, tandis que faire confiance au marqueur de l’éditeur pour le paiement établirait le mauvais préalable. Préférez l’état stable le plus proche déjà exposé par l’application et conservez l’assertion du résultat après l’action.

La documentation d’intégration Playwright de BotBrowser couvre le choix de son exécutable et la configuration du navigateur à partir de profils. Cette préparation ne spécifie pas le contrat de disponibilité d’une application. La comparaison ajoute une décision sur la place de l’attente : connexion et navigation d’abord, état propre à l’opération si nécessaire, puis action et vérifications du résultat. Elle ne fournit aucun constat sur les temps d’initialisation de BotBrowser.

Diagnostiquer le timeout sur la condition qui échoue

Commencez par l’opération indiquée dans l’erreur. Le cas contrôlé de fetch en cours rapporte TimeoutError dans page.waitForLoadState, avec dépassement du budget de 1200 millisecondes. Un timeout de locator.click() attire plutôt l’attention sur l’actionnabilité de la cible. Celui d’une assertion nomme un état attendu absent. Augmenter un délai global masque ces différences et peut allonger chaque échec sans résoudre la condition insatisfaite.

Pour un timeout d’inactivité, capturez les requêtes de la même exécution et déterminez quelle activité reste pertinente pour l’opération demandée. Dans la simulation, l’ensemble des réponses retenues du serveur fournit une preuve directe pour /hold, tandis que la confirmation et le journal établissent l’échange indépendant avec /order. Dans une application, la requête inachevée peut contenir des données indispensables ; retirer l’attente n’est utile que si sa remplaçante vérifie encore le résultat exigé de ces données.

Pour un clic qui ne se produit jamais, examinez la cible et les détails de l’erreur. Un nom accessible dupliqué peut sélectionner plusieurs éléments ; une superposition peut intercepter les événements ; un contrôle désactivé peut refléter une initialisation volontairement inachevée. Gardez les vérifications normales d’actionnabilité actives. Forcer le clic change ce qui est vérifié et n’enregistre pas un gestionnaire absent ni ne rend correct un parcours désactivé.

Pour un clic qui aboutit sans la confirmation désirée, comparez l’état avant et après l’action. Conservez les exceptions de page, les réponses pertinentes et l’état affiché. Le cas du bouton désactivé ne présente pas d’erreur de page dans cette exécution, mais cette absence ne prouve pas la réussite : ses vérifications explicites de disponibilité et de confirmation fournissent les observations positives. Une collection d’erreurs vide reste compatible avec une logique applicative qui n’a simplement rien fait.

Gardez les délais assez locaux pour expliquer leur rôle. Une assertion bornée peut légitimement attendre l’initialisation, tandis qu’une connexion de fond sans rapport avec l’objectif n’a pas d’échéance utile pour cette action. Un waitForTimeout() fixe ajoute du temps écoulé sans vérifier aucune de ces conditions. Un délai qui réussit aujourd’hui peut rester trop court sous charge ou gaspiller du temps lorsque l’application est déjà prête.

Questions fréquentes

Passer à domcontentloaded résout-il tous les timeouts networkidle ?

Cela change la condition de fin de navigation. Le contenu nécessaire peut encore arriver ensuite : conservez les assertions de locator et de résultat. Les exemples naviguent volontairement avec domcontentloaded pour observer séparément la suite ; ils ne démontrent pas que l’analyse du document suffit à toute opération.

Un bouton activé prouve-t-il que son gestionnaire est enregistré ?

Non. L’activation est une condition de l’élément. Le code applicatif détermine quand son comportement devient disponible. L’exemple documentaire d’hydratation concerne cet écart ; la simulation locale d’initialisation tardive l’évite en conservant disabled jusqu’à sa transition de disponibilité.

Tous les tests doivent-ils attendre un événement app:ready ?

Seule une application qui définit cet événement lui donne un sens utile. Un listener limité à l’événement nécessite aussi un enregistrement au bon moment. Un état persistant propre à l’opération peut être plus simple lorsque l’observation commence après le démarrage ; une action ordinaire et une assertion de résultat peuvent déjà suffire.

Les millisecondes enregistrées constituent-elles une mesure de performance ?

Non. Les deux cas contrôlés démontrent un ordre lors d’une exécution locale, avec des horloges distinctes pour le navigateur et le programme. Les captures et appels ajoutent du travail entre observations, et aucune distribution répétée des latences n’a été recueillie. Ils établissent les relations d’état montrées, pas la vitesse de démarrage attendue en production.

Sources

Conclusion pratique

Remplacez le préalable générique networkidle de Playwright par l’état nécessaire à l’opération suivante et une assertion de son résultat. Commencez par une action qui échoue sur une page contrôlée : identifiez si le délai concerne la navigation, l’actionnabilité ou la confirmation attendue, puis vérifiez directement cette condition. Explicitez les exigences de visibilité et de texte, et utilisez l’activité réseau comme preuve de diagnostic pour cette opération.

#Playwright#Networkidle#Disponibilité De L’interface#Débogage De Tests

Cet article fait partie du guide : Débuter avec l'automatisation du navigateur : carte initiale

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.