Scribd
Upload
184 views

Basic XPath Theory

This document provides an overview of basic XPath theory and expressions for selecting nodes from an XML document, such as an HTML document loaded in a browser. It describes different node types like element, attribute, and document nodes. It covers XPath selections using paths starting from the root or anywhere in the document. Predicates are described for making selections more specific by index, attribute, function, or comparison. Boolean operators, wildcards, and functions like contains() and starts-with() are also summarized. Guidelines for optimizing XPath selectors to be shortest and least brittle are presented. Finally, Selenium's usage of XPath locators to identify elements is explained.

Uploaded by

Praveen Kumar S
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
184 views

Basic XPath Theory

This document provides an overview of basic XPath theory and expressions for selecting nodes from an XML document, such as an HTML document loaded in a browser. It describes different node types like element, attribute, and document nodes. It covers XPath selections using paths starting from the root or anywhere in the document. Predicates are described for making selections more specific by index, attribute, function, or comparison. Boolean operators, wildcards, and functions like contains() and starts-with() are also summarized. Guidelines for optimizing XPath selectors to be shortest and least brittle are presented. Finally, Selenium's usage of XPath locators to identify elements is explained.

Uploaded by

Praveen Kumar S
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Basic XPath Theory

This chapter will provide you with a basic understanding of XPath. Just enough to cover the basic requirements for writing Selenium tests. XPath is the XML Path Language. Since all HTML, once loaded into a browser, becomes well structured and can be viewed as an XML tree, we can use XPath to traverse it. XPath is a full programming language so you can perform calculations (e.g. last()-1), and use boolean operations ( e.g. or, and). NOTE: To help follow this section you might want to visit the web page: http://compendiumdev.co.uk/selenium/basic web page.html With the page loaded, use the Firebug plugin FireFinder to try out the XPath statements listed. Ill include the listing of the XHTML for the basic web page.html here so you can follow along:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html> <head> <title>Basic Web Page Title</title> </head> <body> <p id="para1" class="main">A paragraph of text</p> <p id="para2" class="sub">Another paragraph of text</p> </body> </html>

15.1 XPath Expressions


XPath expressions select nodes or node-sets from an XML document. e.g. The XPath expression //p would select the following node-set from the example in the Basic HTML Theory section: 161 Figure 15.1: FireFinder matching p tag

15.2 Node Types


XPath has different types of nodes. In the example XHTML these are: Document node (the root of the XML tree): <html> Element node e.g.: <head><title>Basic Web Page Title</title></head> <title>Basic Web Page Title</title> <p id="para1">A paragraph of text</p> Attribute node e.g. id="para1"

15.3 Selections
15.3.1 Start from root
Start selection from the document node with /, this allows you to create absolute path expressions e.g. /html/body/p Matches all the paragraph element nodes.
assertEquals(2,selenium.getXpathCount("/html/body/p"));

15.3.2 Start from Anywhere


Start selection matching anywhere in the document with //, this allows you to create

relative path expressions. e.g. //p Matches all paragraph element nodes.
assertEquals(2,selenium.getXpathCount("//p"));

15.3.3 By Element Attributes


Select attribute elements with @ followed by an attribute name. e.g. //@id Would select all the attribute nodes.
assertEquals(2,selenium.getXpathCount("//@id"));

15.4 Predicates
Predicates help make selections more specific and are surrounded by square brackets.

15.4.1 Predicates can be indexes


//p[2] Matches the second p element node in the node-set
assertEquals("Another paragraph of text",selenium.getText("//p[2]"));

//p[1] Matches the first p element node.


assertEquals("A paragraph of text",selenium.getText("//p[1]"));

15.4.2 Predicates can be attribute selections


//p[@id=para1] Matches the p element node where the value of the attribute id is para1
assertEquals("A paragraph of text", selenium.getText("//p[@id=para1]"));

//p[@class=main] Matches the p element node where the value of the attribute class is main.
assertEquals("A paragraph of text", selenium.getText("//p[@class=main]"));

15.4.3 Predicates can be XPath functions


//p[last()] Select the last paragraph.
assertEquals("Another paragraph of text",selenium.getText("//p[last()]"));

15.4.4 Predicates can be comparative statements


//p[position()>1] This returns all but the first p element.
assertEquals("Another paragraph of text", selenium.getText("//p[position()>1]")); assertEquals("A paragraph of text", selenium.getText("//p[position()>0]"));

15.5 Combining Match Queries


You can combine several selections by using e.g. //p | //head Match any paragraph element node and also get the head element node.
assertEquals(3,selenium.getXpathCount("//p | //head"));

15.6 Wild Card Matches


You can also use wild cards:

15.6.1 node()
node() matches

any type of node (document, element, attribute) e.g //node()[@id=para1] This matches any node with an id of para1.
assertEquals(1,selenium.getXpathCount("//node()[@id=para1]")); //node() matches //body/node() matches

all the nodes (try it, you may not get the results you expect). all the nodes in the body (again, try it to see if you get the value

you expect).

