XPath (XML Path Language) est un langage de requête puissant utilisé pour naviguer dans le Document Object Model (DOM) des documents HTML et XML. Pour les développeurs web, les testeurs et les ingénieurs en automatisation, maîtriser XPath est essentiel pour localiser et interagir précisément avec les éléments des pages web. Que vous développiez des tests automatisés avec Selenium, Playwright ou d'autres frameworks de test, ou que vous extraiez des données de sites web, XPath offre la flexibilité et la précision nécessaires pour naviguer même dans les structures DOM les plus complexes.
Ce guide complet vous présentera tout ce que vous devez savoir sur XPath, de la syntaxe de base aux techniques avancées, vous aidant à devenir compétent dans la création d'expressions XPath robustes et efficaces.
Avant de plonger plus profondément dans XPath, prenons un moment pour présenter Apidog, la meilleure alternative à Postman disponible aujourd'hui. Apidog combine la documentation, la conception, le débogage, les tests et la simulation d'API en une seule plateforme unifiée.
Contrairement à Postman, Apidog offre une interface plus intuitive, de meilleures fonctionnalités de collaboration d'équipe et une intégration transparente entre la conception et les tests d'API. Grâce à ses puissantes capacités de test, Apidog facilite la validation des API.
Si vous travaillez avec des API et des tests web, la boîte à outils complète d'Apidog peut considérablement rationaliser votre flux de travail et améliorer la productivité.
Qu'est-ce que XPath ?
XPath est un langage de requête conçu pour sélectionner des nœuds dans les documents XML. Puisque HTML peut être considéré comme une forme spécialisée de XML, XPath peut également être appliqué efficacement aux documents HTML. Il a été introduit pour la première fois par le World Wide Web Consortium (W3C) dans le cadre de la spécification XSLT 1.0 et est depuis devenu un outil essentiel pour l'automatisation web et l'extraction de données.
XPath sert de langage de navigation, vous permettant de parcourir la hiérarchie d'un document HTML en définissant des chemins vers des éléments, un peu comme vous naviguez dans des dossiers dans un système de fichiers. Ce qui rend XPath particulièrement puissant, c'est sa capacité à :
- Naviguer dans la hiérarchie des éléments dans plusieurs directions
- Filtrer les éléments en fonction des attributs, du contenu ou de la position
- Accéder facilement aux éléments parents, enfants et frères et sœurs
- Utiliser des fonctions intégrées pour manipuler les données et comparer les valeurs
Localisateurs XPath dans l'automatisation web
Dans les frameworks d'automatisation web comme Selenium WebDriver, les localisateurs XPath servent de méthode principale pour identifier les éléments sur une page web. Bien que d'autres localisateurs comme les sélecteurs CSS, les ID ou les noms de classe soient souvent préférés pour leur simplicité et leurs performances, XPath offre une flexibilité inégalée dans les scénarios complexes.
Voici quelques avantages clés de l'utilisation de XPath dans l'automatisation web :
- Flexibilité : XPath peut localiser des éléments en fonction du contenu textuel, des relations parent-enfant et des relations frères et sœurs, ce que d'autres localisateurs ne peuvent pas facilement faire.
- Sélection basée sur le texte : XPath vous permet de trouver des éléments contenant un texte spécifique, ce qui est inestimable pour le contenu dynamique.
- Capacités de traversée : Vous pouvez naviguer vers le haut (vers les éléments parents), vers le bas (vers les éléments enfants) ou latéralement (vers les éléments frères et sœurs) dans l'arborescence DOM.
- Opérations logiques : XPath prend en charge les opérateurs logiques comme and, or et not, ce qui permet des conditions de sélection complexes.
Les essentiels de XPath
Pour utiliser XPath efficacement, il est important de comprendre ses composants et sa structure fondamentaux.
1. Syntaxe et structure
Les expressions XPath sont écrites sous forme d'une série d'étapes, séparées par des barres obliques (/), qui naviguent dans la hiérarchie des nœuds du document. Chaque étape se compose de :
- Une sélection de nœud (comme un nom d'élément ou un caractère générique)
- Des prédicats facultatifs (conditions entre crochets)
- Des axes facultatifs (spécifiant la direction de la relation)
La syntaxe de base suit ce modèle :
axisname::nodetest[predicate]
Où :
axisnamedéfinit la relation à utiliser (enfant, parent, etc.)nodetestidentifie les nœuds à sélectionnerpredicatefiltre les nœuds sélectionnés en fonction des conditions
2. Axes clés et types de nœuds
XPath fournit divers axes pour définir les relations entre les nœuds :
- child : Sélectionne tous les enfants du nœud actuel
- parent : Sélectionne le parent du nœud actuel
- ancestor : Sélectionne tous les ancêtres (parent, grand-parent, etc.)
- descendant : Sélectionne tous les descendants (enfants, petits-enfants, etc.)
- sibling : Sélectionne les frères et sœurs (nœuds avec le même parent)
- self : Sélectionne le nœud actuel
Les types de nœuds qui peuvent être sélectionnés incluent :
- element : Éléments HTML/XML
- attribute : Attributs d'élément
- text : Contenu textuel dans les éléments
- comment : Nœuds de commentaires
- processing-instruction : Nœuds d'instruction de traitement
3. Fonctions courantes
XPath comprend de nombreuses fonctions qui améliorent ses capacités :
- text() : Récupère le contenu textuel d'un élément
- contains() : Vérifie si une chaîne contient une sous-chaîne spécifique
- starts-with() : Vérifie si une chaîne commence par une sous-chaîne spécifique
- concat() : Combine plusieurs chaînes
- substring() : Extrait une partie d'une chaîne
- count() : Compte le nombre de nœuds dans un ensemble de nœuds
- position() : Renvoie la position d'un nœud dans un ensemble de nœuds
- last() : Renvoie la position du dernier nœud dans un ensemble de nœuds
Types XPath
Il existe deux approches principales pour construire des expressions XPath : absolue et relative.
Expression XPath absolue
XPath absolu fournit le chemin complet de la racine du document à l'élément cible. Il commence par une seule barre oblique (/) et inclut chaque élément de la hiérarchie.
Exemple :
/html/body/div[2]/form/input[3]
Avantages :
- Fournit un chemin précis et unique vers l'élément
- Utile lorsque vous devez cibler une instance spécifique d'un élément
Inconvénients :
- Extrêmement fragile et susceptible de se casser lorsque la structure de la page change
- Long et difficile à lire
- Nécessite une mise à jour si un élément parent change
XPath relatif
XPath relatif commence à partir de n'importe quel point du document et utilise une double barre oblique (//) pour indiquer que le chemin peut commencer n'importe où. Cette approche est plus flexible et résistante aux changements de la structure du document.
Exemple :
//input[@id='email']
Avantages :
- Plus robuste face aux changements de la structure du document
- Plus court et plus lisible
- Se concentre sur les attributs ou caractéristiques uniques de l'élément
Inconvénients :
- Peut être moins spécifique dans les documents complexes
- Pourrait potentiellement correspondre à plusieurs éléments s'il n'est pas soigneusement construit
Syntaxe XPath
Comprendre les éléments de syntaxe de base est crucial pour construire des expressions XPath efficaces :
Éléments de syntaxe de base :
- / (Barre oblique unique) : Sélectionne à partir du nœud racine, représentant un chemin absolu
- // (Double barre oblique) : Sélectionne les nœuds n'importe où dans le document qui correspondent à l'expression
- . (Point) : Fait référence au nœud actuel
- .. (Double point) : Fait référence au parent du nœud actuel
- @ (Symbole arobase) : Sélectionne les attributs
- [] (Crochets) : Contient des prédicats (conditions)
- \(Astérisque) : Caractère générique qui correspond à n'importe quel nœud d'élément
Prédicats
Les prédicats sont des conditions entre crochets qui filtrent la sélection des nœuds :
//div[@class='container'] // Sélectionne les éléments div avec la classe 'container'
//button[text()='Submit'] // Sélectionne les éléments button avec le texte 'Submit'
//li[position()=3] // Sélectionne le troisième élément li
//input[@type='text' and @required] // Sélectionne les éléments d'entrée de texte requis
Sélecteurs XPath
Les sélecteurs XPath définissent les critères de sélection des nœuds dans le document. Voici quelques modèles de sélecteurs courants :
Sélecteurs d'éléments :
//div // Sélectionne tous les éléments div
//div/p // Sélectionne tous les éléments p qui sont des enfants directs de div
//div//p // Sélectionne tous les éléments p n'importe où à l'intérieur de div
Sélecteurs d'attributs :
//*[@id='username'] // Sélectionne l'élément avec l'id 'username'
//input[@name='password'] // Sélectionne l'entrée avec le nom 'password'
//a[@href] // Sélectionne tous les liens avec l'attribut href
//img[@src='logo.png'] // Sélectionne l'image avec src spécifique
Sélecteurs de position :
//tr[1] // Sélectionne le premier élément tr
//tr[last()] // Sélectionne le dernier élément tr
//tr[position()>1] // Sélectionne tous les éléments tr sauf le premier
//ul/li[position() mod 2 = 0] // Sélectionne les éléments li de position paire
Sélecteurs de contenu textuel :
//h1[text()='Welcome'] // Sélectionne h1 avec le texte exact 'Welcome'
//p[contains(text(),'important')] // Sélectionne p contenant le mot 'important'
//label[starts-with(text(),'User')] // Sélectionne les étiquettes commençant par 'User'
Expressions XPath
Les expressions XPath peuvent aller de simples à complexes, selon les éléments que vous devez localiser. Voici quelques exemples d'expressions de plus en plus complexes :
Expressions simples :
//h1 // Tous les éléments h1
//div[@class='header'] // Tous les éléments div avec la classe 'header'
//input[@type='submit'] // Tous les boutons de soumission
Expressions intermédiaires :
//div[contains(@class,'product')]//span[@class='price'] // Portées de prix dans les div de produits
//table//tr[position() > 1] // Toutes les lignes du tableau, sauf les en-têtes
//form[.//input[@required]] // Formulaires contenant des entrées requises
Expressions avancées :
//div[not(@class='hidden') and contains(@id,'section')] // Sections visibles avec un modèle d'ID spécifique
//ul[count(./li) > 5] // Listes avec plus de 5 éléments
//a[contains(@href,'https') and not(contains(@class,'external'))] // Liens HTTPS internes
Axes XPath
Les axes définissent la direction de la navigation à partir du nœud actuel. La compréhension des axes permet une sélection d'éléments plus sophistiquée :
Axes enfant et descendant :
child::div // Équivalent à ./div
descendant::p // Équivalent à .//p
Axes parent et ancêtre :
parent::div // Div parent du nœud actuel
ancestor::form // Tout ancêtre de formulaire du nœud actuel
ancestor-or-self::div // Tout ancêtre div ou le nœud actuel s'il s'agit d'un div
Axes frères et sœurs :
following-sibling::li // Tous les frères et sœurs li qui suivent le nœud actuel
preceding-sibling::div // Tous les frères et sœurs div qui précèdent le nœud actuel
Autres axes utiles :
following::h2 // Tous les éléments h2 qui apparaissent après le nœud actuel dans le document
preceding::input // Tous les éléments d'entrée qui apparaissent avant le nœud actuel
self::p // Sélectionne le nœud actuel s'il s'agit d'un paragraphe
Opérateurs XPath
XPath prend en charge divers opérateurs pour créer des conditions complexes :
Opérateurs de comparaison :
- = : Égal à
- != : Non égal à
- < : Inférieur à
- > : Supérieur à
- <= : Inférieur ou égal à
- >= : Supérieur ou égal à
Opérateurs logiques :
- and : ET logique
- or : OU logique
- not() : NON logique
Opérateurs arithmétiques :
- + : Addition
- : Soustraction
- \: Multiplication
- div : Division
- mod : Modulus
Exemples :
//input[@value > 100] // Entrées avec une valeur supérieure à 100
//div[@class='item' and @id] // Divs avec la classe 'item' qui ont également un ID
//product[price > 50 and price < 100] // Produits avec un prix compris entre 50 et 100
//li[position() mod 2 = 1] // Éléments de liste numérotés impairs
Fonctions XPath
XPath fournit de nombreuses fonctions intégrées pour la manipulation des données :
Fonctions de chaîne :
//a[contains(text(), 'Sign up')] // Liens contenant le texte "Sign up"
//label[starts-with(@for, 'user')] // Étiquettes avec l'attribut 'for' commençant par 'user'
//p[string-length(text()) > 100] // Paragraphes avec un texte de plus de 100 caractères
//div[normalize-space(text())='Hello World'] // Divs avec le texte exact (en ignorant les espaces supplémentaires)
Fonctions numériques :
//ul[count(li) > 5] // Listes avec plus de 5 éléments
//div[round(number(@data-value)) = 42] // Divs avec une valeur de données qui s'arrondit à 42
//product[floor(price) = 99] // Produits avec un prix qui s'arrondit à 99
Fonctions d'ensemble de nœuds :
//tr[position() = last()] // Dernière ligne du tableau
//div[count(child::*) = 0] // Éléments div vides (pas d'éléments enfants)
//div[not(descendant::a)] // Divs qui ne contiennent aucun lien
Console de débogage pour XPath
L'une des méthodes les plus efficaces pour développer et tester des expressions XPath consiste à utiliser les outils de développement de votre navigateur :
Dans Chrome :
- Appuyez sur F12 ou Ctrl+Maj+I pour ouvrir DevTools
- Accédez à l'onglet Console
- Utilisez
$x("your-xpath-here")pour évaluer les expressions XPath - Les résultats apparaîtront sous forme de tableau d'éléments correspondants
Dans Firefox :
- Appuyez sur F12 ou Ctrl+Maj+I pour ouvrir DevTools
- Accédez à l'onglet Console
- Utilisez
$x("your-xpath-here")pour évaluer les expressions XPath - Les résultats apparaîtront sous forme de tableau d'éléments correspondants
Dans Edge :
- Appuyez sur F12 ou Ctrl+Maj+I pour ouvrir DevTools
- Accédez à l'onglet Console
- Utilisez
$x("your-xpath-here")pour évaluer les expressions XPath - Les résultats apparaîtront sous forme de tableau d'éléments correspondants
Cette boucle de rétroaction directe vous permet d'affiner rapidement vos expressions XPath jusqu'à ce qu'elles identifient correctement les éléments cibles.
Conseils et meilleures pratiques
1. Évitez les pièges courants
Restez simple : Les expressions XPath plus simples sont plus faciles à maintenir et moins susceptibles de se casser lorsque la structure de la page change. Visez des expressions concises qui ciblent directement votre élément à l'aide d'attributs uniques.
Évitez les chemins absolus : Les chemins absolus sont extrêmement fragiles. Si un élément du chemin change, XPath se casse. Utilisez des chemins relatifs qui se concentrent sur des identificateurs uniques chaque fois que possible.
Soyez précis : Rendez vos expressions aussi spécifiques que nécessaire, mais pas plus. La sur-spécificité peut rendre les expressions fragiles, tandis que la sous-spécificité peut correspondre à des éléments non intentionnels.
Utilisez les prédicats à bon escient : Les prédicats sont puissants pour filtrer les éléments, mais trop de prédicats imbriqués peuvent rendre les expressions difficiles à lire et à maintenir.
Tenez compte de la compatibilité inter-navigateurs : Certaines fonctionnalités XPath peuvent fonctionner différemment selon les navigateurs. Testez vos expressions dans tous les navigateurs cibles pour garantir la cohérence.
2. Optimiser les performances
Utilisez des sélecteurs efficaces : Dans la mesure du possible, utilisez des ID ou d'autres identificateurs uniques. L'expression //*[@id='username'] est généralement plus rapide que les sélecteurs hiérarchiques complexes.
Limitez l'utilisation de // : L'opérateur à double barre oblique (//) recherche dans l'ensemble du document, ce qui peut être lent. Lorsque vous connaissez l'emplacement général d'un élément, commencez par un chemin plus spécifique.
Éléments de cache : Si vous devez interagir avec le même élément plusieurs fois, stockez la référence plutôt que de la localiser à plusieurs reprises avec XPath.
Minimiser les appels XPath : Chaque évaluation XPath prend du temps. Regroupez les opérations lorsque cela est possible pour réduire le nombre de recherches.
Tester les performances : Si vous remarquez des ralentissements dans vos tests automatisés, profilez-les pour identifier si les requêtes XPath sont le goulot d'étranglement. Envisagez d'autres sélecteurs si nécessaire.
3. Déboguer efficacement
Utilisez les outils de développement du navigateur : La plupart des navigateurs modernes vous permettent de tester les expressions XPath directement dans la console. Cela fournit une rétroaction immédiate sur le fonctionnement de votre expression.
Résultats de sortie : Pendant le développement et le débogage, enregistrez les résultats de vos requêtes XPath pour vérifier que vous sélectionnez les éléments souhaités.
Parcourir le code pas à pas : Utilisez des points d'arrêt et un débogage pas à pas dans votre framework de test pour inspecter l'état de votre application et les résultats XPath.
Commentez votre XPath : Ajoutez des commentaires pour expliquer les expressions XPath complexes, en particulier lors de l'utilisation de fonctionnalités avancées ou de la gestion des cas limites.
Examinez et refactorisez régulièrement : Au fur et à mesure que votre application évolue, examinez périodiquement vos expressions XPath pour vous assurer qu'elles restent fiables et efficaces.
Fiche de référence XPath
Voici un guide de référence complet pour les expressions XPath :
Syntaxe XPath de base :
/ // Sélectionne à partir du nœud racine
// // Sélectionne les nœuds n'importe où dans le document
. // Représente le nœud actuel
.. // Représente le parent du nœud actuel
Sélecteurs :
element // Sélectionne tous les éléments avec le nom donné
@attribute // Sélectionne la valeur de l'attribut spécifié
* // Sélectionne tous les éléments enfants
text() // Sélectionne le texte dans un élément
[predicate] // Ajoute une condition pour filtrer les nœuds
Prédicats :
[name='value'] // Sélectionne les nœuds avec la valeur d'attribut spécifiée
[position()] // Sélectionne les nœuds en fonction de leur position
[last()] // Sélectionne le dernier nœud d'un type donné
[contains(@attribute, 'value')] // Sélectionne les nœuds avec des valeurs d'attribut contenant 'value'
[not(predicate)] // Négation d'une condition
Axes :
ancestor:: // Sélectionne tous les ancêtres
ancestor-or-self:: // Sélectionne les ancêtres et le nœud actuel
child:: // Sélectionne tous les enfants
descendant:: // Sélectionne tous les descendants
descendant-or-self:: // Sélectionne les descendants et le nœud actuel
following:: // Sélectionne tous les nœuds suivants
following-sibling:: // Sélectionne les frères et sœurs suivants
parent:: // Sélectionne le nœud parent
preceding:: // Sélectionne tous les nœuds précédents
preceding-sibling:: // Sélectionne les frères et sœurs précédents
self:: // Sélectionne le nœud actuel
Opérateurs :
= // Égal à
!= // Non égal à
< // Inférieur à
<= // Inférieur ou égal à
> // Supérieur à
>= // Supérieur ou égal à
and // ET logique
or // OU logique
not // NON logique
Fonctions (Exemples) :
name() // Renvoie le nom du nœud actuel
count(nodes) // Renvoie le nombre de nœuds dans l'ensemble de nœuds
concat(string1, string2) // Concatène deux chaînes
substring(string, start, length) // Renvoie une sous-chaîne
contains(string, substr) // Vérifie si une chaîne contient une sous-chaîne
normalize-space(string) // Supprime les espaces blancs de début/de fin et réduit les espaces
Exemples :
/bookstore/book // Sélectionne tous les éléments book dans la librairie racine
//title[text()='XPath'] // Sélectionne les éléments de titre avec le texte 'XPath' n'importe où dans le document
//*[@id='myId'] // Sélectionne les éléments avec l'attribut id égal à 'myId'
/bookstore/book[position()=1] // Sélectionne le premier élément book
//div[@class='highlight']//p // Sélectionne les éléments p dans div avec la classe 'highlight'
//a[contains(@href, 'example.com')] // Sélectionne les éléments a avec 'example.com' dans l'attribut href
Techniques XPath avancées
Travailler avec des ID et des classes dynamiques
Les frameworks web modernes génèrent souvent des ID et des classes dynamiques qui changent à chaque chargement de page. Voici des techniques pour gérer ces scénarios :
// Utilisation de la correspondance partielle d'attributs
//div[contains(@id, 'main-content')]
//button[starts-with(@id, 'submit-')]
//input[ends-with(@id, '-input')] // Remarque : Il s'agit de XPath 2.0 et n'est pas pris en charge dans tous les navigateurs
// Utilisation de modèles de noms de classe
//div[contains(@class, 'btn') and contains(@class, 'primary')]
Gestion des iframes
La sélection d'éléments dans les iframes nécessite une gestion spéciale :
// Tout d'abord, localisez l'iframe
//iframe[@id='content-frame']
// Ensuite, dans Selenium, vous basculeriez vers le contexte de l'iframe avant d'utiliser XPath pour trouver des éléments à l'intérieur
// driver.switchTo().frame(driver.findElement(By.xpath("//iframe[@id='content-frame']")));
// Après avoir basculé, vous pouvez utiliser XPath normalement dans le contexte de l'iframe
//button[@id='submit']
Détection de la visibilité des éléments
XPath lui-même ne peut pas déterminer directement si un élément est visible, mais vous pouvez vérifier les propriétés qui indiquent souvent la visibilité :
// Les éléments avec display:none ont souvent un style en ligne
//div[not(contains(@style, 'display: none'))]
// Les éléments peuvent être masqués via des classes
//div[not(contains(@class, 'hidden'))]
// Les éléments peuvent avoir un attribut aria-hidden
//div[not(@aria-hidden='true')]
Gestion de plusieurs éléments avec les mêmes propriétés
Lorsque plusieurs éléments partagent les mêmes attributs ou propriétés, vous pouvez utiliser l'indexation ou des attributs plus spécifiques :
// Sélectionnez le deuxième bouton avec la classe 'action'
(//button[@class='action'])[2]
// Sélectionner en fonction du contenu textuel et de la classe
//button[@class='action' and contains(text(), 'Save')]
// Sélectionner en fonction des éléments environnants
//div[@class='card']//button[contains(text(), 'View details')]
XPath dans différents frameworks de test
Selenium WebDriver
Selenium prend en charge directement les localisateurs XPath :
// Exemple Java
WebElement element = driver.findElement(By.xpath("//button[@id='submit']"));
# Exemple Python
element = driver.find_element(By.XPATH, "//button[@id='submit']")
// Exemple JavaScript
const element = await driver.findElement(By.xpath("//button[@id='submit']"));
Playwright
Playwright prend en charge les sélecteurs XPath, bien que les sélecteurs CSS soient recommandés pour de meilleures performances :
// Exemple JavaScript
const element = await page.locator('xpath=//button[@id="submit"]');
await element.click();
# Exemple Python
element = page.locator('xpath=//button[@id="submit"]')
element.click()
Cypress
Cypress prend en charge XPath avec un plugin :
// Tout d'abord, installez le plugin : npm install -D cypress-xpath
// Ajouter à cypress/support/e2e.js :
// require('cypress-xpath')
// Ensuite, utilisez dans les tests
cy.xpath('//button[@id="submit"]').click()
Exemples XPath concrets
Exemples de sites web de commerce électronique :
// Trouver tous les produits avec une remise
//div[@class='product'][.//span[@class='discount']]
// Trouver les produits avec un prix dans une plage spécifique
//div[@class='product'][.//span[@class='price' and number(translate(text(), '$', '')) < 100]]
// Trouver les produits avec une note de 4 étoiles et plus
//div[@class='product'][.//div[@class='rating' and @data-stars >= 4]]
Exemples de validation de formulaire :
// Trouver tous les champs obligatoires
//input[@required]
// Trouver les champs avec des erreurs de validation
//input[../span[@class='error']]
// Trouver les étiquettes des champs obligatoires
//label[./following-sibling::input[@required] or ./input[@required]]
Exemples de données de tableau :
// Trouver les lignes du tableau avec un contenu spécifique
//table[@id='data']//tr[td[contains(text(), 'Completed')]]
// Trouver la cellule d'en-tête pour une colonne spécifique
//table//th[contains(text(), 'Status')]
// Trouver les cellules dans la même colonne qu'un en-tête spécifique
//table//th[contains(text(), 'Status')]/following-sibling::td
Conclusion
Maîtriser XPath est une compétence fondamentale pour toute personne impliquée dans l'automatisation des tests web ou l'extraction de données. Ce guide vous a doté d'une compréhension approfondie des éléments essentiels, de la syntaxe, des sélecteurs et des meilleures pratiques de XPath. En mettant en œuvre ces stratégies, vous pouvez optimiser vos processus de test automatisés, améliorer la fiabilité des tests et naviguer en toute confiance, même dans les structures DOM les plus complexes.
La flexibilité et la puissance de XPath en font un outil indispensable dans votre boîte à outils de test, en particulier lorsque vous traitez des applications web complexes où des localisateurs plus simples peuvent ne pas suffire. Bien que les sélecteurs CSS soient souvent préférés pour leurs performances, il existe de nombreux scénarios où les capacités uniques de XPath, comme la sélection d'éléments en fonction du contenu textuel ou la traversée de la
