Iframe Playwright : chargement ou mauvais cadre ?
Diagnostiquez une iframe qui ne charge pas, un Frame détaché ou un mauvais cadre imbriqué. Comparez trois tests locaux et vérifiez le document et la confirmation.
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 iframe Playwright qui ne charge pas peut signifier que l’élément iframe imbriqué n’est jamais apparu, qu’un Frame précédemment sélectionné a été détaché ou que le test est entré dans un document frère chargé qui ne contient pas la cible. Inspectez l’arbre des cadres et identifiez le document contenant le contrôle avant d’allonger le délai d’attente. BotBrowser permet l’intégration avec Playwright grâce à son exécutable de navigateur et à la configuration des profils ; il ne crée pas l’iframe manquante d’une application et ne décide pas quel document intégré une action doit cibler.
Résumé
- Vérifiez séparément chaque frontière entre documents : l’élément iframe extérieur, son élément iframe enfant, puis le contrôle dans le document de cet enfant.
- Conservez un
FrameLocatorpour décrire un chemin par sélecteurs lorsqu’une application remplace son iframe. Un localisateur créé depuis un ancienFramedétaché reste lié à ce cadre ancien. - Un cadre chargé sans bouton correspondant peut être le mauvais frère. Comparez les relations parent-enfant et les URL des documents au lieu de choisir selon la position dans un tableau.
- Trois pages de test locales contrôlées ont réussi 3/3 vérifications de scénario, y compris leurs échecs intentionnels. Seuls deux cas ont envoyé une commande ; le cas sans enfant n’en a envoyé aucune, conformément au résultat attendu.
- Vérifiez le document sélectionné et la réponse de l’application. Un clic terminé ne démontre pas à lui seul que le processus intégré prévu a réussi.
Sommaire
- Identifier l’élément iframe et son document
- Premier cas : l’élément iframe imbriqué est absent
- Deuxième cas : le remplacement détache l’ancien Frame
- Troisième cas : la cible appartient à un cadre frère
- Vérifier le document et le résultat fonctionnel
- Capturer un arbre des cadres avant de modifier l’attente
- Conclusion pratique
Identifier l’élément iframe et son document
Une iframe présente deux côtés pertinents. L’élément <iframe> appartient au document parent ; la page intégrée possède son propre document et ses contrôles. Trouver #outer dans la page établit que l’élément iframe existe. Cela ne prouve ni que l’élément #inner attendu existe dans le document extérieur, ni que l’un de ces documents contient un bouton nommé Place order.
La documentation Playwright sur les cadres présente les interactions limitées à un cadre. Avec du contenu imbriqué, la chaîne de localisateurs doit suivre les frontières correspondantes. Dans les exemples contrôlés ci-dessous, page.frameLocator('#outer').frameLocator('#inner') entre dans le document extérieur, puis dans son document intérieur. Un simple page.getByRole('button') cherche dans le document principal ; un sélecteur CSS descendant ordinaire ne traverse pas la frontière du document d’une iframe.
L’API FrameLocator représente la logique permettant de retrouver l’iframe et d’y localiser des éléments. Un objet Frame, obtenu par des API comme page.frame(), représente un cadre particulier. Cette distinction devient observable lorsqu’une application retire un élément iframe et en insère un autre avec les mêmes attributs. Un chemin de sélecteurs stable peut décrire le remplacement, tandis que l’objet de l’ancien cadre ne peut pas devenir le cadre nouvellement attaché.
| Symptôme lors de l’action en échec | Éléments à recueillir | Première piste de correction |
|---|---|---|
| Le cadre extérieur existe ; le nombre d’iframes imbriquées est nul | Rechercher l’élément iframe enfant dans le document extérieur | Vérifier la condition d’insertion de l’application et le sélecteur |
Frame was detached | Identité de l’ancien cadre et événement framedetached | Résoudre le cadre actuel par son chemin prévu |
| Un frère chargé ne contient aucune cible correspondante | Relation parent-enfant, URL du document et nombre de cibles | Sélectionner le frère qui porte le processus |
| Plusieurs éléments iframe correspondent | Nombre de correspondances à la frontière ambiguë | Donner au cadre une identité applicative unique |
| Bon cadre et une cible, mais le clic attend encore | Détails d’actionnabilité du localisateur | Vérifier l’état du contrôle et la réception des événements |
La ligne sur l’ambiguïté concerne la sélection du cadre elle-même. Les violations du mode strict de Playwright expliquent les correspondances multiples et le périmètre des composants ; le même besoin d’identité s’applique avant d’entrer dans un cadre. Un localisateur de bouton au nom unique ne peut pas corriger deux éléments iframe indiscernables si le choix du cadre est déjà ambigu. La sélection par position convient uniquement lorsque cette position fait réellement partie du contrat de l’application.
Le 2026-11-18, trois cas contrôlés sur localhost ont été exécutés avec Playwright 1.58.0, Chrome 157.0.8103.79 non modifié et macOS arm64. Trois navigateurs sans interface ont fonctionné simultanément, chacun avec une zone d’affichage de 1150 × 850. L’exécution complète a duré 3846 millisecondes et a indiqué pass: 3, fail: 0. Il s’agissait de pages de test avec Chrome standard, sans profil BotBrowser, service intégré distant ni parcours d’achat en production.
Chaque scénario comportait délibérément un échec ou une cible absente. Sa réussite signifie que l’échec attendu et les assertions d’état suivantes correspondaient à la conception du test. Cela ne signifie pas que les trois clics initiaux ont réussi, ni qu’une correction a été démontrée pour un document manquant. Les sections suivantes distinguent ces résultats.
Premier cas : l’élément iframe imbriqué est absent
La première page affiche une iframe extérieure dont le document indique que l’élément iframe imbriqué est absent. Il n’existe aucun nœud #inner dans lequel entrer. La navigation utilise waitUntil: 'load', et le document extérieur peut être interrogé : l’échec enregistré est donc plus précis qu’une affirmation générale selon laquelle la page n’aurait jamais chargé.
L’arbre ne contient que deux cadres actifs. Voici une représentation compacte des noms enregistrés, des relations parent-enfant et des chemins URL ; le port temporaire du serveur local est omis :
top #1 /top?case=missing-child
└─ outer #2 /outer?case=missing-child
targetDocument: null
businessOrders: 0
visibleTopStatus: No order yet
Le programme de test a vérifié par assertion qu’il existait un élément iframe extérieur dans le document principal et aucun élément #inner à l’intérieur. Il a ensuite tenté le clic imbriqué avec un délai de diagnostic délibérément court et a intercepté le TimeoutError attendu de locator.click.
Ce délai de 650 millisecondes appartient à un cas négatif local déterministe. Ce n’est pas une durée recommandée pour une application intégrée en production. Le constat utile vient de l’élément iframe absent et de l’arbre capturé, plutôt que du nombre exact de millisecondes avant l’échec de l’action.
const outer = page.frameLocator('#outer');
await expect(page.locator('#outer')).toHaveCount(1);
await expect(outer.locator('#inner')).toHaveCount(0);
const target = outer.frameLocator('#inner').getByRole('button', {
name: 'Place order',
});
await expect(target.click({ timeout: 650 })).rejects.toThrow(/Timeout/);
await expect(page.getByRole('status')).toHaveText('No order yet');
Ces instructions Playwright Test s’appliquent à la page de test déjà chargée, avec expect importé depuis @playwright/test. L’assertion sur un nombre nul convient puisque cette page omet volontairement son enfant. Si une application promet d’insérer l’enfant après une transition, vérifiez le nombre positif requis après avoir déclenché cette transition. Un count() immédiat peut aider à prendre une photographie de diagnostic, mais il ne réessaie pas jusqu’à l’arrivée d’un élément retardé.
La capture montre un document extérieur sans parcours d’achat intégré. Le journal du serveur contient indépendamment zéro commande pour ce cas. Ces observations étayent l’absence de cible et l’absence de changement du processus ; l’image seule ne pourrait pas établir qu’aucune requête cachée n’a été envoyée.
Dans une application que vous contrôlez, examinez la condition responsable de la création de #inner : un onglet sélectionné, un prérequis terminé, l’état d’une fonctionnalité ou la bonne route. Aucune de ces causes possibles en production n’a été testée ici. Allonger le délai du clic donne seulement plus de temps à une insertion pour se produire ; cela ne peut pas faire afficher à une branche applicative un contenu qu’elle n’est pas conçue pour afficher. De même, modifier le nom d’un bouton ne sert à rien avant que son document existe.
Deuxième cas : le remplacement détache l’ancien Frame
La page de remplacement commence avec #outer contenant #inner, dont le document d’achat porte data-generation="1" sur le bouton. La page principale expose un contrôle Replace nested frame. Son gestionnaire de messages provoque la création d’une nouvelle iframe dans le document extérieur et appelle replaceWith() sur l’ancienne. Le nouvel élément conserve id="inner" et name="inner", mais son URL sélectionne la génération 2.
Avant de déclencher le remplacement, le programme de test a conservé deux chemins de ciblage différents. L’un était un localisateur de bouton fondé sur des FrameLocator imbriqués. L’autre était un localisateur de bouton créé depuis l’objet Frame sélectionné à cet instant. La comparaison porte ainsi sur l’appartenance au cadre, plutôt que sur la déclaration d’une variable JavaScript avant ou après la transition.
const outer = page.frameLocator('#outer');
const target = outer.frameLocator('#inner').getByRole('button', {
name: 'Place order',
});
await expect(target).toHaveAttribute('data-generation', '1');
const oldFrame = page.frame({ name: 'inner' });
if (!oldFrame) throw new Error('Initial inner frame is absent');
const oldTarget = oldFrame.getByRole('button', { name: 'Place order' });
const detached = page.waitForEvent('framedetached', {
predicate: frame => frame === oldFrame,
timeout: 3000,
});
await page.getByRole('button', { name: 'Replace nested frame' }).click();
await detached;
expect(oldFrame.isDetached()).toBe(true);
await expect(target).toHaveAttribute('data-generation', '2');
La page de test possède exactement un cadre nommé inner lors de la sélection initiale. Une application réelle a besoin d’une identité tout aussi unique ; les noms des cadres ne sont pas automatiquement uniques dans une page quelconque. L’attente de l’événement est enregistrée avant le clic déclencheur et exige l’objet d’origine : le détachement d’un cadre analytique sans rapport ne peut donc pas la satisfaire.
L’arbre des cadres observé a changé comme suit. Les identifiants numériques sont attribués par le programme de test pour distinguer les objets de cadre dans ce cas ; ce ne sont pas des identifiants permanents fournis par le navigateur.
before:
top #1 /top?case=replacement
└─ outer #2 /outer?case=replacement
└─ inner #3 /leaf?case=replacement&generation=1
after:
top #1 /top?case=replacement
└─ outer #2 /outer?case=replacement
└─ inner #4 /leaf?case=replacement&generation=2
Le programme a enregistré le détachement de l’ancien cadre #3 à 1135 millisecondes, puis l’attachement du nouveau cadre #4 à 1137 millisecondes. Ce sont des horodatages écoulés depuis le début du scénario. Leur ordre confirme le retrait et le remplacement dans cette exécution ; les deux millisecondes qui les séparent ne constituent ni une garantie de latence du navigateur ni un délai d’attente à copier dans un test.
L’appel à oldTarget.click({ timeout: 650 }) après le détachement a produit :
locator.click: Frame was detached
Le localisateur target conservé a, lui, résolu le nouveau bouton, dont l’URL du document propriétaire se terminait par /leaf?case=replacement&generation=2. Il a cliqué sur la génération 2 et produit un POST /order?case=replacement&generation=2. Les documents enfant et principal contenaient ensuite tous deux Order confirmed: REPLACEMENT-2.
Cela démontre le remplacement de l’élément iframe. Une navigation dans une iframe existante est une autre transition et ne doit pas être automatiquement qualifiée de problème de cadre détaché. L’API Frame distingue attachement, navigation et détachement. Utilisez les événements réels du cycle de vie pour déterminer si un cadre particulier a disparu ou a simplement navigué.
Un FrameLocator ne promet pas non plus de réussir en cas de remplacement continu. Son sélecteur doit toujours identifier l’iframe souhaitée, le remplacement doit exposer le contrôle requis et l’actionnabilité doit être satisfaite au moment de l’action. Si l’application supprime sans cesse son parcours d’achat, conservez cet échec de cycle de vie au lieu de le masquer dans une boucle de tentatives illimitée.
Troisième cas : la cible appartient à un cadre frère
La page des cadres frères donne deux enfants au document extérieur : content et checkout. Les deux chargent correctement. Le document de contenu ne comporte explicitement aucun bouton d’achat ; le document d’achat contient le contrôle Place order requis. Un test entrant dans #content peut donc attendre sans succès alors que le contrôle voulu est visible ailleurs dans la page.
top #1 /top?case=sibling
└─ outer #2 /outer?case=sibling
├─ content #3 /leaf?case=sibling&role=content
│ buttons: []
└─ checkout #4 /leaf?case=sibling&role=checkout
buttons: [Place order]
Le programme de test a vérifié l’existence de chaque élément iframe enfant, puis a affirmé par assertion qu’aucun bouton correspondant ne se trouvait dans content. Le clic tenté à travers ce mauvais frère a produit un TimeoutError de locator.click avec le même délai de 650 millisecondes que le cas sans enfant. Le seul intitulé de l’erreur ne distingue donc pas ces deux échecs : une chaîne manque d’un élément iframe imbriqué, tandis que l’autre entre dans un véritable document sans le bouton.
const outer = page.frameLocator('#outer');
const content = outer.frameLocator('#content');
const checkout = outer.frameLocator('#checkout');
await expect(outer.locator('#content')).toHaveCount(1);
await expect(outer.locator('#checkout')).toHaveCount(1);
await expect(content.getByRole('button', { name: 'Place order' })).toHaveCount(0);
const target = checkout.getByRole('button', { name: 'Place order' });
await expect(target).toHaveCount(1);
await target.click();
await expect(checkout.getByRole('status')).toHaveText('Order confirmed: SIBLING-1');
La correction déplace ici la frontière du cadre de #content vers #checkout. Elle n’élargit pas le nom du bouton et ne désactive pas les vérifications d’actionnabilité. Le document propriétaire de la cible enregistrée était /leaf?case=sibling&role=checkout, et le serveur a reçu exactement une commande pour ce cas. La confirmation renvoyée est parvenue au document d’achat comme au document principal.
Ne transformez pas ce résultat en règle comme « la deuxième iframe est celle de l’achat ». Dans cette page de test, des identifiants explicites définissent le rôle des documents. Une publicité, un aperçu intégré ou une mise à jour applicative peuvent modifier l’ordre d’énumération sans changer l’identité du parcours d’achat. Utilisez un titre, un nom, un identifiant de test ou un autre sélecteur stable défini par l’application, dont le sens résiste à ce changement.
Les URL apportent une corroboration utile, avec certaines limites. Deux cadres peuvent partager une URL, et un parcours d’achat valide peut naviguer entre plusieurs URL. Dans cet arbre contrôlé, le paramètre de requête role fournit une distinction commode parce que le test la définit. Dans une intégration en production, vérifiez l’identité et l’état documentés du cadre au lieu de supposer qu’une sous-chaîne comme payment identifie toujours le bon document.
Vérifier le document et le résultat fonctionnel
Les cas de remplacement et de cadres frères ne se contentent pas d’attendre un bouton. Juste avant le clic, le programme évalue le bouton correspondant pour obtenir son ownerDocument.URL, sa génération et son texte. Cette photographie associe le contrôle sélectionné à un document précis à cet instant de vérification. Elle complète l’arbre des cadres : celui-ci décrit tous les documents actifs, tandis que l’évaluation de la cible décrit l’élément réellement trouvé par le localisateur.
const selected = await target.evaluate(button => ({
url: button.ownerDocument.URL,
generation: button.dataset.generation,
text: button.textContent,
}));
console.log(selected);
Cette évaluation ne réserve pas l’élément de manière atomique. Une action ultérieure résout à nouveau son localisateur, et l’application peut changer entre la photographie et le clic. Le test de remplacement vérifie donc la génération 2 ainsi qu’une confirmation qui inclut elle-même cette génération. Son tableau de commandes côté serveur apporte une autre vérification indépendante : l’ancienne génération n’a envoyé aucune commande.
| Scénario | Document cible | Commandes enregistrées | Texte final du document principal |
|---|---|---|---|
| Enfant absent | Aucun | 0 | No order yet |
| Remplacement | /leaf?case=replacement&generation=2 | 1, génération 2 | Order confirmed: REPLACEMENT-2 |
| Mauvais frère, puis bon frère | /leaf?case=sibling&role=checkout | 1, génération 1 | Order confirmed: SIBLING-1 |
Chaque clic réussi effectue un véritable POST HTTP local. Le gestionnaire du document feuille lit la confirmation JSON, met à jour son propre statut et transmet la confirmation par messages aux parents. Le document extérieur la relaie à la page principale. Une confirmation dans la page principale dépend donc du chemin de messages du test autant que de l’interaction intégrée. Un relais défectueux pourrait laisser le statut principal inchangé malgré la réussite de l’opération enfant ; diagnostiquez séparément ces deux observations.
Le programme enregistré utilise toHaveText() pour les assertions de confirmation. Cela vérifie la condition textuelle, pas la visibilité. Ses captures finales montrent séparément les confirmations rendues. Lorsqu’un test exige un retour visible, affirmez explicitement cette exigence sur le même élément de statut :
const childStatus = checkout.getByRole('status');
const topStatus = page.getByRole('status');
await expect(childStatus).toHaveText('Order confirmed: SIBLING-1');
await expect(childStatus).toBeVisible();
await expect(topStatus).toHaveText('Order confirmed: SIBLING-1');
await expect(topStatus).toBeVisible();
Ces assertions de visibilité supplémentaires constituent un modèle de test réutilisable ; ce ne sont pas des assertions ajoutées rétroactivement à l’exécution enregistrée. Les assertions de localisateurs Playwright réessaient la condition spécifiée. Une vérification textuelle suivie d’une vérification de visibilité observe toujours deux instants, sans garantir que le statut restera visible indéfiniment.
Le serveur de test conserve les commandes en mémoire et n’implémente aucune base de données. Son POST et la confirmation correspondante établissent le processus requête-réponse démontré, pas la persistance durable d’un achat. Si l’application exige une commande sauvegardée, utilisez une lecture ultérieure ou une assertion serveur qu’elle prend en charge. Évitez de cliquer automatiquement une nouvelle fois si la confirmation manque : le premier envoi peut déjà avoir réussi.
Capturer un arbre des cadres avant de modifier l’attente
Pour une page autorisée, une petite sonde indépendante peut enregistrer les relations parent-enfant et les événements du cycle de vie sans déclencher d’action fonctionnelle. Installez playwright dans un projet Node, installez son navigateur avec npx playwright install chromium, puis enregistrez le code suivant dans inspect-frames.mjs. Exécutez node inspect-frames.mjs http://127.0.0.1:3000/your-page sur une page que vous contrôlez, déjà servie à cette adresse, en remplaçant l’URL par la cible que vous êtes autorisé à inspecter.
import { chromium } from 'playwright';
const targetURL = process.argv[2];
if (!targetURL) throw new Error('Pass an authorized page URL');
const browser = await chromium.launch();
try {
const page = await browser.newPage();
const ids = new WeakMap();
let nextId = 1;
const id = frame => {
if (!ids.has(frame)) ids.set(frame, nextId++);
return ids.get(frame);
};
const describe = frame => {
const parent = frame.parentFrame();
return {
id: id(frame),
parentId: parent ? id(parent) : null,
name: frame.name(),
url: frame.url(),
detached: frame.isDetached(),
};
};
for (const event of ['frameattached', 'framenavigated', 'framedetached']) {
page.on(event, frame => console.log(event, describe(frame)));
}
await page.goto(targetURL, { waitUntil: 'domcontentloaded' });
console.table(page.frames().map(describe));
} finally {
await browser.close();
}
La sonde s’abonne avant la navigation et peut donc observer le cycle de vie initial des cadres. Son tableau est une photographie prise après DOMContentLoaded ; il ne promet pas que tous les cadres ultérieurs sont apparus. Pour un enfant créé après une transition applicative, placez la capture du tableau après l’assertion explicite de cette transition dans le véritable test. La sonde ferme volontairement son navigateur une fois terminée et ne reste pas ouverte à attendre des événements futurs arbitraires.
Un cadre attaché peut initialement avoir une URL vide avant son événement de navigation. Traitez cette observation intermédiaire comme une étape de la séquence, sans lui attribuer immédiatement l’identité du document intégré final. Ne vous fiez pas non plus à parentFrame() au moment du détachement pour reconstruire l’ascendance historique : conservez l’enregistrement antérieur d’attachement ou de l’arbre. Les événements de cadres de la page et les relations entre cadres documentent les observations disponibles dans l’API.
Pour un remplacement intermittent, conservez la séquence d’événements à côté de l’action en échec. Les traces Playwright pour le débogage des tests fournissent des photographies des actions et une chronologie montrant les transitions autour de l’échec. Ouvrir la page actuelle après l’échec d’un test peut révéler un remplacement sain tout en perdant l’ancien cadre et le contexte exact du localisateur responsable. Masquez les jetons et les valeurs propres aux comptes dans les URL des cadres avant de partager les journaux.
Ce n’est qu’après avoir trouvé le bon document qu’un délai de clic dépassé doit devenir une investigation d’actionnabilité. L’actionnabilité de Playwright couvre notamment la visibilité, la stabilité, l’activation et la réception des événements. force: true n’insère pas une iframe manquante, ne rattache pas un ancien cadre et ne déplace pas le bouton dans un frère sélectionné. Si la cible est correcte mais qu’une attente concerne un trafic réseau sans rapport, les délais networkidle et la disponibilité de l’interface distinguent cette condition d’attente de l’état nécessaire à l’interaction.
Les exemples emploient des documents localhost de même origine afin de contrôler le cycle de vie, le contenu et les commandes enregistrées. Ils ne testent ni l’authentification entre origines, ni les permissions du bac à sable, ni les politiques de sécurité du contenu, ni les restrictions d’intégration de tiers. Les API de cadres prises en charge par Playwright constituent l’interface de contrôle adaptée aux documents intégrés ; l’accès JavaScript depuis la page parente reste séparément limité par la politique de même origine du navigateur. Une intégration réelle bloquée nécessite ses propres preuves de réponse et de console avant de lui attribuer l’une de ces explications locales.
L’intégration Playwright de BotBrowser documente la configuration de l’exécutable et du profil permettant d’utiliser le client d’automatisation avec BotBrowser. Cette configuration peut fournir un environnement de navigateur contrôlé pour reproduire un problème applicatif. Elle ne peut pas identifier le parcours d’achat à partir d’un index générique d’iframe, garantir qu’un remplacement reste monté ou établir le résultat d’une commande. Les trois cas exécutés avec Chrome standard ajoutent des comparaisons d’arbres, de cycle de vie et de confirmations au-delà de la configuration de démarrage ; ils ne démontrent aucun comportement de cadre propre à BotBrowser.
Questions fréquentes
Attendre le chargement de l’iframe extérieure couvre-t-il tous les cadres imbriqués ?
Aucune étape de chargement unique ne prouve l’existence de tous les futurs documents enfants. Une application peut insérer une iframe imbriquée après le chargement du document extérieur. Vérifiez l’élément enfant voulu et l’état requis au moment de son utilisation ; gardez cette assertion dans le bon document parent.
Chaque navigation est-elle une erreur de cadre détaché ?
Non. Navigation et détachement sont des événements distincts du cycle de vie. Une iframe peut naviguer en conservant son objet de cadre. L’exemple de remplacement retire précisément un élément et attache un nouveau cadre ; une autre transition exige sa propre séquence réelle d’événements.
Peut-on conserver un FrameLocator avant l’apparition de l’iframe ?
Oui. Créer un FrameLocator décrit un chemin de récupération, sans exiger qu’une recherche d’élément réussisse immédiatement. Son action ultérieure nécessite toujours que le cadre correspondant et la cible deviennent disponibles avant l’expiration du délai applicable. La construction seule ne vérifie pas la disponibilité.
Pourquoi deux problèmes de cadres différents produisent-ils le même délai dépassé ?
Un clic imbriqué attend une chaîne de conditions. Dans le cas enregistré sans enfant, un élément iframe est absent ; dans le cas des frères, le document sélectionné ne contient pas le bouton. Conservez le journal complet des appels et interrogez chaque frontière pour distinguer les conditions non satisfaites.
Sources
- Playwright : cadres et interactions dans un cadre
- Playwright : API FrameLocator et mode strict
- Playwright : cycle de vie et relations de Frame
- Playwright : événements d’attachement des cadres de page
- Playwright : actionnabilité
- Playwright : assertions avec nouvelles tentatives
- MDN : politique de même origine
- BotBrowser : intégration Playwright
Conclusion pratique
Pour une iframe Playwright qui ne charge pas ou un délai dépassé dû au mauvais cadre, inspectez une chaîne de localisateurs en échec, frontière par frontière. Établissez si l’élément enfant existe, si le cadre sélectionné a survécu à la transition applicative et si la cible appartient à ce document. Conservez ensuite le chemin du cadre voulu, effectuez l’action une seule fois et vérifiez le résultat propre au processus. Commencez par une capture de l’arbre à côté de l’action en échec ; elle distingue trois défauts différents avant qu’un changement de délai ne les masque.
Cet article fait partie du guide : Débuter avec l'automatisation du navigateur : carte initiale
Articles Connexes
Selenium Shadow DOM : recherches et racines détachées
DémarrageTimeout networkidle Playwright : attendre l’interface
DémarrageSelenium element not interactable : causes et correctifs
DémarragePlaywright : attendre la réponse après un clic
PlateformePermissions Policy pour les fonctions du navigateur intégrées
DémarrageAttentes Selenium WebDriver pour des tests stables
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.