Navigating the web as an automation tester involves ensuring applications are bug-free and offer exceptional user experiences. With the vast number of websites and continuous development, making websites compatible and functionally efficient is crucial.
XPath testing is essential for achieving this, as it provides a flexible and powerful way to locate elements and attributes within XML documents. XPath testers use advanced techniques to handle diverse scenarios and extract data precisely, making it a valuable tool for testing teams and developers.
In this article, you will first see what XPath is and the types of XPath, and then you will see the advanced techniques that the XPath tester can use to master complex element selection.
Introduction to XPath
XPath is used to select the various nodes from an XML document. Its widespread usage is attributed to its flexibility in navigating the XML structure’s elements and attributes. XPath plays a crucial role if you want to traverse the XML document, and it allows you to select the elements and attributes based on their names, values, and positions in the document hierarchy.
XPath is also used to extract data from an XML document. Apart from this, XPath is also used to check whether a specific element exists or not. Also, you can check the attribute within the XML document, showcasing its versatility in handling various aspects of XML data. This is a general idea of XPath. Now, let us see what XPath is in Selenium.
Concerning automation Selenium testing, XPath is a very powerful technique used to traverse the HTML structure of a website on which you are about to perform testing. Using the XPath, you can easily navigate HTML and XMP documents in a standard manner. You can precisely and faster allocate the web elements using XPath.
Syntax of XPath:
The syntax of XPath Selenium is as follows:
XPath = //tagname[@Attribute=’Value’]
where,
- //: It is used to denote the current node.
- tag name: It is used to denote the name of the tag of your current node.
- @: It is used to denote the “Select” attribute.
- Attribute: It is used to denote the attribute of the node.
- Value: It denotes the value of that specific attribute you choose in the XPath.
Types of Selenium XPath
There are two types of XPath that you use to perform testing. The first is Absolute XPath, and the second is Relative XPath. Let us have a brief look over them one by one.
Absolute XPath
An absolute path is defined as XPath, which is used to find the web element directly. The major drawback of Absolute XPath is that if there are any changes in the element’s path, the XPath will fail. Absolute XPath always starts with a single forward slash “/.” Forward slash indicates that you can select the element from the root node.
The syntax of absolute XPath is as follows:
Absolute XPath:/html/body/div[1]/div/div[2]/header/div/div[2]/a/img
Relative XPath
A relative path is defined as that XPath that starts in the middle of the HTML DOM structure. In this type of path, the structure starts with a double forward slash “//.” The forward slash in the XPath shows that you can find the element anywhere on the webpage. Using the relative XPath, you can easily write from the middle of the HTML document and do not need to write a complex XPath.
The syntax of relative XPath is as follows:
Relative XPath://*[@id=”block-perfecto-main-menu”]/ul/li[6]/a
Below is an example that shows how you can use the relative XPath in Selenium using Python language:
from selenium import webdriver
# Create a new instance of the Firefox driver
driver = webdriver.Firefox()
# Navigate to a website
driver.get(“https://example.com”)
# Find an element using relative XPath
element = driver.find_element_by_xpath(“//div[@id=’myDiv’]/p[2]”)
# Perform actions on the element
element.click()
# Close the browser
driver.quit()
Advanced Techniques for XPath Testing
Now, let us dive into the various advanced techniques that the testing and QA team can use for XPath testing.
Using Contains()
Using the contain() is a very efficient technique for XPath testing. Contains a very useful XPath locator. It is widely used in XPath testing to locate elements. Sometimes, it has proven to be very helpful for test automation engineers.
Then, the attribute of a specific element is dynamic, which you need to find; you can use the contain() for the constant part of the web element. It is also used in other conditions of XPath testing. The syntax of contains() is as follows:
Syntax: //tag[contains(@attribute, ‘value‘)]
Using Starts-with()
This advanced method of XPath testing is used to check the starting text of an attribute. It becomes very handy when the present attributes change dynamically. But to save the testing in this situation, you can use this start-with for the values that are non-changing attributes. The syntax of start-with() is as follows:
Syntax: //tag[starts-with(@attribute, ‘value‘)]
Using Operator “OR”
The testing team must use two interrogations depending on the conditions in this technique. For example, let’s say A and B. It works as “Boolean Operations “and provides the results in True or False. The “or” is case-sensitive; you should not use the capital “OR.” The syntax of the OR operator for XPath testing is as follows:
Syntax: //tag[XPath Statement-1 or XPath Statement-2]
Using Ancestor XPath
Ancestor XPath is a very effective strategy for XPath testing. It is used to find the element before the ancestor statement. It sets this as a top node and then searches for the specific element. It executes in two different steps, which are as follows:
- First, the method finds the elements whose path is //section[@id=’content’]
- After that, the method starts finding all the div elements in the current node to which the above XPath belongs.
The ancestor method in XPath is specifically used when handling complex XML documents or web pages with deep nested elements. This method allows the XPath testing team to select various levels of elements such as parent, grandparent, and other elements of the current node.
The elements get selected in reverse document order, which means the closest ancestor will be selected first, and so on.
The syntax of the ancestor XPath is as follows:
//section[@id=’content’]//ancestor::div
To better understand, you can refer to the below example:
html
<html>
<body>
<form id=”loginForm”>
<div id=”credentials”>
<input id=”username” type=”text”/>
<input id=”password” type=”password”/>
</div>
<input id=”submit button” type=”submit”/>
</form>
</body>
</html>
Multiple Criteria in Filters
Using multiple filters in your XPath testing is another useful strategy that must be followed. This is used to make the testing efficient as well as productive. It helps you to get a refined output. Below is a sample example for better understanding:
$.Sample_object.Sample_array_element[?(@.pricing.freeTrial==’Yes’ && @.features.indexOf(‘Parallel Testing’) >= 0)]
Union
As we know, the union is generally used to combine two or more distinct data results. In XPath testing, it is also used the same way. It allows you to select multiple elements or ranges in one go. It can be used by a union operator ([, ]). Using union is considered a good strategy in XPath testing. Below is an example that shows how to use Union in XPath testing:
$.Sample_object.Sample_array_element[0, -1].name
Using Chained Declaration
The chained declaration is another advanced technique that can be used to chain multiple relative XPath declarations. You need to use a double forward slash “//” to do this. It will help you to find the location of the desired element. The syntax of the chained method for XPath testing is as follows:
Example: //div//span[text()=’Sample Text’]
Following XPath
This method in XPath testing is used to search and locate the element after the provided parent node. This method locates the element before the statement and then sets this to the top node. After that, the method finds all the elements after that specific node. Given below is an example to understand better the method working:
1- First, it finds this XPath with class attribute: //div[@class=’fusion-sliding-bar-wrapper’]
2- After that, the method starts to find all the selection elements after that node.
The syntax of the Following XPath is as follows:
//div[@class=’fusion-sliding-bar-wrapper’]//following::section
Preceding XPath:
In this method of XPath testing, you select all the nodes that come before the current node. However, this method selects elements that exclude ancestors and attributes. Given below is the syntax of this method:
//div[@id=’wrapper’]/div[@class=’fusion-sliding-bar-wrapper’]//preceding::li
To fully leverage the capabilities of an XPath tester, consider using a cloud-based platform like LambdaTest. This platform supports XPath testing and includes a JSON tester for API testing. LambdaTest is an AI-powered test execution platform enabling you to perform manual and automated tests at scale across over 3000 browsers, real devices, and OS combinations.
Conclusion
The XPath Expression Tester allows developers to test and evaluate XPath, the query language for selecting text, nodes, and attributes in XML documents. The syntax of the XPath tester is “XPath = //tagname[@Attribute=’Value’].”
There are two types of XPath: Absolute XPath and Relative XPath. The various XPath testing methods are Using Contains(), Using Starts-with(), using the OR operator, etc.
