One crucial aspect of Locators in Selenium Java on webpages accurately. In this article, we will explore various techniques for element location using Selenium Java, enabling you to enhance your web automation capabilities. Selenium, a popular open-source web automation tool, empowers developers and testers to automate web applications effectively.

Understanding Locators in Selenium Java

Traditional Locators 

Element locators are essential components in Selenium Java, allowing the identification and interaction with specific elements on a webpage. Selenium provides several strategies to locate elements, including:

• By ID: Using the unique ID attribute of an element.
• By Name: Locating elements by their name attribute.
• By Class Name: Targeting elements by their CSS class name.
• By Tag Name: Identifying elements based on HTML tags.
• By Link Text: Locating elements with anchor tags and link text.
• By Partial Link Text: Identifying elements by partial link text matching.
• By XPath: Utilizing XPath expressions to locate elements.
• By CSS Selector: Using CSS selectors to target elements.

Relative Locators

Relative Locators are introduced in Selenium 4. Previously these locators were called friendly locators. These are used to locate the neighboring elements.

• Above: Locating an element above the located element.
• Below: Locating an element below the located element.
• Left of: Locating an element Left of the located element.
• Right of: Locating an element Right of the located element.
• Near: Locating an element near the located element.
• Chaining relative locators: If required, you can also combine locators using chaining. In certain situations, an element can be accurately identified by its position relative to other elements, such as being above/below one element and right/left of another.

Locating Elements with Traditional Locators 

Let’s dive deeper into some of the most commonly used techniques for element location in Selenium Java.

By ID

To locate an element by ID, use the findElement() method and provide the ID value as an argument. For example:

WebDriver driver = new ChromeDriver();
driver.findElement(By.id("test-id"));

By Name

To locate elements by their CSS class name, use the findElement() method with the By.name() locator. For example:

WebDriver driver = new ChromeDriver();
driver.findElement(By.name("test-name"));

By Class Name

To locate elements by their CSS class name, use the findElement() method with the By.className() locator. For example:

WebDriver driver = new ChromeDriver();
driver.findElement(By.className("test-class-name"));

By Tag Name

To locate elements by their CSS class name, use the findElement() method with the By.tagName() locator. For example:

WebDriver driver = new ChromeDriver();
driver.findElement(By.tagName("test-tag-name"));

By Link Text

To locate elements by their CSS class name, use the findElement() method with the By.linkText() locator. For example:

WebDriver driver = new ChromeDriver();
driver.findElement(By.linkText("test link text"));

By Partial Link Text

To locate elements by their CSS class name, use the findElement() method with the By.partialLinkText() locator. For example:

WebDriver driver = new ChromeDriver();
driver.findElement(By.partialLinkText("test partial link text"));

By XPath

XPath provides a powerful way to locate elements based on their structure and hierarchy in the HTML DOM. Use the findElement() method with the By.xpath() locator. For example:

WebElement element = driver.findElement(By.xpath("//input[@name='username']"));

By CSS Selector

CSS selectors offer another efficient method for locating elements. Use the findElement() method with the By.cssSelector() locator. For example:

WebElement element = driver.findElement(By.cssSelector("input[name='password']"));

Locating Elements with Relative Locators

Above 

In case the element cannot be readily recognized, for any given reason, we can identify the element by leveraging the fact that it is an “button” element positioned “above” the element having id “test-id”.

By loc = RelativeLocator.with(By.tagName("button")).above(By.id("test-id"));

Below

In case the element cannot be readily recognized, for any given reason, we can identify the element by leveraging the fact that it is an “button” element positioned “below” the element having id “test-id”.

By loc = RelativeLocator.with(By.tagName("button")).above(By.id("test-id"));

Left of 

In case the element cannot be readily recognized, for any given reason, we can identify the element by leveraging the fact that it is an “button” element positioned “left of” the element having id “test-id”.

By loc = RelativeLocator.with(By.tagName("button")).toLeftOf(By.id("test-id"));

Right of 

In case the element cannot be readily recognized, for any given reason, we can identify the element by leveraging the fact that it is an “button” element positioned “right of” the element having id “test-id”.

By loc = RelativeLocator.with(By.tagName("button")).toRightOf(By.id("test-id"));

Near 

In situations where the relative positioning is not clear or varies depending on the window size, the “near” method can be employed to identify an element that is within a maximum distance of 50px from the given locator. This approach is particularly useful when dealing with a form element that lacks a readily constructible locator, but its associated input label element can be used instead.

By loc = RelativeLocator.with(By.tagName("button")).near(By.id("test-id"));

Chaining relative locators 

If necessary, locators can also be chained together. In certain cases, an element can be best identified by its relative position both above/below one element and to the right/left of another element. By combining multiple locators, we can effectively pinpoint the desired element based on its specific placement in relation to other elements.

By loc = RelativeLocator.with(By.tagName("button")).below(By.id("test-id1")).toRightOf(By.id("test-id2"));

Advanced Techniques

Selenium Java provides advanced techniques for locating elements efficiently.

Explicit Waits

Explicit waits ensure that Selenium waits for a specific condition to be satisfied before locating an element. Use the WebDriverWait class in combination with an expected condition. For example:

WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("elementId")));

Using Dynamic Locators in Selenium Java

In certain scenarios where elements have dynamic attributes or values, it is possible to use dynamic Locators in Selenium Java. Regular expressions or substring matching can be used within Locators in Selenium Java to handle such dynamic elements.

Best Practices for Locators in Selenium Java

To ensure robust and maintainable test automation scripts, follow these best practices:

• Use unique and stable Locators in Selenium Java to avoid false positives and minimize test script maintenance.
• Prefer CSS selectors and XPath expressions when locating elements.
• Leverage the WebDriverWait class and expected conditions for explicit waits.
• Modularize your code to promote reusability and improve maintainability.

Conclusion

Effectively locating elements in Selenium Java is crucial for successful web automation. By understanding the various techniques available and following best practices, you can streamline your testing processes and build reliable and efficient automation scripts.

Note: Remember to regularly refer to the official Selenium documentation for any updates or changes in the APIs and best practices.

FAQ