Finding items on a webpage can be difficult due to the complexity of web elements. On the other hand, web elements are essential in the development and testing of any software.
To make things easier for testers, this post will explain Selenium findElement and findElements with the help of an example.
Selenium findElement: An Overview
To interact with a web page, the driver must first find a web element and initiate a JavaScript event, such as clicking, entering, selecting, or typing in the field value. The discovery of relevant web elements on the web page is usually the first step in the automated UI testing of any web program. Typically, frameworks such as Selenium WebDriver are used to automate testing.
Selenium specifies two ways of identifying web elements:
- The findElement command can be used to locate an element on a page.
- findElements is a command that searches a page for a list of web elements.
Let’s take a closer look at how to find products on the site utilizing various locators. There are several locators to pick from in Selenium. Any web page can have textboxes, checkboxes, radio buttons, dropdowns, and other elements.
These elements must first be identified or located before performing any operation (action), such as writing in a text box, selecting a checkbox, or selecting an option from a dropdown menu. To assist in identifying these items, Selenium provides eight Identifiers or locators.
It’s vital to distinguish between different site elements. You might examine how to determine the uniqueness of these elements using these IDs or locators in the next section.
How to Use Selenium findElement?
Several methods for locating components on a page, and some are superior to others. There are eight main sorts of locators or identifiers available in Selenium.
Let’s look at each identifier in more detail. First, go over the Firebug and Firepath Tutorial. To locate web components, use the Firebug Firefox add-on, and to build XPath, use the Firepath add-on. Firebug and Firepath are not required; all browsers include a built-in developer console that you may by pressing F12 on the keyboard (Function key).
Note that you can utilize web elements found in one browser without modification in other browsers.
By Using Id
It is a property of a web element that allows it to be uniquely identified on a page. As a result, it has become the most often used locator. Ids are also the quickest and most dependable identifiers compared to other identifiers.
Selenium WebDriver’s findElement() method creates a unique Web Element depending on the locator (criteria) provided as an Argument.
BY is a class that defines methods for all locators to locate items, such as By.Id() for finding elements using the Id property, By.xpath() for finding elements using xpath, etc.
findElements() is similar to findElement() in that it produces a list of WebElements found on a page based on the criteria sent in as an argument. In upcoming classes, we’ll go deeper into findElements.
By Using Name
The Name property is the second most popular technique for locating components after IDs. Make sure the name isn’t always unique, though. Selenium will always act on the first matched element if there are numerous names. This is true for all locators. The name attribute is an HTML code attribute, just like the Id attribute.
Using Class Name
The classname locator uses a name class attribute. It’s similar to Id and Name, except that multiple things may share the same Class Name. It can be utilized if the class attribute in the developer console or Firebug returns only one matching element.
Another thing to keep in mind is that HTML code with several classes assigned to it should be treated as such (multiple classes have white spaces in the value.)
By Using Tag Name
Finding an element by tag name isn’t as prevalent as it used to be because dynamic pages now have multiple things with the same tag. The tag name locator is employed when “finding all links on a page” or “searching for all checkboxes in a frame or a page,” the tag name locator is employed.
Using Link Text
On an HTML page, the anchor tag (“a”) denotes links. Every website link has a “href” element that gives the navigation page’s address. Link text is the text that appears next to each link. A link on a page can be identified using two Locators (linktext and partial link text).
Using Partial Link Text
Link Text and partial link text are both used to identify links. Unlike Link Text, which exactly matches the link text, Partial Link Text only matches the link text in part. It’s conceivable to consider it a containment strategy.
Consider the following texts: “SIGN-ON” and “SINGLE SIGN-ON.” In this case, using “SIGN” or “ON” as partial link text could result in many matched items on the web page. As a result, selecting only a portion of a text should be done with prudence.
Another useful application of Partial Link Text is when we want to find all the links on a page that contain the same word (like add word is common to add customer and add account).
Using Xpath
Xpath is the most important identifier in the list. All of the pieces can be identified using xpath. Xpath is a path established using HTML tags (or XML tags) and their attributes to travel to a node on an HTML page.
There are two varieties of Xpath:
- Xpath is a path that connects two points (absolute)
- relative to Xpath
At the top of the page, the absolute xpath begins. HTML is the first tag, just like in an HTML page.
Using CSS Selector
CSS selector is a class that allows you to identify web components based on their CSS
properties. Cascading Style Sheets (CSS) is a language for specifying how an HTML page should appear. It describes the look and feel of the page. CSS selectors are faster than any other approach for identifying a WebElement.
Using a Cloud Testing Tool
Cloud testing tools like LambdaTest provides testers the facility to find web elements they are unable to find on the screen. LambdaTest’s cloud Selenium Grid allows testers to perform live testing of websites and web applications on an online device farm of 3000+ browsers and OS combinations.
Identifying Elements Through Strategies
There are two types of Selenium implementations, both of which are used to identify elements.
The test cases define the locators since they contain direct selenium calls.
The locators are declared at runtime in test cases that use reusable routines.
In the first scenario, we have a great deal of control over where the elements are placed. It also implies:
- Because tests are so firmly bound to Selenium as a tool, switching technologies in the future will be much more difficult.
- When the user interface undergoes considerable changes, it is possible that updating the test scripts will take a lot more time.
- In the second situation, smart expression generation logic is required to select the appropriate location depending on factors such as parameters supplied to the function or page inspection.
- In the second scenario, clever expression generating logic is necessary to choose the proper position based on function parameters or page inspection information.
It also implies:
- There’s less duplication because we’re reusing functions, which equals fewer maintenance expenses.
- There is a need for a more scalable test architecture.
- The execution time is longer.
- More xpaths or CSS should be utilized as locators.
Concluding Thoughts
One of the two techniques should be used depending on the size of the application under test and how often and how much regression areas alter in the product. Try the first implementation method if it’s a small application or the regression areas don’t change greatly. However, in the world of web application automation, such instances are uncommon.
Add Comment