Scribd Logo
Upload

Welcome to Scribd!

  • Basic XPath Theory

    Uploaded by

    Praveen Kumar S
    148 views5 pages
    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.

    Original Description:

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Report this Document
    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.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOCX, PDF, TXT or read online from Scribd
    Flag for inappropriate content
    Download as docx, pdf, or txt
    148 views5 pages

    Basic XPath Theory

    Uploaded by

    Praveen Kumar S
    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.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOCX, PDF, TXT or read online from Scribd
    Flag for inappropriate content
    Download as docx, pdf, or txt
    of 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