15.6.2 *
Match anything depending on its position with * e.g. @* Matches any attribute. //p[@*=para1] Would match the first paragraph
assertEquals(1,selenium.getXpathCount("//p[@*=para1]")); * can

match nodes e.g. //*[@*] Matches anything with any attribute


assertEquals(2,selenium.getXpathCount("//*[@*]"));

//*[@id] Matches anything with an id attribute.


assertEquals(2,selenium.getXpathCount("//*[@id]")); /html/*

Matches all children of the document node.


assertEquals(2,selenium.getXpathCount("/html/*"));

15.7 Boolean Operators


You can setup matches with multiple conditions.

15.7.1 and
//p[starts-with(@id,para) and contains(.,Another)] Find all paragraphs where the id starts with para and the text contains Another i.e. the second paragraph.
assertEquals("Another paragraph of text", selenium.getText( "//p[starts-with(@id,para) and contains(.,Another)]"));

15.7.2 or
//*[@id=para1 or @id=para2] Find any node where the id is para1 or the id is para2 i.e. our two paragraphs.
assertEquals(2, selenium.getXpathCount("//*[@id=para1 or @id=para2]"));

15.8 XPath Functions


Since XPath is actually a programming language it has built in functions which we can use in our XPath statements. Some common XPath functions are listed below

15.8.1 contains()
contains() allows

you to match the value of attributes and elements based on text anywhere in the comparison item e.g. //p[contains(.,text)] Match any paragraph with text in the main paragraph e.g. Both our paragraphs
assertEquals(2, selenium.getXpathCount("//p[contains(.,text)]")); //p[contains(.,Another)]

Match any paragraph with Another in the paragraph text, in our example this would match the second paragraph.
assertEquals("Another paragraph of text", selenium.getText("//p[contains(.,Another)]"));

//p[contains(@id,1)] This would match any paragraph where the id had 1 in it, in our example this is the first paragraph
assertEquals("A paragraph of text", selenium.getText("//p[contains(@id,1)]"));

15.8.2 starts-with()
starts-with() allows

you to match the value of attributes and elements based on text at the start of the comparison item e.g. //*[starts-with(.,Basic)] Would match any node where the contents of that node start with Basic, in our example this would match the title.
assertEquals("Basic Web Page Title", selenium.getText("//*[starts-with(.,Basic)]")); //*[starts-with(@id,p)]

This would match any node where the id name started with p, in our example this would match the paragraphs.
assertEquals("Basic Web Page Title", selenium.getText("//*[starts-with(.,Basic)]"));

15.8.3 Many More


There are many XPath functions available to you, I have just picked a few of the most common ones that I use. I recommend that you visit some of the web sites below to learn more about XPath functions, and experiment with them. Recommended web sites for function references: http://unow.be/rc/w3xpath1 http://unow.be/rc/msxpathref2 http://unow.be/rc/pitstop13

15.9 XPath optimisation


For our testing we typically want to get the shortest and least brittle XPath statement to identify elements on a page. Some XPath optimisation strategies that I have used are: use the id, use a combination of attributes to make the XPath more specific, start at the first unique element We have to make a trade off between handling change and false positives. So we want the XPath to return the correct item, but dont want the test to break when simple changes are made to the application under test.

15.9.1 Use the ID


If the element has a known id then use that e.g. //*[@id=p2] Or you probably want to be even more specific and state the type e.g. //p[@id=p2]
1http://www.w3schools.com/XPath/xpath

functions.asp

2http://msdn.microsoft.com/en-us/library/ms256115.aspx 3http://www.xmlpitstop.com/ListTutorials/DispContentType/XPath/PageNumber/1.aspx

15.9.2 Use the attributes


If it doesnt have an id, but you can identify it with a combination of attributes then do that. Our example XHTML doesnt have enough nodes to make this clear, but we did this with our initial Search Engine testing. e.g. //input[@name=q and @title=Search]

15.9.3 Start at the first unique element


If there is really nothing to distinguish the element then look up the Ancestor chain and find the first unique element. e.g. //form/table[1]/tbody/tr[1]/td[2]/input[2] This approach starts to introduce the chance of false positives since a new input might be added before the one we want, and the test would start using that instead.

15.10 Selenium XPath Usage


Selenium uses XPath in locators to identify elements e.g.
selenium.isElementPresent("xpath=//p[@id=p1]")

Because only XPath locators start with // it is possible to write XPath locators without adding xpath= on the front. e.g.
selenium.isElementPresent("//p[@id=p1]") The specific XPath command getXpathCount expects

an XPath statement as its argument so you should not use xpath= in front of the XPath locator. Possibly a good reason for not using xpath= in any of your locators, but each of us has personal coding styles so you get to make a choice as to which you prefer. e.g.
selenium.getXpathCount("//p"); //return a count of the p elements

You can combine the XPath statement in the getAttribute statement to get specific attributes from elements e.g.
assertEquals("p2", selenium.getAttribute("xpath=//p[2]@id")); assertEquals("p2",selenium.getAttribute("//p[2]@id"));

The @id (or more specifically @<attribute-name>) means that the statement is not valid XPath but Selenium parses the locator and knows to split off the @id on the end before using it.

You might also like