Selenium web driver uses 8 locators to find the elements on web page. The following are the list of object identifier or locators supported by selenium.
We have prioritized the list of locators to be used when scripting.
1. id
2. Name
3. Linktext
4. Partial Linktext
5. Tag Name
6. class name
7. Css
8. xpath
Locating an Element By ID:
The most efficient way and preferred way to locate an element on a web page is By ID. ID will be the unique on web page which can be easily identified.
IDs are the safest and fastest locator option and should always be the first choice even when there are multiple choices, It is like an Employee Number or Account which will be unique.
Example 1:
<div id="abcid">.....</div>
Example 2:
<input id="email" class="required" type="text"/>
We can write the scripts as
WebElement Ele = driver.findElement(By.id("abcid"));
Unfortunately there are many cases where an element does not have a unique id (or the ids are dynamically generated and unpredictable like GWT). In these cases we need to choose an alternative locator strategy, however if possible we should ask development team of the web application to add few ids to a page specifically for (any) automation testing.
Locating an Element By Name:
When there is no Id to use, the next worth seeing if the desired element has a name attribute. But make sure there the name cannot be unique all the times. If there are multiple names, Selenium will always perform action on the first matching element
Example:
<input name="register" class="required" type="text"/>
WebElement register= driver.findElement(By.name("register"));
Locating an Element By LinkText:
Finding an element with link text is very simple. But make sure, there is only one unique link on the web page. If there are multiple links with the same link text (such as repeated header and footer menu links), in such cases Selenium will perform action on the first matching element with link.
Example:
<a href="seleniumhq.org">Downloads</a>
WebElement download = driver.findElement(By.linkText("Downloads"));
Locating an Element By Partial LinkText:
In the same way as LinkText, PartialLinkText also works in the same pattern.
User can provide partial link text to locate the element.
Example:
<a href="seleniumhq.org">Download selenium server</a>
WebElement download = driver.findElement(By.PartialLinkText("Download"));
Locating an Element By TagName:
TagName can be used with Group elements like , Select and check-boxes / dropdowns.
below is the example code:
Select select = new Select(driver.findElement(By.tagName("value of Tag")));
select.selectByVisibleText("November");
or
select.selectByValue("11");
Locating an Element By Class Name:
There may be multiple elements with the same name, if we just use findElementByClassName,m make sure it is only one. If not the you need to extend using the classname and its sub elements.
Example:
WebElement classtest =driver.findElement(By.className(“value of name”));
CSS Selector:
CSS mainly used to provide style rules for the web pageIs and we can use for identifying one or more elements in the web page using css.
If you start using css selectors to identify elements, you will love the speed when compared with XPath.
We can you use css which can also run with the same speed in IE browser. CSS selector is always the best possible way to locate complex elements in the page.
Example:
WebElement Checkments = driver.findElements(By.cssSelector("input[id="value of id"']"));
XPath Selector:
XPath is designed to allow the navigation of XML documents, with the purpose of selecting individual elements, attributes, or some other part of an XML document for specific processing
There are two types of xpath
1. Native Xpath, it is like directing the xpath to go in direct way. like
Example:
html/head/body/table/tr/td
Here the advantage of specifying native path is, finding an element is very easy as we are mantion the direct path. But if there is any change in the path (if some thing has been added/removed) then that xpath will break.
2. Relative Xpath.
In relative xpath we will provide the relative path, it is like we will tell the xpath to find an element by telling the path in between.
Advantage here is, if at all there is any change in the html that works fine, until unless that particular path has changed. Finding address will be quite difficult as it need to check each and every node to find that path.
Example:
//table/tr/td
We will take and sample XML document and we will explain different methods available to locate an element using Xpath
If a simple XPath is not able to find a complicated web element for our test script, we need to use the functions from XPath 1.0 library. With the combination of these functions, we can create more specific XPath. Let's discuss a 3 such functions –
- text():It take complete String with space Ex. //*['text()="abc "']
- Normalize-space(): It remove before and after string space not between but not work with part of string.
- Contains():It can used remove space and take part of string Ex. //*[contains(.,"hello")]
- Sibling: Used in case of dynamic Xpath . Ex. //div/tr[contains(,"hello")]/following-sibling::span //*[contains(text(),"hello")]/preceding-sibling::span
- Ancestor
