Forem: Riadayal

Automation Testing Tutorial: A Starter’s Guide With Example

Riadayal — Wed, 20 Apr 2022 07:29:38 +0000

Software testing is an integral part of any IT project. Testing the software more and more will ensure a better quality of your software. Now, how do you achieve it? Either you go with Manual Testing or Automation Testing.

Now sticking to manual testing can land you in trouble sometimes, as achieving Continuous Testing through manual testers can be really exhaustive. Moreover, manual testing is prone to human errors, is time-consuming, expensive, and can hit customer experience greatly.

Businesses are constantly pressured to improve, adapt, and become competitive. Keeping up with all the changes in the technology industry is an enormous challenge, and organizations, therefore, need to automate repetitive testing processes to ensure that software performs according to expectations and provides value in no time. This can happen by adopting agile methodologies to achieve shorter development cycles and accelerated Time to Market (TTM).

Having said that, in my opinion, manual testing still plays an imperative and indispensable role in the software development life cycle, though it has to be coupled with a formidable automation testing strategy.

In this automation testing tutorial, we will cover all about automation testing, the need for automation testing, and its different approaches.

Let’s get started!

Note: Split Your String — A free web based utility that instantly splits text into multiple pieces. This online tool can be used to split long web addresses, texts, word, and much more. Select a delimiter and start splitting right away!

What is Automation Testing?

Automation testing is the process of carrying out the test activities using the assistance of tools, scripts, and software by repeating pre-defined actions.

In simple terms, you can understand automation testing as a type of testing that focuses on replacing repetitive, error-prone, and time-consuming manual tasks or activities with automated scripts in order to enhance the performance of the software and efficiency.

Testing is a very crucial activity in any Software Development Lifecycle. In order to ensure a better quality of your software, you need to ensure better testing of it. Automation testing gives testers the time to focus on other quality activities like performing exploratory tests, analyzing test results, etc., by taking over the repetitive and mundane tasks like Regression tests. As a result, automation testing enables you to achieve better test coverage in a shorter period of time.

Difference between Manual and Automation Testing

Let’s see the major differences between Manual and Automation Testing:

FEATURES	MANUAL TESTING	AUTOMATION TESTING
Test Execution	Done manually by the team members	Done using automation tools and scripts
Test Efficiency	Time-consuming and less efficient	Saves time and is more efficient
Test Accuracy & Reliability	Low, as manual tests are prone to human errors	High, as no scope of human errors
Infrastructure Cost	Low, Return of Investment is low	Low (for the cloud-based test), Return Of Investment is high
Usage	Suitable for Exploratory, Ad Hoc, and Usability Testing	Suitable for Regression, Load, and Performance Testing
Coverage	Difficult to ensure greater test coverage	Easier to achieve greater test coverage

The above differences clearly indicate the effectiveness of automation testing. However, with manual testing, you benefit from human expertise and knowledge, which an automation testing tool can never provide a match for.

Hence, an ideal approach would always be to keep a combination of Manual + Automation activities for your testing cycle.

Why Automation Testing?

Now that you have seen some of the major benefits of automation testing, let’s understand the need for automation testing through a practical use case.

You get a new feature to test in your software. You started your test plan, and there are some 50 test cases that you identified.

You started the tests and reported some 10 bugs in the first sprint. Those bugs keep getting fixed over sprints, and you have to test the updated version of the software with each build. Now, how do you ensure that the fix for one bug doesn’t affect the older working areas?

To ensure that, you need to test the complete software or perform regression testing after each bug fix. When the number of bugs in software increases or the number of features to test increases, manual testing may turn cumbersome. This is where automation testing comes in.

In such cases, you can simply automate the areas you have already tested and covered. Now, every time a new build or bug fix comes in, you can run the entire suite and easily ensure the health of your software.

Hence, with lesser time, you can achieve better coverage and quality of your software. An effective test automation strategy plays an important role in ensuring a bug-free application.

Automation testing life cycle mentioned above is a group of well-defined phases that result in an efficiently working test automation framework used to develop and maintain the software.

Which Test Cases To Automate?

Automation Testing has a lot of benefits and is well suitable for areas that require testing over and over again, but can we achieve 100% test automation?

Well, it’s difficult to achieve 100% test automation, and hence, it’s very important to determine which test case can be automated.

Let’s look at the areas where you can apply Automation Testing

Repetitive (Regression) Tests

These are the prime candidates for automation tests, as their numbers keep on increasing with the addition of new functionalities. As a result, they become difficult to maintain, and running them manually over and over again becomes a mundane task.

Complex Tests

Complex tests are best to automate. For example, consider the areas which require large calculations; they are always prone to human errors. Hence, automating them would always ensure the correct result of your software.

Smoke Tests

The smoke tests which probably need to be carried out in different environments like Dev Env, QA Env, and Production Envs are also good candidates for automation testing. It would save a lot of time by running these tests through automation every time a new environment comes in. This way, you can also cover tests over different browsers or OS flavors in less time.

Data-Driven Tests

These are the tests that require repeated testing with different data sets, and hence, automation testing can prove to be a boon in such cases.

Performance Tests

Automation testing will help you test the software performance and load under different conditions easily and in much lesser time as compared to the manual approach.

How do you perform Automation Testing?

The below-mentioned steps are followed in the automation testing process:

Test Tool Selection
Define Scope Of Automation
Planning, Design & Development
Test Execution
Maintenance

Test Tool Selection

Before starting with any test automation, you need to decide which kind of tests you need to automate. Once you have the test definition ready, you need to select the correct set of tools that can help you in performing those tests. There are several testing tools available. The industry-standard tools for automated testing are based on code and code-based test scripts.

The most popular code-based web automation framework for automation testing is Selenium WebDriver, which allows you to test web applications using different browsers (Chrome, Firefox, Internet Explorer, etc.). It also supports many languages such as Java, Python, C#, etc. However, choosing the correct one is a very crucial step in an automation process.

Consider the below pointers when selecting an automation tool:

How easy is it to develop and maintain scripts using the test tool?
How many different platforms does the tool support? For e.g., Web, Mobile, Desktops, etc.
How many different languages is the tool compatible with?
Does the tool support a reporting mechanism?

Define Scope Of Automation

Now that you have selected the best-suited test tool, the next step is to define the scope of your test automation. Consider the below points while defining the scope of automation:

The complexity of test cases
Technical feasibility
Common functionalities across applications
Reusability and Scalability of test cases for cross-browser testing

Planning, Design & Development

The Planning, Design & Development phase includes the below points:

Framework design & its features
Test case development
Test suite preparation, For e.g., Smoke, Sanity, Regression
Plugging framework with some CI/CD pipeline to achieve continuous testing.

Test Execution

The scripts developed during the design phase are now executed in this phase. Execution can be performed using the automation testing tool or the test management tool, which will, in turn, invoke the test automation tool. You should start the execution of your test scripts as early as possible. This is what the Shift Left Testing approach also suggests.

In contrast to traditional models like the Waterfall Model, where testing comes into the picture at the very end of the cycle, the Shift Left Testing approach suggests moving the Testing activities “Left” or rather “earlier” in the development cycle. Thus, it involves the testers much earlier in the software development life cycle. The earlier the testers are involved, the more bugs you find, and as a result, you have a better quality product.

Maintenance

In this phase of automation testing, testing is carried out in order to determine whether the newly added functionalities are working fine or not. Maintenance and up-gradation of test suites are carried out in order to improve the effectiveness of automation scripts with each successive release cycle.

Many firms even use this phase for Shift-Right Testing. Shift-Right testing, or rather Testing In Production, happens after the software is deployed in production environments. This is mainly done in order to ensure the correct performance, stability, and usability of the application in the production environment.

Note: Online Sort List — This tool changes the order of all your list items so that they are sorted alphabetically, or numerically. Try sorting your list online now.

Different Approaches to Automation Testing

There are three main approaches that you can consider while performing automation testing.

Code-Driven Testing
Graphical User Interface Testing
Framework Approach

Code-Driven Testing

This testing approach is a popular method in agile software development. Here, the focus is mainly on test case execution to determine if different sections of code are performing as per expectations or not.

The idea behind code-driven testing is to use a programming language to write the unit test instead of using an external tool that provides a testing framework. The advantages are that you have full power at your disposal to create whatever tests you want, and you don’t have to deal with an external tool. The disadvantage is that it is harder to set up and run tests, so it can be more difficult to get people to do it regularly.

Graphical User Interface Testing

With the increasing complexity of software and its graphical interfaces, the need for formal GUI testing has increased dramatically. The testing process can be categorized into two main types: unit testing and functional testing.

Unit testing, which is most often driven by developers, involves a detailed analysis of each component of the application to ensure that it is operating correctly in isolation. Functional testing, on the other hand, determines whether or not all components of the application can be used as expected by the end user. This phase of GUI testing is usually performed by quality assurance analysts who are more familiar with how users interact with the application.

Test Automation Framework

A framework is a set of guidelines that help in maintaining test consistency and test structure. It also helps in achieving the maintainability, scalability, and reusability of the code across test cases.

There are four major kinds of frameworks used in automation testing:

1- Data-Driven Framework — These frameworks are focused on separating the logic of test cases and the test data separately. Here the data is treated as an input to the test script logic. Each data set can be treated as a separate test case.

A data-driven framework is a test automation framework that stores keywords and locators of elements into an external file, such as an XML file. This makes it easier for testers to build test cases because it does not require the use of object repositories.

Data-driven frameworks are often used with keyword-driven frameworks. Keywords are stored in a data file and then placed into a function library. The keywords may be written manually or generated via recording. Tests are created in the data file, which can be edited by testers without programming knowledge. The test data for each keyword is stored in the same row as the keyword, making it easy to change.

2- Keyword-Driven Framework — A keyword-driven framework is essentially a data-driven framework that is limited to accepting inputs only from an excel data source. In this type of framework, test case logic resides in a database table and is linked to one or more related tables that contain the test data. Each logical operation of the application under test is defined as a keyword, which represents some action on the application under test. The keywords are then mapped to a subroutine, which implements the functionality of the keyword and performs the desired action on the application.

The main advantage of this type of framework is that it does not require any programming skills because all the required operations can be performed using keywords. Therefore, anyone (even nonprogrammers) can create and execute test cases using this approach. However, this framework limits itself to operations that can be performed using existing keywords; no new keywords can be created because they would require programming knowledge.

3- Modular Testing Framework — Modular Testing Framework is a way to test a piece of software in isolation. Each module is tested with the same testing framework so that testing multiple modules can be done with a single line of code.

The framework is composed of two main components: Test Cases and Test Suite. A Test Case is an object that defines a series of steps or actions to be performed. The Test Suite is simply an object that contains a collection of Test Cases.

When the Test Suite is executed, it will execute each Test Case using a Test Runner object that can perform assertions on the results produced by executing the individual Test Cases.

4- Hybrid Testing Framework — Hybrid Driven Framework is a mix of both the Data-Driven and Keyword-Driven Frameworks. In this case, both keywords, as well as the test data, are externalized.

A hybrid testing framework combines the strengths of two approaches, using features of both to achieve the best of both worlds. It can be especially good at handling complex, difficult-to-test situations, and requirements.

Popular Test Automation Frameworks

Now that we have learned the basics about test automation, let’s see some of the popular test automation frameworks which are being widely used.

Selenium — Selenium is a popular test automation framework used to validate web applications across different browsers and platforms.
Cypress testing — Cypress is a JavaScript test automation solution used for web automation. It enables teams to create web test automation scripts.
TestNG — TestNG is a powerful test automation framework for Java. It is inspired by JUnit and NUnit. It can be used to cover a wider range of test categories: unit, functional, end-to-end, integration, etc.
WebDriverIO — WebDriverIO is an open-source testing utility for nodejs. It allows you to run Selenium tests written in JS on multiple browsers and platforms.
Pytest — pytest is a testing framework based on python. It’s often considered to be the de-facto standard when it comes to writing unit tests for python code.
NUnit — The NUnit Framework is a unit testing framework for all .NET languages.
PHPUnit — PHPUnit is a programmer-oriented testing framework for PHP. It is an instance of the xUnit architecture for unit testing frameworks.
Cucumber — Cucumber is an open-source tool that supports Behavior Driven Development(BDD) frameworks. Cucumber enables you to write test cases that anyone can easily understand regardless of their technical knowledge.

These were some of the popular test automation frameworks I have come across for different languages. However, the list doesn’t end here. There are a lot of other test automation frameworks also available in the market. You can check them and select one that best suits your overall requirements.

Example of Test Automation

Let us now see a basic test automation example. In this case, we will automate a web page making use of the Selenium framework and LambdaTest.

Selenium is an open-source framework for cross-browser and cross-platform testing of web applications. It is a suite that allows automated tests of websites and web applications in different browsers on different platforms using any programming language of your choice.

Cloud testing tools like LambdaTest offer a cloud Selenium Grid that lets you run parallel tests on an online browser farm of 3000+ browsers and operating systems. All you need to do is instantiate the remote Selenium WebDriver instead of the local Selenium WebDriver.

Here’s a quick video on performing Selenium automation testing on the LambdaTest platform.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, End to End testing, CI/CD, and more.

With LambdaTest, you don’t have to worry about downloading and configuring hundreds of browsers on your machine, as they are readily available on the online Selenium Grid. Instead, all you need to do is register on LambdaTest for free, claim your 100 free automation testing minutes, and run Selenium IDE tests on cloud.

Now that we have covered the basics of cloud Selenium Grid let’s implement a sample example using LambdaTest Selenium Grid.

Problem Statement

In the below example, I am running the same test case on Chrome (latest) + Windows 10 combination.

Launch Chrome browser on Windows 10.
Open LambdaTest sign up page.
Click on the Sign In button.
Close the web browser.

Implementation

FirstTestScriptUsingSeleniumGrid.java

package LambdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class FirstTestScriptUsingSeleniumGrid {

   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeTest
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "95.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "FirstTestScript");
       capabilities.setCapability("name", "FirstTestScriptSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
   }

  @Test
   public void firstTestCase() {
       try {
           System.out.println("Logging into Lambda Test Sign Up Page");
           driver.get("https://accounts.lambdatest.com/register");
           WebElement pageHeader= driver.findElement(By.xpath("//a[text()='Sign In']"));
           pageHeader.click();
           System.out.println("Clicked on the Sign In Button.");
       } catch (Exception e) {

       }

   }

   @AfterTest
   public void closeBrowser() {
       driver.close();
       System.out.println("The driver has been closed.");

   }

}

GitHub

You will need the below pom.xml for importing the necessary dependencies.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>org.example</groupId>
   <artifactId>LambdaTest</artifactId>
   <version>1.0-SNAPSHOT</version>
   <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-api</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-remote-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-chrome-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>6.14.3</version>
       </dependency>
       <dependency>
           <groupId>io.github.bonigarcia</groupId>
           <artifactId>webdrivermanager</artifactId>
           <version>4.4.3</version>
       </dependency>
   </dependencies>

   <properties>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
   </properties>

</project>

And the below testng.xml file will be needed for running the test case.

testng.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="FirstTestScriptUsingSeleniumWebDriverSuite">

   <test name="FirstTestScriptUsingSeleniumWebDriver" >
       <classes>
           <class name="LambdaTest.FirstTestScriptUsingSeleniumGrid" >
           </class>
       </classes>
   </test>
</suite>

GitHub

Code Walkthrough

Global Variables: As tests have to be run on LambdaTest cloud Selenium Grid, we would be using the below-shown variables.

Here, you can populate the values for your corresponding username and access key, which can be collected by logging into your LambdaTest Profile Section. However, the gridURL will remain the same.

@BeforeTest(Setup Method): In Selenium, the RemoteWebDriver class implements the WebDriver interface to execute test scripts through the Selenium RemoteWebDriver server on a remote machine.

The @BeforeTest annotation in TestNG is used to execute a set of statements before running a test suite. This method can be used for initializing the resources required for your test case.

The below-imported class will help you in using the RemoteWebDriver class.

Here, I have used the LambdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc.

@ Test(firstTestCase): In the test case, I opened the LambdaTest sign up page in the Chrome browser using the driver.get() statement. The findElement method in Selenium is used for locating the SignIn WebElement.

Here, I have used XPath in Selenium for locating the ‘Sign In’ button. To investigate the XPath of any element, you can simply right-click on it and click on Inspect. You will be able to spot the locator in the Elements tab. The click method in Selenium is used for clicking on the Sign In button.

@ AfterTest: In the AfterTest method, close the browser using the driver.close() method.

Execution

You will see the below output once you run the testng.xml file.

Once the tests are completed, Log on to LambdaTest Automation Dashboard to check the status of the test execution on LambdaTest.

You can also access the report on LambdaTest Analytics Dashboard. The dashboard shows all the details and metrics related to your tests.

Test Summary gives you a high-level overview of your test performance. It shows how many of your previous tests passed and failed and how effective each team member was in running their tests. Don’t forget to check out Test Overview for interactive visualization of how your tests are performing over time.

Note: Uppercase Text — Online tool for uppercasing all text. Generate any text in uppercase.

Conclusion

In this automation testing tutorial, we got to know what is automation testing, the differences between manual and automation testing, the need for automation testing, and a few approaches to do the same. We also saw which test cases should be automated and implemented our first automation test script with Selenium.

Investment in automation testing is essential to maintain the efficiency and effectiveness of the software development process. It is important to estimate the return on investment (ROI) of automation testing, especially when the company has a tight budget and cannot afford all the requested projects.

I hope this article helps you in taking the first step towards your automation testing journey and, as a result, helps in achieving a better quality of your software.

Happy Testing 🙂

How To Use TestNG Reporter Log In Selenium

Riadayal — Tue, 19 Apr 2022 07:10:45 +0000

TestNG is an open-source test automation framework, where ‘NG’ stands for Next Generation. TestNG has given testers the ability to group or prioritize the test cases, generate HTML reports, log messages, run tests in parallel, and much more. These diverse sets of features are a huge boon when it comes to Selenium automation testing.

In our previous blogs of this Selenium TestNG tutorial series, we have learned to use the TestNG results plugin, generate the TestNG reports in Jenkins, install the TestNG reports plugin in Jenkins, and more. But why do we need reporting structure in the first place?

Reports can be insightful as they give us all the accessible information in one place, and with automated report generation structures, they even improve the efficiency and overall analysis. However, sometimes TestNG reports might not convey to us the exact root of failure due to insufficient logging. As a result, we might need to run the whole class to ascertain the problem.

To overcome this problem, TestNG provides us an inbuilt class called the Reporter Class. In this Selenium TestNG tutorial, we will find out how to use the TestNG Reporter Log. By the end of this blog, you would be able to store log super-useful information in the reports.

Note: Random String Generator — The most simple online utility that generates random strings. Free, quick and powerful Random String Generator that allows you to flexibly create random strings ranging from minimum 8 to maximum 25 character length.

What is the Reporter Class in TestNG?

Reporter Class is an inbuilt class in TestNG which is available under the org.testng package. This class provides test methods to log messages that will be included in the HTML reports generated by TestNG. Reporter Class is one of the simplest ways of generating log information.

It helps in storing logs in the reports that can be either user-generated or system-generated reports. This can be hugely beneficial when we later look at the reports as it helps derive detailed information from the logs. This avoids the need to rerun the entire test case.

For example, if you have a test case with many steps, Reporter Class can prove to be extremely helpful since you can specify different logs at each step and later use them when debugging the failures.

Let’s see how we can use the TestNG Reporter Log in Selenium-based test automation framework.

Reporter Class Syntax

Reporter Class of TestNG provides us with four different methods to log information. Isn’t that interesting? Here are those methods:

Reporter.log(String s);
Reporter.log(String s, Boolean logToStandardOut);
Reporter.log(String s, int level);
Reporter.log(String s, int level, Boolean logToStandardOut);

Now, let’s go through each one of these TestNG Reporter Log syntaxes in detail.

1. Reporter.log(String s);

This method logs the string passed into your HTML Report.

Parameters:

S — The message to be logged

Example:

Reporter.log("Logging into Selenium Playground");

2. Reporter.log(String s, Boolean logToStandardOut);

This method logs the string passed into your HTML Report. Additionally, it also prints the same message on your console if logToStandardOut is set to TRUE.

Parameters:

S — The message to be logged
logToStandardOut — Print the message on standard output

Example:

Reporter.log("Logging into Selenium Playground", true);

3. Reporter.log(String s, int level);

This method logs the string passed into your HTML Report if the current verbosity equals or is greater than the one passed in the parameter.

Parameters:

S — The message to be logged
level — The verbosity of the message to be logged

Example:

Reporter.log("Logging into Selenium Playground", 2);

What is Verbosity Level in TestNG?

The Verbose Level in TestNG is used to define the amount of logging performed on the console. The verbosity level ranges from 0 to 10, where 10 is the most detailed logging level whereas 0 means minimal logging.

You can set the verbosity level in your testng.xml. Below is a sample snippet from the tesng.xml, which indicates how to do the same.

<suite thread-count="2" name="TestNGReporterTest" parallel="classes" verbose="10">

4. Reporter.log(String s, int level, Boolean logToStandardOut);

This method logs the string passed into your HTML Report if the current verbosity equals or is greater than the one passed in the parameter. Additionally, it will print the message onto the console if logToStandardOut is set to TRUE.

Parameters:

S — The message to be logged
level — The verbosity of the message to be logged
logToStandardOut — Whether to print the message on standard output as well

For example,

Reporter.log("Logging into Selenium Playground", 2, true);

As the demand for automation increases, so does the demand for skilled testers. TestNG helps you become an automation expert. With LambdaTest’s TestNG certification, you can begin your journey to becoming an automated testing expert.

Here’s a short glimpse of the TestNG certification offered by LambdaTest:

Note: Random Sentence Generator — Free online tool to generate random sentences effortlessly.

How to log messages in reports using TestNG Reporter Class?

Now that we have seen the basics of TestNG Reporter Log in this Selenium TestNG tutorial, let’s deep dive into how we can use the same in our Selenium Automation Framework. We would do the same by demonstrating through a TestNG Reporter Log example.

Use Case: Automate the Simple Form Demo Page of Selenium Playground using the Cloud Selenium Grid By LamdaTest.

LambdaTest provides a cloud-based cross browser testing tool that allows users with an easy way to manage their manual and automated tests across 3000+ online browsers and operating systems combinations.

We will cover the below steps in our test case and use Reporter Class to log all the necessary details.

Open https://www.lambdatest.com/selenium-playground/
Click on Simple Form Demo
Enter a message in Single Input Field and retrieve the Message
Enter a value in the Two Input Fields and retrieve the total of those total values
Validate the actual and expected values.

Below attached is the test class file, its corresponding testng.xml file, and the pom.xml, which is needed in running the same.

package LamdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.Reporter;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class ReporterTest {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeTest
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "93.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "TestNGReporterLog");
       capabilities.setCapability("name", "TestNGReporterLogSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
   }


   @Test
   public void learnSingleInputFieldUsingSelenium() {
       try {
           Reporter.log("Logging into Selenium Playground");
           driver.get("https://www.lambdatest.com/selenium-playground/");
           Reporter.log("Logged into Selenium Playground. Now, Clicking On Simple Form Demo", true);

           //Clicks on the simple form demo option in the selenium playground
           WebElement simpleFormDemo = driver.findElement(By.xpath("//a[text()='Simple Form Demo']"));
           simpleFormDemo.click();
           Reporter.log("Clicked successfully on Simple Form Demo option.", 2);

           //Enters the message in the enter message input box
           WebElement messageInputBox = driver.findElement(By.xpath("//input[@id='user-message']"));
           messageInputBox.sendKeys("Running my first testcase using Lambda Test");

           //Clicks on Show Message button
           WebElement showMessageButton = driver.findElement(By.xpath("//button[text()='Show Message']"));
           showMessageButton.click();

           //Retrieves the entered user message
           WebElement userMessage = driver.findElement(By.xpath("//label[text()='Your Message: ']//parent::div//span"));
           String actualUserText = userMessage.getText();
           Reporter.log("Actual User Input Is: " + actualUserText, 2, true);

           Assert.assertTrue(actualUserText.equals("Running my first testcase using Lambda Test"), "Expected and actual texts do not match.");
       } catch (Exception e) {

       }

   }

   @Test
   public void learnMultipleInputFieldUsingSelenium() {
       try {
           Reporter.log("Logging into Selenium Playground");
           driver.get("https://www.lambdatest.com/selenium-playground/");
           Reporter.log("Logged into Selenium Playground. Now, Clicking On Simple Form Demo", true);

           WebElement simpleFormDemo = driver.findElement(By.xpath("//a[text()='Simple Form Demo']"));
           simpleFormDemo.click();
           Reporter.log("Clicked successfully on Simple Form Demo option For Multiple input fields.", 2);

           WebElement firstInputBox = driver.findElement(By.xpath("//input[@id='sum1']"));
           firstInputBox.sendKeys("2");

           WebElement secondInputBox = driver.findElement(By.xpath("//input[@id='sum2']"));
           secondInputBox.sendKeys("2");

           WebElement getTotalButton = driver.findElement(By.xpath("//button[text()='Get Total']"));
           getTotalButton.click();

           WebElement userMessage = driver.findElement(By.xpath("//label[text()='Total a + b = ']//parent::div//span"));
           String actualUserText = userMessage.getText();

           Reporter.log("The total of the two entered user inputs is: " + actualUserText, 2, true);
           Assert.assertTrue(actualUserText.equals("4"), "Expected and actual texts do not match.");
       } catch (Exception e) {

       }

   }

   @AfterTest
   public void closeBrowser() {
       driver.close();
       Reporter.log("The driver has been closed.", false);

   }

}

GitHub source: https://gist.github.com/RDayal11/1440f06481e4fda2290da2c30d836b91

You can make use of the below testng.xml to run the above java class. Here, we are running the tests in parallel with 2 threads and a verbosity level of 10. You can right-click on the testng.xml file and choose the Run as TestNG option to run the same.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite thread-count="2" name="TestNGReporterTest" parallel="classes" verbose="10">

   <test name="TestNGReporterTest" preserve-order="true">
       <classes>
           <class name="LamdaTest.ReporterTest">
               <methods>
                   <include name="learnMultipleInputFieldUsingSelenium"/>
                   <include name="learnSingleInputFieldUsingSelenium"/>
               </methods>
           </class>
       </classes>
   </test>
</suite>

Below pom.xml will be needed for installing all the necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>org.example</groupId>
   <artifactId>LambdaTest</artifactId>
   <version>1.0-SNAPSHOT</version>
   <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-api</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>6.14.3</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-remote-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
   </dependencies>

   <properties>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
   </properties>

</project>

Code Walkthrough

Now, let’s try to understand the test case using the TestNG Reporter Log, which we automated.

Imported Dependencies: Here, we have imported all the necessary classes, including the Reporter Class needed for using Reporter.log methods.

2. Global Variables: As we have used an online Selenium Grid like LamdaTest to perform parallel testing, we are using the below-shown variables.

Here, you can populate the values for your corresponding username and access key, which can be collected by logging into your LamdaTest Profile Section. You can copy the Username and the Access Token to be used in the code. However, the gridURL will remain the same, as shown below.

3. @ BeforeTest(Setup Method): Here, we have made use of the LamdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc., for our Selenium Remote Web Driver. Do refer to our detailed blog that deep dives into the important TestNG annotations that are used for web automation testing.

4. @ Test(learnSingleInputFieldUsingSelenium): Here, the first Reporter.log statement would print our log only on the emailable report since we haven’t used the logToStandardOut flag. However, the following would print the log both on console output and the emailable report since the logToStandardOut is set to True. Finally, the driver.get statement would open the Selenium Playground website in the Chrome browser launched in the setup method.

Once logged into Selenium Playground, the following steps get the SimpleFormDemo web element and click on the same. The Reporter.log statement used here will log the statement in the emailable report as the current verbosity level, which is 10, set through testng.xml, is greater than the value 2 sent here.

Here, we have made use of XPath in our test case for all the web elements. You can get the XPath of any element by simply doing a right-click on the Element→ Inspect Option. You can also refer to the complete guide on XPath in Selenium for understanding how you can make the most out of XPath for accessing WebElements in the DOM.

Once we are on the Simple Form Demo page, the following steps get the Message Input Box web element and enter the message “Running my first test case using Lambda Test”. Next, we click on the “Show Message” button and retrieve the message displayed, followed by an assert which validates if the entered message and displayed message are equal or not.

The Reporter.log statement here will log the report’s message and print the same on the console output. Thus, the final console output will look something like this:

This is because the emailable report, as mentioned, contains all the messages we logged.

This is how our actual output on the playground looks:

5. @ Test(learnMultipleInputFieldUsingSelenium): Here, the steps to click on the Simple Form Demo Option remain the same as our first test case. However, in this test case, instead of using the single input field, we first enter “2” in the first input box and then repeat the same for the second input box. Later, we click on the “Get Total” button and validate the values we entered.

The final console output looks something like this.

The emailable report will look like this:

The actual output on the playground will look like this:

Note: Random UUID Generator — This free online UUID v4 generator (random UUID) creates version-4 universally unique identifiers according to RFC 4122. Version-4 UUIDs are random and dynamically generated.

How to log messages in the Report using ITestListener?

In this Selenium TestNG tutorial, we saw how we could use the Reporter.log() method in our test cases and log the desired messages in the Report (as well as the console). However, what if we want to print any log before the test execution starts or after the test execution has ended.

TestNG provides us with a lot of Listeners (e.g. IAnnotationTransformer, IReporter, etc). These interfaces are used while performing Selenium automation testing mainly to generate logs and customize the TestNG reports. Here we will make use of ITestListener. You can use the below Listener.java, which is implementing the ITestListener.

package util;

import org.testng.*;

public class Listener implements ITestListener {

   // This belongs to ITestListener and will execute before the whole Test starts

   @Override
   public void onStart(ITestContext arg0) {
       Reporter.log("About to begin executing Class " + arg0.getName(), true);
   }

   // This belongs to ITestListener and will execute, once the whole Test is finished

   @Override
   public void onFinish(ITestContext arg0) {
       Reporter.log("About to end executing Class " + arg0.getName(), true);
   }
   // This belongs to ITestListener and will execute before each test method

   @Override
   public void onTestStart(ITestResult arg0) {
       Reporter.log("Testcase " + arg0.getName() + " started successfully", true);
   }

   // This belongs to ITestListener and will execute only in the event of a successful test method
   public void onTestSuccess(ITestResult arg0) {
       Reporter.log("Testcase " + arg0.getName() + " passed successfully", true);
   }

   // This belongs to ITestListener and will execute only in the event of a fail test

   public void onTestFailure(ITestResult arg0) {
       Reporter.log("Testcase " + arg0.getName() + " failed", true);
   }

   // This belongs to ITestListener and will execute only in the event of the skipped test method

   public void onTestSkipped(ITestResult arg0) {
       Reporter.log("Testcase " + arg0.getName() + " got skipped", true);
   }

   @Override
   public void onTestFailedButWithinSuccessPercentage(ITestResult arg0) {
   }
}

GitHub source: https://gist.github.com/RDayal11/1440f06481e4fda2290da2c30d836b91

onStart: Here, Reporter.log will log the message before the execution of the whole class starts.
OnFinish: Here, Reporter.log will log the message once the execution of the whole class has finished.
onTestStart: Here, Reporter.log will log the message before the execution of the individual test methods starts.
onTestSuccess: Here, Reporter.log will log the message only if the execution of the test method has been completed with Success State.
onTestFailure: Here, Reporter.log will log the message only if the execution of the test method has been completed with Failed State.
onTestSkipped: Here, Reporter.log will log the message only if the execution of the test method has been skipped.

In the case of ITestListener, you can choose to implement only those methods which you intend to.

How to use this Listener Class in the test class?

To implement the above-described methods, you can simply add an annotation in your test class just above your class name.

Syntax:

@Listeners(PackageName.ClassName.class)

Console Output:

How to view the logged messages in EmailableReport in TestNG?

Once you have run your test case, refresh your project and go to the test-output folder. You will find an emailable-report.html inside it, which can be viewed using any browser. In addition, the emailable-report.html will have all your messages logged.

Once you open the report, it will look as shown below.

Conclusion

In this Selenium TestNG tutorial, we learned what is Reporter Class in TestNG and how we can use the different parameters it offers. We also ran our first test script using the Reporter class on Cloud Selenium Grid offered by LamdaTest and logged a few messages. We also learned how we could make use of the Reporter Class in ITestListeners. We got the logs printed on the console and finally saw them getting logged in our EmailableReport. I hope you enjoyed reading this article and learned some more about the TestNG Reporter Log.

Happy Testing!!

How To Set Test Case Priority In TestNG With Selenium

Riadayal — Mon, 18 Apr 2022 11:01:47 +0000

TestNG is an open-source and powerful test automation framework with a wide range of features, including annotations, data providers, group testing, prioritization, and much more.

Prioritization in TestNG is an easy way to set test case priority and run your test case in the exact order you want. This feature is particularly useful when defining a sequence for the test case execution when you have multiple test cases or assign precedence to a few methods over others. For example, if you want your login scenario to run first, followed by adding an item to your cart, you don’t need to worry as TestNG has got you all covered.

In our previous blogs of this Selenium TestNG tutorial series, we have learned how to install TestNG, how to use annotations in TestNG, and much more. In this blog, we will cover how to set test case priority in TestNG while performing Selenium automation testing.

Let’s get started!

Note: MD2 Hash Calculator — Free online tool that computes MD2 hash of text and strings.

What is test Priority in TestNG?

In TestNG, Priority is an attribute that helps the users define the order in which they want the test cases to be executed.

When you have multiple test cases and want them to run in a particular order, you can use the Priority attribute to set test priority in TestNG. The test cases get executed following an ascending order in the priority list, and hence, test cases with lower priority will always get executed first.

Syntax for using test Priority in TestNG

To set test case priority in TestNG, we need to add annotation as @ Test (priority=X). In the below-shown example, we have given a priority of 1 to the test case.

@Test(priority = 1)
public void myTestCaseWithPriority() {
   try {
       System.out.println("I am in my first testcase with priority=1");
   } catch (Exception e) {
   }
}

What is default Priority in TestNG?

The default test priority in TestNG is 0. So, when you don’t set test priority in TestNG explicitly to the test cases, TestNG assigns them a priority of 0.

For example, the below-shown test case doesn’t have any priority set, and hence, it assumes a priority of 0.

@Test
public void myTestCaseWithDefaultPriority() {
   try {
       System.out.println("I am in my first testcase with default priority");
   } catch (Exception e) {

   }
}

With TestNG certification, you can challenge your skills in performing automated testing with TestNG and take your career to the next level.

Here’s a short glimpse of the TestNG certification from LambdaTest:

How to set negative Priority in TestNG?

If you wonder whether we can assign a negative priority value to any test case, the answer is Yes!! We can assign a negative priority to the test methods when we want them to take precedence over the default ones.

The below-shown example has two test methods, one with a default priority 0 and the other with negative priority, i.e., -1. Hence, the test method with negative priority will always be executed first, followed by the test method with default priority.

@Test
public void myTestCaseWithDefaultPriority() {
   try {
       System.out.println("I am in my first testcase with default priority");
   } catch (Exception e) {

   }

}

@Test(priority = -1)
public void myTestCaseWithNegativePriority() {
   try {
       System.out.println("I am in my first testcase with negative priority");
   } catch (Exception e) {

   }

}

Console Output:

How to test with the same Priority in TestNG?

You must wonder what happens if you have a test case with all or some of the methods having the same priority. In such cases, TestNG follows an alphabetical order while executing them.

The below example has two test methods (a and b), and both have the same default priority that is 0. Therefore, the order of execution will be method a followed by b.

@Test
public void a() {
   try {
       System.out.println("A");
   } catch (Exception e) {

   }

}

@Test
public void b() {
   try {
       System.out.println("B");
   } catch (Exception e) {

   }

}

Console Output:

How to set test case Priority in TestNG using Selenium?

In this blog on how to set test case priority in TestNG, we have learned the fundamentals of priority in TestNG. In this section of the Selenium TestNG tutorial, we will see how test priority in TestNG works or how to set test case priority in TestNG.

Problem Scenario:

We will automate the main page of Selenium Playground offered by LamdaTest and print the headers of all the sections sequentially.

LambdaTest is an automated cross browser testing platform. With over 2000 online browser and OS combos, it lets you manage your manual and automated tests in one place with ease.

Implementation:

We will implement the problem scenario in four different ways, as listed below:

When all the methods are without priority
When all the methods are with priority
When all the methods are with the same priority
When there are both methods with and without priority

If you are getting started with running TestNG scripts using Selenium WebDriver, you can refer to our blog on Create TestNG Project In Eclipse & Run Selenium Test Script.

Note: Lines Count— Free online tool to calculate the number of lines in any given text.

Implementing test case Priority when methods are without Priority in TestNG

In this section of the Selenium TestNG tutorial, we will see how to set test case priority in TestNG when all the methods are without any priority using a sample Selenium automation code.

package LamdaTest;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import java.net.MalformedURLException;
import java.net.URL;

class SeleniumPlaygroundTestsWithoutPriority {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "94.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "TestNGWithoutPriorityTests");
       capabilities.setCapability("name", "TestNGWithoutPriorityTestsSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
       Reporter.log("Logging into Selenium Playground", true);
       driver.get("http://labs.lambdatest.com/selenium-playground/");
   }

   @Test
   public void getFirstOptionName() {
       try {
           WebElement option1 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[1]"));
           Reporter.log("The First Option Is: " + option1.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getSecondOptionName() {
       try {
           WebElement option2 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[2]"));
           Reporter.log("The Second Option Is: " + option2.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getThirdOptionName() {
       try {
           WebElement option3 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[3]"));
           Reporter.log("The Third Option Is: " + option3.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getFourthOptionName() {
       try {
           WebElement option4 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[4]"));
           Reporter.log("The Fourth Option Is: " + option4.getText(), true);
       } catch (Exception e) {

       }

   }


   @Test
   public void getFifthOptionName() {
       try {
           WebElement option5 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[5]"));
           Reporter.log("The Fifth Option Is: " + option5.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getSixthOptionName() {
       try {
           WebElement option6 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[6]"));
           Reporter.log("The Sixth Option Is: " + option6.getText(), true);
       } catch (Exception e) {

       }

   }

   @AfterClass
   public void closeBrowser() {
       driver.close();
       Reporter.log("Closing the browser", true);

   }

}

You can use the below testng.xml file for running the above test class.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="TestNGPriorityTest">

   <test name="TestNGPriorityTest" >
       <classes>
           <class name="LamdaTest.SeleniumPlaygroundTestsWithoutPriority">
           </class>
       </classes>
   </test>
</suite>

The below pom.xml can be used for installing all the necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>org.example</groupId>
   <artifactId>LambdaTest</artifactId>
   <version>1.0-SNAPSHOT</version>
   <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-api</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>6.14.3</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-remote-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
   </dependencies>

   <properties>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
   </properties>

</project>

Code Walkthrough:

Imported Dependencies: Here, we have imported all the necessary classes, including the Desired Capabilities, Reporter Class, etc., for using the corresponding methods.

Reporter Class is an inbuilt class in TestNG and is used for logging messages in the HTML Reports and Standard Output.

You can refer to How to Use TestNG Reporter Class In Selenium that deep dives into the details of Reporter Class.

2. Global Variables: Here, we have used an online Selenium Grid like LamdaTest to perform parallel testing.

3. @ BeforeClass(Setup Method): Here, we have used the LamdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc., for our Selenium Remote Web Driver.

Do refer to our detailed blog that deep dives into the important TestNG annotations that are used for web automation testing.

Along with setting the desired capabilities, we are logging into the Selenium Playground in the Before Class Method to use the platform for all the following test methods by logging in once.

We are also logging the text message “Logging into Selenium Playground” in our HTML Report as well as standard output by making use of the Reporter Class Method.

4. @ Test(getFirstOptionName): In this method, we are getting the Web Element of the header of the first section of the Selenium Playground highlighted below. Then, we are printing the text of the same Web Element, using Reporter Class on the console and HTML Report. Here, the text of the web element printed on the console will be Input Forms.

Since there is no priority explicitly set, the test method will assume the default priority of 0.

5. @ Test(getSecondOptionName): In this method, we are getting the Web Element of the header of the second section of the Selenium Playground. Then, we are printing the text of the same Web Element, using Reporter Class on the console and HTML Report. Here, the text of the web element printed on the console will be Progress Bars & Sliders. The test method here again assumes the default priority of 0.

6. @ Test(getThirdOptionName): In this method, we are getting the Web Element of the header of the third section of the Selenium Playground. Then, we are printing the text of the same Web Element, using Reporter Class on the console and HTML Report. Here, the text of the web element printed on the console will be Alerts & Modals. The test method assumes the default priority of 0.

7. @ Test(getFourthOptionName): In this method, we are getting the Web Element of the header of the fourth section of the Selenium Playground. Then, we are printing the text of the same Web Element, using Reporter Class on the console and HTML Report. Here, the text of the web element printed on the console will be Date Pickers.

8. @ Test(getFifthOptionName): In this method, we are getting the Web Element of the header of the fifth section of the Selenium Playground. Then, we are printing the text of the same Web Element, using Reporter Class on the console and HTML Report. Here, the text of the web element printed on the console will be Table.

9. @ Test(getSixthOptionName): In this method, we are getting the Web Element of the header of the sixth section of the Selenium Playground. Then, we are printing the text of the same Web Element, using Reporter Class on the console and HTML Report. Here, the text of the web element printed on the console will be List Box.

10. @ AfterClass(closeBrowser): In this method, we are simply closing the browser launched before class once all the test methods are executed.

Execution Results:

Since no priority was explicitly mentioned for all the above-shown test methods, TestNG will assign them a default priority of 0. Now, as explained in Tests With Same Priority In TestNG, to tie break between all these methods having the same priority, TestNG will follow alphabetical order while executing them. As a result, console output will look something like this:

You can further check the execution results of your test published at LambdaTest Automation Dashboard.

While your test is running, you can also see the live video streaming of your tests and various other details such as logs or exceptions raised.

Note: MD5 Hash Calculator — Free online tool to generate MD5 Hash values.

Implementing test case Priority when methods are with Priority in TestNG

In the previous section of this blog on how to set test case priority in TestNG, you saw the test methods getting executed alphabetically since they had a default priority assigned. Now, let’s see how the same test case would behave when we explicitly assign priority to the test methods while performing Selenium automation testing.

package LamdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

class SeleniumPlaygroundTestsWithPriority {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "93.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "TestNGWithPriorityTests");
       capabilities.setCapability("name", "TestNGWithPriorityTestsSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
       Reporter.log("Logging into Selenium Playground", true);
       driver.get("http://labs.lambdatest.com/selenium-playground/");
   }

   @Test(priority = 1)
   public void getFirstOptionName() {
       try {
           WebElement option1 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[1]"));
           Reporter.log("The First Option Is: " + option1.getText(), true);
           System.out.println("I am in my first testcase with priority=1");
       } catch (Exception e) {

       }

   }

   @Test(priority = 2)
   public void getSecondOptionName() {
       try {
           WebElement option2 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[2]"));
           Reporter.log("The Second Option Is: " + option2.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 3)
   public void getThirdOptionName() {
       try {
           WebElement option3 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[3]"));
           Reporter.log("The Third Option Is: " + option3.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 4)
   public void getFourthOptionName() {
       try {
           WebElement option4 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[4]"));
           Reporter.log("The Fourth Option Is: " + option4.getText(), true);
       } catch (Exception e) {

       }

   }


   @Test(priority = 5)
   public void getFifthOptionName() {
       try {
           WebElement option5 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[5]"));
           Reporter.log("The Fifth Option Is: " + option5.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 6)
   public void getSixthOptionName() {
       try {
           WebElement option6 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[6]"));
           Reporter.log("The Sixth Option Is: " + option6.getText(), true);
       } catch (Exception e) {

       }

   }

   @AfterClass
   public void closeBrowser() {
       driver.close();
       Reporter.log("Closing the browser", true);

   }

}

The below testng.xml file can be used for running the above Java class.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="TestNGPriorityTest">

   <test name="TestNGPriorityTest" >
       <classes>
           <class name="LamdaTest.SeleniumPlaygroundTestsWithPriority">
           </class>
       </classes>
   </test>
</suite>

Code Walkthrough:

In this test case, the scenario remains the same as what we saw in our first example, except that all the methods have been assigned a priority here.

Execution Results:

Since all the test methods had their respective priorities assigned, TestNG will execute them in ascending order of their priorities. Hence, the method getFirstOptionName with priority=1 will be executed first, followed by getSecondOptionName with priority=2, and so on. As a result, console output looks like this:

You can further check the LamdaTest Automation Dashboard to check your test results and logs.

Implementing test case Priority when methods are with the same Priority in TestNG

In the previous section of this blog on how to set test case priority in TestNG, we saw how easily TestNG picked up our test methods based on their priority in ascending order, but what if the methods had the same priority assigned. So let’s see how our test result would look if the same test methods run with an equal priority assigned.

In this method, we will also assign a negative priority to a few of our test methods.

package LamdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

class SeleniumPlaygroundTestsWithSamePriority {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "93.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "TestNGWithSamePriorityTests");
       capabilities.setCapability("name", "TestNGWithSamePriorityTestsSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
       Reporter.log("Logging into Selenium Playground", true);
       driver.get("http://labs.lambdatest.com/selenium-playground/");
   }

   @Test(priority = 1)
   public void getFirstOptionName() {
       try {
           WebElement option1 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[1]"));
           Reporter.log("The First Option Is: " + option1.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 1)
   public void getSecondOptionName() {
       try {
           WebElement option2 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[2]"));
           Reporter.log("The Second Option Is: " + option2.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 2)
   public void getThirdOptionName() {
       try {
           WebElement option3 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[3]"));
           Reporter.log("The Third Option Is: " + option3.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = -1)
   public void getFourthOptionName() {
       try {
           WebElement option4 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[4]"));
           Reporter.log("The Fourth Option Is: " + option4.getText(), true);
       } catch (Exception e) {

       }

   }


   @Test(priority = -2)
   public void getFifthOptionName() {
       try {
           WebElement option5 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[5]"));
           Reporter.log("The Fifth Option Is: " + option5.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = -3)
   public void getSixthOptionName() {
       try {
           WebElement option6 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[6]"));
           Reporter.log("The Sixth Option Is: " + option6.getText(), true);
       } catch (Exception e) {

       }

   }

   @AfterClass
   public void closeBrowser() {
       driver.close();
       Reporter.log("Closing the browser", true);

   }

}

You can use the below testng.xml file for running the above Java class.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="TestNGPriorityTest">

   <test name="TestNGPriorityTest" >
       <classes>
           <class name="LamdaTest.SeleniumPlaygroundTestsWithSamePriority">
           </class>
       </classes>
   </test>
</suite>

Code Walkthrough:

In this test case, the scenario remains the same as what we saw in our first and second examples, except that all the methods have been assigned a priority here, two of them having the same priority and few being assigned a negative priority.

Let’s decode how our results would look like. Here, the test method getSixthOptionName is assigned the lowest priority of -3, and hence, it will be picked up first, followed by getFifthOptionName with priority = -2, and then getFourthOptionName with priority = -1.

After these, there are two test methods getFirstOptionName and getSecondOptionName running with the same priority = 1. Hence, out of these two, getFirstOptionName will be executed first, since it comes first alphabetically followed by getSecondOptionName. The last method to be executed will be getThirdOptionName running with priority = 2.

Execution Results:

As expected, the console output will look like:

You can further check the LamdaTest Automation Dashboard to check your test results and logs.

Implementing test case Priority with both Prioritized and Non-Prioritized methods in TestNG

In the previous section of this blog on how to set test case priority in TestNG, we had either all the test methods without any priority set or all running with priority. But can we have a combination of both prioritized and non-prioritized methods in TestNG? The answer is YES.

Let’s explore a sample test case and understand how TestNG would execute our test methods in such scenarios.

package LamdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

class SeleniumPlaygroundTestsWithAndWithoutPriority {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "93.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "TestNGWithAndWithoutPriorityTests");
       capabilities.setCapability("name", "TestNGWithAndWithoutPriorityTestsSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
       Reporter.log("Logging into Selenium Playground", true);
       driver.get("http://labs.lambdatest.com/selenium-playground/");
   }

   @Test
   public void getFirstOptionName() {
       try {
           WebElement option1 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[1]"));
           Reporter.log("The First Option Is: " + option1.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getSecondOptionName() {
       try {
           WebElement option2 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[2]"));
           Reporter.log("The Second Option Is: " + option2.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 1)
   public void getThirdOptionName() {
       try {
           WebElement option3 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[3]"));
           Reporter.log("The Third Option Is: " + option3.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 1)
   public void getFourthOptionName() {
       try {
           WebElement option4 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[4]"));
           Reporter.log("The Fourth Option Is: " + option4.getText(), true);
       } catch (Exception e) {

       }

   }


   @Test(priority = 0)
   public void getFifthOptionName() {
       try {
           WebElement option5 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[5]"));
           Reporter.log("The Fifth Option Is: " + option5.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test(priority = 2)
   public void getSixthOptionName() {
       try {
           WebElement option6 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[6]"));
           Reporter.log("The Sixth Option Is: " + option6.getText(), true);
       } catch (Exception e) {

       }

   }

   @AfterClass
   public void closeBrowser() {
       driver.close();
       Reporter.log("Closing the browser", true);

   }

}

You can use the below testng.xml for running the Java class.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="TestNGPriorityTest">

   <test name="TestNGPriorityTest" >
       <classes>
           <class name="LamdaTest.SeleniumPlaygroundTestsWithAndWithoutPriority">
           </class>
       </classes>
   </test>
</suite>

Code Walkthrough:

In this test case, the scenario remains the same as what we saw until now, except that some methods have been assigned a priority here while some are running with default priority.

Let’s see how our results would look like, Here, the test methods getFifthOptionName has been assigned a priority =0, but it still falls at the same level as methods getFirstOptionName and getSecondOptionName since even though they are not assigned any priority explicitly, they will run with the default priority which is 0. Hence, out of all these three methods, getFifthOptionName will run first, followed by getFirstOptionName and getSecondOptionName, considering their alphabetical order. After these, the test method getFourthOptionName will be executed, followed by getThirdOptionName as both of them have the same priority set, which is 1. In the end, getSixthOptionName will be executed since it is running with a priority of 2.

Execution Results:

As expected, the console output will look like:

You can further check the LamdaTest Automation Dashboard to check your test results and logs.

TestNG issue when running tests with same Priority and in Parallel

We saw how to set case priority in TestNG and how the TestNG priority worked in different scenarios when they had the same or different priority set or even when they had no priority set. However, the scenarios where the same priority assigned methods could behave a little differently if you would run them in parallel.

You can refer to Create TestNG XML File & Execute Parallel Testing that deep dives into the details of parallel testing in TestNG using TestNG XML file.

For example, If we use our same test case where all the methods had no priority explicitly defined, which means they run with a default priority, i.e., 0 but, instead of running the test methods sequentially, let’s run them in parallel and see how the result would look like.

package LamdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

class SeleniumPlaygroundTestsWithoutPriority {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "94.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "TestNGWithoutPriorityTests");
       capabilities.setCapability("name", "TestNGWithoutPriorityTestsSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
       Reporter.log("Logging into Selenium Playground", true);
       driver.get("http://labs.lambdatest.com/selenium-playground/");
   }

   @Test
   public void getFirstOptionName() {
       try {
           WebElement option1 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[1]"));
           Reporter.log("The First Option Is: " + option1.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getSecondOptionName() {
       try {
           WebElement option2 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[2]"));
           Reporter.log("The Second Option Is: " + option2.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getThirdOptionName() {
       try {
           WebElement option3 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[3]"));
           Reporter.log("The Third Option Is: " + option3.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getFourthOptionName() {
       try {
           WebElement option4 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[4]"));
           Reporter.log("The Fourth Option Is: " + option4.getText(), true);
       } catch (Exception e) {

       }

   }


   @Test
   public void getFifthOptionName() {
       try {
           WebElement option5 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[5]"));
           Reporter.log("The Fifth Option Is: " + option5.getText(), true);
       } catch (Exception e) {

       }

   }

   @Test
   public void getSixthOptionName() {
       try {
           WebElement option6 = driver.findElement(By.xpath("(//div[@class='contentlearn']//h2)[6]"));
           Reporter.log("The Sixth Option Is: " + option6.getText(), true);
       } catch (Exception e) {

       }

   }

   @AfterClass
   public void closeBrowser() {
       driver.close();
       Reporter.log("Closing the browser", true);

   }

}

Let’s use the below testng.xml and run the same class in parallel with a thread count of 6.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="TestNGPriorityTest" parallel="methods" thread-count="6" >

   <test name="TestNGPriorityTest">
       <classes>
           <class name="LamdaTest.SeleniumPlaygroundTestsWithoutPriority">
           /class>
       </classes>
   </test>
</suite>

Execution Results:

Now ideally, the test methods should have been executed in alphabetical order since they all had a default priority of 0 assigned. So, getFifthOptionName should run first, followed by getFirstOptionName, and so on.

Actual Results:

The test methods get executed in a random sequence instead of alphabetical order since we are running them in parallel.

The console output shows that the methods have been executed in a random sequence.

Note: The same works fine if we simply remove the parallel and thread-count attribute from our testng.xml file.

One thing important to consider here is that you would only face this problem when the methods have the same priority. The execution order remains exactly as expected when those methods run with different priorities assigned and in parallel.

You can follow the LambdaTest YouTube Channel by scanning the below QR code and stay up to date with the latest tutorials around Selenium automation testing, cross browser testing, and more.

Conclusion

In this blog on how to set test case priority in TestNG, we learned about the Priority attribute in TestNG and how we can use it while performing Selenium.

We saw how TestNG handles any negative priority, or when all methods have the same priority and when all methods have different priorities. We also came across the limitation of TestNG, which happens when the methods have the same priority assigned, and they are being run in parallel.

I hope you enjoyed reading this Selenium TestNG tutorial on how to set test case priority in TestNG and understood about setting test case priority in TestNG.

Happy Testing !!

How To Implement Shift Left Testing Approach

Riadayal — Thu, 14 Apr 2022 08:01:25 +0000

The “shift left” approach is based on the principle that if the software development team can test code as it is being developed, they can discover errors earlier than if they wait until the end of the project. The shift left testing approach encourages developers to write tests earlier in the development cycle, before code is released for testing.

Shift left testing process is an agile software development practice that emphasizes putting test cases in place early in a project’s life cycle, meaning during initial development phases rather than at the end. It also means that, instead of just covering a small percentage of a project’s expected functionality, a large percentage of the functionality will be covered by automated tests.

Shift left testing is also instrumental in reducing the number of defects that find their way into the production software. It’s about shifting from manual to automated testing so that by the time you need to do manual testing, there is less work to be done from a quality standpoint. In essence, it aims to catch bugs earlier so that they are easier and cheaper to fix at the early stages of the development lifecycle.

However, before discussing the shift left testing process in detail, we need to understand a typical Software Development Life Cycle (SDLC) and the fundamentals of Shift Right Testing.

This article on shift left testing will guide you about the shift left testing approach and how teams can leverage shift left testing to improve the product quality and more.

Let’s Get Started!

What is the Software Development Life Cycle (SDLC)?

In order to understand the shift left testing approach, let us first see what is the Software Development Life Cycle and what are the different stages involved in the cycle.

Software Development Life Cycle (SDLC) is a step-by-step approach to developing any software. It provides us with various models that help us define a methodology to improve the overall quality of the product, along with helping teams improve the software development process.

What are the different stages in a traditional SDLC Model (Waterfall Model)?

We have various SDLC Models available today in the market, the Waterfall Model is the most popular one from the lot. It is a sequential process where you identify all the tasks in advance and then execute them in a sequential manner.

However, the Waterfall model is losing its popularity (at a rapid pace) as software development companies worldwide are adopting Agile methodologies for developing their product. You can deep dive into Agile vs Waterfall methodology comparison to choose the right model for your product.

The below image shows the various steps involved in a typical Waterfall Model.

As we can see, there are different stages involved in a typical software development life cycle.

Planning & Requirement Analysis: This is the most important and fundamental stage in SDLC. This stage involves gathering requirements from the customers, market surveys, and other relevant sources that drive the overall product architecture.
Design: Once the requirements have been gathered and documented, the next stage involves designing the architecture of the overall product based on the requirements that were gathered in the earlier stage.
Implementation/Development: In this stage, the actual product development is started and the product is built and pushed to the QA team to carry out the testing activities.
Testing: Here comes the role of QA to start testing the product, report issues, and finally certify it so that customers can use the product.
Deployment: This is the stage where the product is finally deployed for the customers to use.
Maintenance: The maintenance phase includes enhancing the features and solving issues reported by the customers, which eventually helps in making a better quality product.

Note: JavaScript typed arrays provide a mechanism for accessing raw binary data much more efficiently than can be done with the standard JavaScript getters and setters.

What is Shift Right Testing?

Shift right testing suggests moving the testing activities later in the Software Development Life Cycle, usually after the software has been deployed in the production environments. Thus, it is also known as “Testing In Production,” and it helps uncover issues that could not be detected within the development or testing environments.

In simple terms, shift right testing is performed on applications that are already built and released to the end-customer. This testing practice is widely being adopted these days and is closely tied to DevOps activities.

The goal of shift right testing is to mainly ensure correct performance, stability, and usability of the application in the production environment. The feedback and reviews are thus collected from targeted users to understand the software’s function in real-world conditions. This helps enhance the quality of the software much further.

What is Shift Left Testing?

You saw how the traditional Waterfall model works where testing comes into the picture very late in the cycle or the shift right testing, where testing is done at the end or right of the cycle. Shift right testing is ideal for improving product quality and performance by solving issues that are witnessed in the production environment.

However, the shift left testing approach suggests moving the Testing activities “Left” or rather “earlier” in the development cycle. Thus, it involves the testers much earlier in the software development life cycle. It aims to identify bugs and bottlenecks earlier in the development process.

As a result, it improves the quality of the code and reduces the overall time consumed in the cycle. It helps in ensuring that fewer defects make it to the production environment.

Compared to shift right testing, where the testing was at the extreme right of the development cycle, the shift left testing approach involves testing at each development phase. Overall, it focuses on continuous testing throughout the development cycle.

Importance Of Shift Left Testing approach

In the traditional Waterfall model, where the testing is carried out at the end of the cycle, a situation arises where severe defects are caught. It is difficult and costly to fix such critical bugs at the end of the cycle. The cost involved in fixing bugs rises exponentially with its discovery stage.

As a result, late testing in the cycle leads to:

Increased costs owing to bug discovery at a later stage
Longer bug fix times
Error-prone software since the QA gets less time to validate the entire product
Lesser time for automating the tests, which eventually leads to regression defects
Poor end-user experience as customers experience products with bugs

However, shift left testing by getting the testers involved early in the cycle helps in reducing costs involved in bug discovery and bug fixes. As a result, there is no delay or effect on the project’s final deliverables and even leads to customer satisfaction.

To realize the potential of the shift left testing process in the field of test automation, LambdaTest is hosting a webinar on Shift-Left Testing and Continuous Feedback to Deliver Quality at Agile Speed in association with Patrick Walsh — Engineering Manager at Teckro. Here’s a teaser for the same:

Note: ECMAScript 5 Strict Mode — A strict alignment of code elements related to a particular topic is often used to visually reinforce the importance of that topic for the reader.

Shift Left and Shift Right in Software Testing

Till now, we covered the essential fundamentals of shift right testing as well as shift left testing. While shift left testing ensures that lesser bugs make it to the production environment, the shift right testing approach ensures that issues discovered by end-users in the end-product are fixed at an expedited pace.
// Detect dark theme var iframe = document.getElementById('tweet-1313608471233941504-354'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1313608471233941504&theme=dark" }
Both the testing approaches have their own significance and enterprises need to leverage the combination of shift right testing and shift left testing to improve product quality across the entire paradigm of product development. The intent should be to minimize the cost involved in discovering and fixing defects.

Advantages of Shift Left Testing approach

We covered how you can avoid the risk of finding severe bugs at the end of the cycle by testing earlier in the cycle. However, that is not the only advantage that the shift left testing approach offers.

Here are the salient benefits of shift left testing:

Reduced time to market since the overall QA process happens in a continuous manner
Reduced costs involved in fixing bugs
Top-notch product quality
Improved customer experience due to a strong product base and lesser production issues
Improved efficiency and reduced time in the overall software development lifecycle

The ROI of Shift Left Testing

As a QA manager, one of the key responsibilities should be to reduce the TAT (Turn Around Time) involved in bug discovery and bug fixing stages. Reduced TAT brings significant benefits across the entire value chain.

The cost of detecting and fixing defects in software increases exponentially with time in the software development workflow. In simple terms, the later the bugs are found in the release cycle, the more expensive they turn out to be to fix. As a result, it costs much less to fix bugs that are discovered at an early stage.

And guess what, fixing a bug that is found post-production costs approximately 30x more than it would have taken to fix it in in-house environments. Whoof!

The below graph shows the relative cost of fixing bugs based on their time of detection, and as you can notice the cost increases exponentially with the lateness of their discovery

What are the different types of Shift Left Testing?

There are four different types of shift left testing that provide different values when performed.

Traditional Shift Left Testing

In order to understand the traditional shift left testing approach, we first must understand the traditional V-Model in a Software Development Life Cycle.

SDLC V-Model

We already saw one of the most widely used SDLC models, which is the Waterfall model.
The V-Model is an extension of the Waterfall model and is based on the association of a testing phase for each corresponding development stage. Therefore, it is also known as the Verification and Validation model. This means that there is a directly associated testing phase for every single phase in the development cycle. For example, the following image illustrates a typical V Model.

Now, you know about the V Model. Let’s see what the traditional shift left testing process offers us.

The traditional shift left testing process moves the testing lower down, hence, towards the left on the right side of the V Model.

The traditional shift left testing process focuses more on Unit Testing and Integration Testing. This is done using API testing and achieved via the usage of API testing and utilizing Selenium testing tools. It does not put more emphasis on acceptance testing & system-level testing.

Incremental Shift Left Testing

This shift left testing approach is most suitable for projects which are developing complex and large software systems. In such cases, it becomes difficult to manage all the tasks and deliverables together.

Hence, they are broken down into smaller bits. These pieces are built upon each other, and with each increment, the software is also delivered to the customer. After each delivery, the development & testing is incrementally shifted to the left. Now, this helps even the testing teams as they can test each of the individual bits.

Hence, it introduces incremental testing via an incremental development cycle. The below image is an illustration of Incremental shift left testing.

The red dashed arrows indicate the shift left here since the bits of the large V Model are shifted left to become increments of the corresponding types of testing in the smaller incremental V Models. It introduces

Agile/DevOps Shift Left Testing

This approach of shift left testing is usually done in a number of sprints. It emphasizes continuous testing via an evolutionary life cycle composed of many smaller sprints. It is mainly used for developmental testing and not for operational testing, which occurs once the system is operational.

Model-Based Shift Left Testing

The overall idea behind shift left testing is to catch bugs early before it becomes too late. However, in the above three models that we discussed, testing would start at the early stage of the development cycle. This leads to missing some of the critical issues of the requirement gathering phase, which later gets uncovered once the development cycle is over.

Interestingly, around 45–65% of the defects are introduced during the requirement gathering phase, which we would miss in the above three models. In model-based shift left testing, testing can start at the earliest, so bugs are identified and solved long before the software development cycle starts. Imagine how helpful that would be. The below picture is an illustration of model-based shift left testing.

How to implement the Shift Left Testing approach?

Here are some of the important steps that need to be implemented for rolling out a shift left testing strategy:

Include Testers During Initial Plan And Analysis: Requirement gathering is the most important phase in any software development life cycle. The testing team must get involved during the requirement analysis and gathering phase to have a thorough understanding of the requirements (and use cases). They must review, understand and analyze during this phase. This will lead to avoiding any ambiguity or confusion later in the cycle while testing the product.
Include Testers During Design And Development: QA Teams must collaborate with the developers during the designing and development phase, providing them with the test scenarios that address all the customer use cases and business requirements.
Develop A Robust & Strong Test Plan: The testing team must develop a robust test plan to catch most of the defects during the initial phases and avoid finding critical issues during the actual testing phase.
Unified Test Strategy: A unified test strategy helps the QA teams to analyze dependencies on the environment, automation, test data, etc., and helps in overall readiness. This strategy covers all the dimensions of Quality Control and helps define clear responsibilities for the individual team members.
Risk-Based Analysis: This is usually done to examine each test scenario’s impact and the likelihood of failure. Once the test plan is ready, the testers must decide the priority of the test cases, and later, discuss with the developers the likelihood of that failure and the impact of that failure from the project manager.
Static Testing: Static testing is carried out in the early phases of the project and includes validation of requirements and design. The purpose of static testing is to find defects early in the life cycle that could be very expensive to remove in the later phases of the project.
Include Developers Into Testing Activities: Developers must ensure that they test the individual units of code before sharing it with the concerned QA teams. This can easily address critical issues even before they are pushed.
Inculcate Test Automation: Since shift left testing process involves continuous testing, repeating tests in every continuous cycle can be troublesome for both developers and testers. Hence, both teams should embrace test automation tools that can help them run the tests and ensure better code coverage and product quality.

With test automation, however, the problems of managing the automation suite and real devices arise. However, cloud-based cross browser testing platforms like LambdaTest help you perform end-to-end automation tests on a secure, reliable, and scalable online Selenium Grid.

You can perform automated cross browser testing with Selenium scripts on 3000+ online browsers and operating systems environments, giving you higher test coverage and significantly lesser built times. You could also run a single test across multiple browser/OS configurations simultaneously.

This post on Cross Browser Testing In Selenium will help you quickly get started with Selenium automation testing on the LambdaTest Selenium automation grid. Hence, switching to LambdaTest can help you utilize the shift left testing capacity to its full benefit. Easy!

You can go through the following video to have a quick demo of performing cross browser testing on the LambdaTest platform.

Also, you can follow the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress testing, CI/CD, and more.

Note: Adler-32 Hash Calculator is a tool for computing the Adler-32 checksum of a string or file on your browser. The checksum, which can be generated in base64, hexadecimal, or integer formats, can be used to verify data integrity during transmission.

Shortcomings of the Shift Left Testing approach

We saw that there are so many key benefits of the shift left strategy. But we know everything comes with its own challenges. So here’s a limitation of the shift left testing approach:

The major problem is that in order to shift left, the entire methodology needs to change, which would require a team effort. First, the managers and stakeholders need to start the plan from scratch and introduce it to the team members.

Later, the team members need to adjust accordingly, which means a change in skill sets, tools, coding languages, etc. You see, that is a drastic change for anyone to get accustomed to! But once adopted, the benefits are enormous.

Shift Left Vs Shift Right? What is the way ahead?

We read about shift right and how it helps discover all performance and usability issues in a production environment that can never be seen in a development or testing environment and improves the customer experience.

On the other hand, the shift left helps us save time, effort, risk, and resources enormously. And the million-dollar question arises? Which one is better or which one to look for?

Honestly, I feel these two testing methods are amazing and have their own set of benefits. Opting for any of these would enormously help you. However, why not merge both?
By shifting our testing left and simultaneously shifting our testing right, we can test at every stage of the software development cycle, which will help us achieve continuous testing even better. Isn’t that amazing?

Reach out to your QA, Development, and DevOps team members, and you can probably figure out a plan on how to include both in your release cycle.

Conclusion

In this article on shift left testing, we read about what is shift left testing, what are the different types of it, its pros and cons, and how to implement it. In a nutshell, the shift left testing process is all about finding defects earlier, thereby reducing the overall cost, testing continuously to reduce defects in the end, and as a result, improving the customer experience. We also read about shift right and how it differs from shift left.

Shift left testing has brought a huge change when it comes to the testing world. For testers, the core concept till now was just defect detection. However, the shift left testing process has introduced the concept of early defect detection and how it can lead to early defect prevention and, as a result, reap benefits for the entire team.

I hope you enjoyed reading the article and learned some more about the shift left testing
approach.

Happy Testing!!

Guide To Selenium WebDriver: Getting Started With Test Automation [Tutorial]

Riadayal — Wed, 13 Apr 2022 10:26:40 +0000

When it comes to web automation testing, there are a number of frameworks like Selenium, Cypress testing, Playwright, Puppeteer, etc., that make it to the ‘preferred list’ of frameworks. The choice of test automation framework depends on a range of parameters like type, complexity, scale, along with the framework expertise available within the team. However, it’s no surprise that Selenium is still the most preferred framework among developers and QAs.

For starters, Selenium WebDriver is the core of the Selenium automation framework. In this Selenium WebDriver tutorial, I deep dive into the integral aspects of Selenium WebDriver along with touching upon the Selenium WebDriver architecture.

By the end of this Selenium WebDriver tutorial, you will be in a better position to run Selenium WebDriver tests on local Selenium Grid and cloud Selenium Grid.

What is Selenium?

Selenium is one of the most widely used open-source Web UI (User Interface) automation testing frameworks. It enables testers to execute tests across different browsers, platforms, and languages.

During my QA career, I had the fortune to try out and use a number of test automation frameworks. So far, none of the frameworks come close to the Selenium automation framework in terms of framework features, supported languages, CI/CD integrations, and more. Nevertheless, as per a survey, Selenium automation testing is still the most preferred mode for realizing web automation testing.

Selenium is one-up concerning other test automation frameworks, as it provides compatibility with popular programming languages like Python, Java, JavaScript, C#, and Ruby. Therefore, referring to individual Selenium language tutorials like the Selenium Python tutorial can be a good starting point to make the most out of Selenium and Python for web automation testing.

Shown below is the evolution of the Selenium automation framework:

Apart from Selenium WebDriver, Selenium IDE and Selenium Grid are other key components of the Selenium framework. Selenium 4 is the latest Selenium version at the time of writing this blog. If you are curious about Selenium 4, you can further deep-dive into our blog on what is new in Selenium 4.

Also, you can follow the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress testing, CI/CD, and more.

Features of Selenium automation framework

Now that we have covered the basics about what is Selenium, lets me walk you through some of the major features of the Selenium automation framework in this section of the Selenium WebDriver tutorial:

Selenium supports popular programming languages like Java, Python, C#, JavaScript, Ruby, PHP, and Perl; through the use of specific browser drivers.
Selenium is also a platform-agnostic test automation framework. For example, running Selenium tests on macOS is very much similar to running Selenium tests on Windows OS.
Selenium tests can be executed across multiple browsers (e.g., Firefox, Chrome, IE, Safari, etc.) and multiple operating systems (e.g., Windows 10, macOS, etc.). Running Selenium tests in IE is still relevant even in 2021 🙂
Parallel testing in Selenium using the Selenium Grid helps achieve improved browser and test coverage. This eventually helps in expediting the time to market.
Selenium integration with test automation frameworks supported by Python, Java, JavaScript, etc., helps make the most out of Selenium and the corresponding test automation framework. For example, the TestNG framework for Selenium helps achieve the best out of Selenium and TestNG frameworks.
Selenium and Continuous Integration lets QA engineers run Selenium automation tests as a part of the CI/CD pipeline. For example, Selenium Continuous Integration with Jenkins helps run Selenium automation tests as a part of Jenkins pipelines.
Selenium integration with reporting platforms like Extent, Allure, etc., helps generate and manage test reports. In addition, reporting tools in Selenium provide information about the overall behavior of tests, which helps improve the quality of tests.
Running Selenium tests in Docker containers cuts down the test execution time and minimizes the differences that might arise among different test environments (e.g., staging, production, etc.)

Now that you already know what is Selenium, let’s deep dive into various components of Selenium in the next section of this Selenium WebDriver tutorial.

What are the components of Selenium?

As already stated, Selenium is a framework (i.e., it is not a single software but a suite composed of different components).

Selenium is composed of the following components:

Selenium IDE
Selenium WebDriver
Selenium Grid

It’s important to understand these main components in depth before getting started with a hands-on in this Selenium WebDriver tutorial.

Selenium IDE

Selenium IDE is basically a Record/Run tool that is available as a browser plugin for Mozilla Firefox and Google Chrome. You need not have any programming language experience to work with the IDE.

It follows a record-and-playback approach wherein you can record your test steps and export the tests in the preferred Selenium-supported programming language. These exported tests can then be used with Selenium WebDriver.

Selenium IDE in Selenium 4 is more than a playback & recording tool, the features of which can be leveraged to make the most out of Selenium automation testing.

Selenium WebDriver

Selenium WebDriver is an enhanced version of Selenium RC and overcomes the limitations faced in Selenium RC. It controls the browser by direct communication. It has a faster execution time as compared to IDE and RC.

Selenium RC and WebDriver were merged into one single unit known as Selenium WebDriver 2.0. Over time it has been enhanced for more features and functionalities. In Selenium 3, the JSON Wire protocol was the primary mode of communication between the test code and web browser.

With Selenium 4, JSON Wire protocol is replaced with W3C protocol, which means that encoding and decoding of test requests are no longer required in WebDriver W3C protocol. Therefore, as QA engineers, we can expect less flaky tests with W3C WebDriver Protocol in Selenium 4.

Selenium Grid

Selenium Grid enables the users to perform parallel test execution. It is used along with Selenium RC to run parallel tests across different browsers and machines.

Users can run simultaneous tests in multiple environments, thereby saving a lot of time and expediting the time to market.

Selenium Grid is based on the Hub-Node concept. Until Selenium 3, the Hub and Node jars had to be started separately. With Selenium 4, all the necessary dependencies are available in a single Jar file. Therefore, to use the Selenium Grid on Selenium 4, you need not start the Hub and Node separately.

That’s not all. Selenium Grid on Selenium 4 supports different operating modes like Standalone Mode, Hub & Node Mode, and Fully-Distributed Mode.

Selenium WebDriver architecture

In this Selenium WebDriver tutorial, we have covered the basics of Selenium and its components. Now, let’s try to understand Selenium WebDriver in a detailed manner.

As mentioned earlier, Selenium WebDriver is an enhanced version of Selenium RC. It is a web framework that helps us in executing cross browser tests. It also allows us to choose a programming language to create the test scripts.

Selenium WebDriver architecture in Selenium 3

The Selenium WebDriver architecture in Selenium 3 constitutes of four major components:

Selenium Client Libraries/ Language Bindings
JSON Wire Protocol
Browser Drivers
Real Browsers

Selenium Client Libraries

In order to support multiple languages, Selenium developers have built the language bindings. For example, if you are writing your tests in Java, you can use the Java bindings. Client libraries can be downloaded from the official Selenium website.

JSON Wire Protocol

JSON is an abbreviated form of JavaScript Object Notation. It transfers the data between client and server. It provides support for data structures like objects and arrays, hence doing data reading and writing easier.

It acts as a REST(Representational State Transfer) API to transfer information between the HTTP servers.

Browser Drivers

In order to develop a secure connection with the browser, Selenium uses Drivers. Each browser has its own driver that hides the internal logic of the browser’s functionality.

In addition, each automation language has a corresponding browser driver. The following series of actions are performed when a Selenium automation test is triggered:

Every Selenium command generates a corresponding HTTP request, which is sent to the browser driver.
This request is routed through the HTTP Server.
The HTTP Server now drives the instruction execution on the browser.
The browser sends back the status to the HTTP Server, which forwards it to the automation script.

Some of the browser drivers are ChromeDriver, GeckoDriver, MicrosoftEdge driver, etc.

Browsers

Browsers are the end-point of our test execution. Selenium supports all major browsers like Firefox, Chrome, Safari, Edge, etc.

Selenium WebDriver architecture in Selenium 4

One of the major differences between Selenium 3 and Selenium 4 is that Selenium WebDriver in Selenium 4 is W3C Compliant. As seen in the WebDriver architecture in Selenium 3, encoding and decoding of API requests had to be done due to the involvement of the JSON Wire protocol.

With W3C WebDriver in Selenium 4, the tests can directly communicate with the web browser. Since the Selenium WebDriver and web browsers are on the same page (as far as W3C protocol is concerned), you can expect less flakiness and more consistency as far as Selenium automation testing is concerned.

This certification is ideal for testing professionals who want to acquire advanced, hands-on knowledge in Selenium automation testing.

Here’s a short glimpse of the Selenium Advanced certification from LambdaTest:

Benefits of Selenium WebDriver

Now that we know about the entire architecture of Selenium WebDriver, let’s take a quick look at its advantages in this part of the Selenium WebDriver tutorial.

Here are the major advantages of Selenium WebDriver:

It supports multiple operating systems like Windows, Mac, Linux, etc.
It supports multiple programming languages like Java, Python, JavaScript, PHP, C#, etc.
It is compatible with all modern browsers like Chrome, Firefox, Opera, Safari, and Microsoft Edge. It is also compatible with the near-retiring Internet Explorer (IE) browser.
It provides faster completion of test scripts as compared to other tools.

Limitations of Selenium WebDriver

The advantages of Selenium WebDriver outnumber its shortcomings. However, as a QA engineer, it is important to make an informed choice before choosing the best-suited framework for the project.

Here are some of the potential shortcomings of Selenium WebDriver:

It does not support the automation of Windows-based applications.
It does not have any in-built reporting mechanism.
There is no test tool integration for test management in Selenium.
Out of the box, Selenium WebDriver does not support parallel testing, which makes it very challenging to run larger and complex test suites. If you wish to perform parallel testing with Selenium, then you need to use the Selenium Grid.

However, you can eliminate the above-mentioned drawbacks by adopting cloud Selenium Grid for test automation where Selenium tests can securely run at scale, that too at a rapid pace! Cross browser testing platforms like LambdaTest provide a secure, scalable, and reliable online Selenium Grid that lets you run Selenium tests in parallel on 2,000+ browser and platform configurations.

In the latter sections of this Selenium WebDriver tutorial, we will deep dive into how to run Selenium tests in parallel on LambdaTest cloud Selenium Grid.

Note: Array.prototype.findIndex - The method of findIndex() returns an index of the 1st element in the array which aceepts the testing function provided.

Selenium WebDriver: Installation and set up

In this section of the Selenium WebDriver tutorial, we look at setting up Selenium WebDriver for the Windows Operating System with Java as the programming language.

For demonstration, I have used the Eclipse IDE. However, you can choose to use the IDE of your choice. Now we are about to get our hands dirty with some code 🙂

Starting with the prerequisites:

Install Java
Install Eclipse IDE
Install Selenium WebDriver

Install Java

Step 1: Go to the official Java Downloads website and download the JDK for Windows x64 Installer.

Step 2: Accept the license agreement in the pop-up next and click on Download.

Step 3: Once the download is done, navigate to the Downloads folder and double click the executable so that Java is installed in your system.

Set Up Environment Variables

Step 1: Open your PC settings and select ‘Advanced system settings’ from the System dialog window.

Step 2: Click on the Environment Variables button on the next window.

Step 3: Now, under the System variables, double-click on Path.

Step 4: Add the complete path of the Java installation directory as per your system location and click OK.

Step 5: That’s it. You can now see the topmost path in the screenshot is the Java path in my system.

To verify that the Java is installed and variables are set correctly, open Command Prompt and type: java -version. You will see the Java version installed in your system.

And there you go, your first prerequisite is fulfilled. The next step is installing Eclipse.

Install Eclipse

Step 1: Download Eclipse IDE for Java Developers from the official Eclipse website. I would suggest downloading the last stable release. Select the download based on your system architecture. I am using eclipse Mars, but you can choose any of the latest versions.

Step 2: Once the download is complete, extract the zip file at a location at your convenience.

Step 3: Now open the extracted folder and double click on eclipse.exe.

The Eclipse will open up, and there you are done with your second prerequisite of this Selenium WebDriver tutorial.

Install Selenium WebDriver

The last step in this Selenium WebDriver tutorial is to install the Selenium Standalone Server, which is shown in the steps below:

Step 1: Download Selenium Client & WebDriver Language Bindings from the Selenium website. You can download the client libraries corresponding to your language preference. We will be working with Java Client Bindings in this blog.

Step 2: Once the file is downloaded, extract it to a folder of your choice from where you can use it later.

Step 3: You can now see the corresponding extracted file at the selected destination folder.

Step 4: On opening the folder, you will be able to see the jar files, a libs folder(which contains some more jar files), and a CHANGELOG file.

Step 5: Next, you need to download the browser drivers that will help you instantiate the browser. Below are the links to download the drivers for some major browsers:

There is a difference between WebDriver and Remote WebDriver since there is no necessity to download browser drivers when running Selenium tests on a cloud Selenium Grid.

Step 6: Next, simply extract the downloaded driver and store it at a location where you can use it.

Now we are done with setting up the prerequisites, let’s look at how to configure Eclipse with the Selenium Libraries that we have just installed.

Note: Array.prototype.includes - Checks if an array includes the given value, returning a boolean value (unlike indexOf).

How to setup Eclipse for Selenium WebDriver

The following steps in this Selenium WebDriver tutorial will guide you in configuring and installing the Eclipse IDE:

Step 1: Launch eclipse.exe that was saved in the steps to install Eclipse.

Step 2: Select your workspace manually, or let the default location be there and click on OK.

Step 3: Create a New Project by navigating to File > New > Java Project.

Step 4: Click on Next and give a name to the Project. Click on Finish.

Step 5: Now that your project is created, Right-click on the project and select New > Package.

Step 6: Enter the package name in the New Java Package dialog box and click on Finish.

Step 7: You need to create a class under the package now. To do so, right-click on the package name, go to New > Class.

Step 8: In the New Java Class dialog box, enter a name for your class, select a method stub viz, public static void main(String[] args) and click on Finish.

Your Explorer would look like below:

Step 9: Now that we have created an outline for our test project, we need to import the libraries we installed for the Selenium WebDriver tutorial in the section above.

To start with, right-click on the project and go to Build Path > Configure Build Path.

Step 10: Click on Add External JARs and navigate to the location where your downloaded JARs were saved.

Step 11: Select the two jars installed in the Selenium Client folder and the jars under the libs folder.

Step 12: Once added, you will see the jar files under the Libraries:

Step 13: Click on Apply and then OK. You can now see the Referenced Libraries populated in the package explorer.

We have now configured Selenium WebDriver in our Eclipse Project and are good to write our first test script.

Running test automation script using Selenium WebDriver

Now that I have touched upon Selenium Webdriver and its architecture, let’s write our first automation script using Selenium Webdriver in this section of the Selenium WebDriver tutorial.

Problem Statement

To demonstrate the usage of Selenium WebDriver, I will perform the following use case:

Launch Chrome browser.
Open LambdaTest sign up page.
Click on the Sign In button.
Close the web browser.

Implementation

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

@Listeners({util.Listener.class})
class FirstTestScriptUsingWebDriver {
   public static WebDriver driver = null;
   @BeforeTest
   public void setUp() throws Exception {
       WebDriverManager.chromedriver().setup();
       driver=new ChromeDriver();
   }
   @Test
   public void firstTestCase() {
       try {
           System.out.println("Logging into Lambda Test Sign Up Page");
           driver.get("https://accounts.lambdatest.com/register");
           WebElement pageHeader= driver.findElement(By.xpath("//a[text()='Sign In']"));
           pageHeader.click();
           System.out.println("Clicked on the Sign In Button.");
       } catch (Exception e) {
       }
   }
   @AfterTest
   public void closeBrowser() {
       driver.close();
       System.out.println("The driver has been closed.");
   }
}

You will need the below pom.xml for importing the necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>LambdaTest</artifactId>
  <version>1.0-SNAPSHOT</version>
  <dependencies>
      <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-api</artifactId>
          <version>4.0.0-alpha-7</version>
      </dependency>
      <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-remote-driver</artifactId>
          <version>4.0.0-alpha-7</version>
      </dependency>
      <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-chrome-driver</artifactId>
          <version>4.0.0-alpha-7</version>
      </dependency>
      <dependency>
          <groupId>org.testng</groupId>
          <artifactId>testng</artifactId>
          <version>6.14.3</version>
      </dependency>
      <dependency>
          <groupId>io.github.bonigarcia</groupId>
          <artifactId>webdrivermanager</artifactId>
          <version>4.4.3</version>
      </dependency>
  </dependencies>

  <properties>
      <maven.compiler.source>8</maven.compiler.source>
      <maven.compiler.target>8</maven.compiler.target>
  </properties>
</project>

And the below testng.xml file will be needed for running the test case.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="FirstTestScriptUsingWebDriverSuite">
   <test name="FirstTestScriptUsingWebDriver" >
       <classes>
           <class name="LambdaTest.FirstTestScriptUsingWebDriver" >
           </class>
       </classes>
   </test>
</suite>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="FirstTestScriptUsingWebDriverSuite">
   <test name="FirstTestScriptUsingWebDriver" >
       <classes>
           <class name="LambdaTest.FirstTestScriptUsingWebDriver" >
           </class>
       </classes>
   </test>
</suite>

Code Walkthrough

Import Dependencies: Here, we have imported all the necessary classes for using WebDriver, ChromeDriver, and the related annotations in TestNG.

@BeforeTest: Typically, for running any Selenium test script, you will need a browser driver, and to use it, you need to set the browser driver executable path explicitly. After that, you need to instantiate the driver instance and proceed with the test case.

However, managing the browser driver can become cumbersome over time as their versions keep changing, and you need to keep updating the drivers. Hence, to overcome the same, I have used the WebDriverManagerClass.

Here, WebDriverManager.chromedriver.setup() checks for the latest version of the specified web driver binary. If the binaries are not present, it will download them and later instantiate the Selenium WebDriver instance with the ChromeDriver. Isn’t it easy? 🙂

The below two classes will help you in using WebDriver and ChromeDriver.

@ Test(firstTestCase): In the test case, I opened the LambdaTest sign up page in the Chrome browser using the driver.get() statement. The findElement method in Selenium is used for locating the SignIn WebElement.

@AfterTest: In the AfterTest method, close the browser using the driver.close() method.

Test Execution

You will see the below output once you run the testng.xml file.

Automated browser testing using cloud Selenium Grid

So far, in this Selenium WebDriver tutorial, I used the local Selenium WebDriver to run a particular test case. Now, as the number of test cases increases, running them parallel with a higher number of threads on a single VM would start giving automation failures.

However, a realistic scenario is where a single test case (or multiple test cases) has to be run across different browser and OS combinations. This is where the Selenium Grid comes into the picture. Selenium Grid eases our setup-related woes, along with helping us run tests at scale on a local (or cloud) grid setup.

Selenium Grid makes parallel execution possible by sending commands to remote Web Browser instances from a hub server.

Selenium testing tools like LambdaTest offer a cloud Selenium Grid that lets you run parallel tests across 3000+ different browsers and operating systems. All you need to do is instantiate the remote Selenium WebDriver instead of the local Selenium WebDriver.

With LambdaTest, you don’t have to worry about downloading and configuring hundreds of browsers on your machine as they are readily available on the online Selenium Grid. Instead, all you need to do is register on LambdaTest for free and claim your 100 free automation testing minutes.

Now that I have covered the basics of cloud Selenium Grid, let’s implement the same example using LambdaTest Selenium Grid.

Problem Statement

In the below example, I am running the same test case on Chrome (latest) + Windows 10 combination.

Launch Chrome browser on Windows 10
Open LambdaTest sign up page.
Click on the Sign In button.
Close the web browser.

Implementation

package LambdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class FirstTestScriptUsingSeleniumGrid {

  public String username = "YOUR USERNAME";
  public String accesskey = "YOUR ACCESSKEY";
  public static RemoteWebDriver driver = null;
  public String gridURL = "@hub.lambdatest.com/wd/hub";

  @BeforeTest
  public void setUp() throws Exception {
      DesiredCapabilities capabilities = new DesiredCapabilities();
      capabilities.setCapability("browserName", "chrome");
      capabilities.setCapability("version", "94.0");
      capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
      capabilities.setCapability("build", "FirstTestScript");
      capabilities.setCapability("name", "FirstTestScriptSample");
      try {
          driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
      } catch (MalformedURLException e) {
          System.out.println("Invalid grid URL");
      } catch (Exception e) {
          System.out.println(e.getMessage());
      }
  }

  @Test
  public void firstTestCase() {
      try {
          System.out.println("Logging into Lambda Test Sign Up Page");
          driver.get("https://accounts.lambdatest.com/register");
          WebElement pageHeader= driver.findElement(By.xpath("//a[text()='Sign In']"));
          pageHeader.click();
          System.out.println("Clicked on the Sign In Button.");
      } catch (Exception e) {

      }
   }

  @AfterTest
  public void closeBrowser() {
      driver.close();
      System.out.println("The driver has been closed.");
  }
}

Code Walkthrough

Global Variables: As tests have to be run on LambdaTest cloud Selenium Grid, we would be using the below-shown variables.

Here, you can populate the values for your corresponding username and access key, which can be collected by logging into your LamdaTest Profile Section. However, the gridURL will remain the same.

@BeforeTest(Setup Method): In Selenium, the RemoteWebDriver class implements the WebDriver interface to execute test scripts through the RemoteWebDriver server on a remote machine.

The below-imported class will help you in using the RemoteWebDriver class.

Here, I have used the LambdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc.

The implementation under @ Test and @AfterTest annotations remain unchanged since only the end-point of execution have changed from Selenium Grid’s load to cloud Selenium Grid.

Execution

Log on to LambdaTest Automation Dashboard to check the status of the test execution on LambdaTest.

Note: asm.js - The asm.js subset of JavaScript provides low-level, portable performance with high-level language semantics. Asm.js is intended to be a target for a compile step from languages like C/C++ into optimized JavaScript.

What’s new in Selenium WebDriver 4?

So far, in this Selenium WebDriver tutorial, I have covered the essentials of Selenium WebDriver and its architecture in Selenium 3 and Selenium 4. However, as a QA engineer, the innumerable features offered by Selenium 4 fascinate me a lot!
// Detect dark theme var iframe = document.getElementById('tweet-1448289975062220808-244'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1448289975062220808&theme=dark" }
Apart from the renewed Selenium WebDriver architecture, here are some of the other major enhancements in Selenium 4:

W3C Standardization

A significant change in Selenium 4 is the complete W3C compliance of the WebDriver APIs. This eliminates the need for encoding and decoding the API requests by the JSON wire protocol responsible for communication between browsers and test scripts.

The implementation of this standardization means the WebDriver will now interact directly with the target browser.

Enhanced Selenium Grid

The earlier versions of Selenium Grid were complex to set up and maintain. However, the new Selenium Grid is easy to set up as there is no need to maintain Hub and Node separately.

The Grid even has an improved GUI, and the support for Docker helps the developers (and testers) to use it on Virtual Machines(VMs). The Grid can also be deployed now on Kubernetes. Running Selenium tests in Docker is now a cakewalk with the Selenium Grid setup on Selenium 4!

Relative Locators in Selenium 4

Relative locators (or Friendly locators) help locate WebElements relative to a particular WebElement. For example, the required element could be near to, left of, right of, above, or below a specified element.

Relative locators in Selenium 4 can help save a lot of time when locating tricky WebElements. Above, Below, To Right Of, To Left Of, and Near are some of the relative locators that can be leveraged to reduce the lines of code when it comes to locating WebElements.

Better Browser and Tab Management

Selenium 4 provides a new API newWindow that lets you create a new window (or tab) and switch to it without creating a new WebDriver object.

Opening a new Window in Selenium 4

driver.get("https://www.google.com/");
// Opens a new window and switches to new window
driver.switchTo().newWindow(WindowType.WINDOW);
// Opens LambdaTest homepage in the newly opened window
driver.navigate().to("https://www.lambdatest.com/");

Opening a new Tab in Selenium 4

driver.get("https://www.google.com/");
// Opens a new window and switches to new window
driver.switchTo().newWindow(WindowType.TAB);
// Opens LambdaTest homepage in the newly opened tab
driver.navigate().to("https://www.lambdatest.com/");

Deprecation Of Desired Capabilities

In Selenium 4, Desired Capabilities are getting replaced with Options, and we need to create an Options object to use the Driver class.

The below-mentioned Options objects will be used in Selenium 4 for defining the browser-specific capabilities.

Chrome — ChromeOptions
Firefox — FirefoxOptions
Safari — SafariOptions
Internet Explorer (IE) — InternetExplorerOptions
Microsoft Edge — EdgeOptions

Chrome DevTools Protocol (CDP)

Chrome DevTools Protocol is the new addition in Selenium 4. The new feature provides Chrome and Microsoft Edge’s debugging protocol for debugging, simulating poor network conditions, and emulating geolocation for automation testing.

Geolocation testing with Selenium helps in mocking browser’s geolocation for the purpose of web browser testing. This feature in Selenium 4 can be leveraged to test the website’s functionalities by mocking different geographical locations.

Conclusion

In this Selenium WebDriver tutorial, I deep-dived into the basics of Selenium WebDriver, its components, and Selenium WebDriver architecture. I also implemented test scenarios using WebDriver as well as cloud Selenium Grid. In the end, we also glanced upon the new and improved features which Selenium 4 offers. I believe you are now all geared up to start on your Selenium automation journey.

Happy testing! 🙂

How To Minimize Browsers In Selenium WebDriver Using JUnit

Riadayal — Tue, 12 Apr 2022 10:58:34 +0000

Delivering software with superior UI is one of the key aspects of development, but there are times when you need to test the most complicated functionality. These tests include window resizing or minimizing or maximizing, all of which require interacting with the browser window, and if the number of tests is high, it becomes cumbersome. Minimizing browser windows in Selenium with JUnit can be used for automating interactions with browser windows. There are scenarios where minimization of browser windows is a must-have operation to proceed with other scenarios in the respective test suite.

Another use case to run our tests with a minimized browser is when we are running tests on our local machine, and we want the screen to be free for us to do something else while the tests continue to run. Whatever the reason be, minimizing the browser window using Selenium WebDriver is a very useful feature and can make our lives easier in many situations.

Let’s take a deeper look at how you can handle minimized and maximized browser windows with Selenium WebDriver.

In our previous blogs of this Selenium JUnit tutorial series, we have learned how to run parameterized tests in JUnit, use annotations in JUnit, and much more. In this Selenium JUnit tutorial, we will learn how to minimize browsers in Selenium WebDriver using JUnit.

Starting your journey with Selenium WebDriver? Check out this step-by-step guide to perform Automation testing using Selenium WebDriver.

Let’s get started!

How to minimize browsers in Selenium WebDriver using JUnit?

Until Selenium 3, we had some limitations while handling the browsers; i.e., we were only able to maximize the window and not able to minimize directly. Though it allowed using setPosition() to minimize the browser window, it was of no use as you couldn’t maximize whenever you wanted.

However, with Selenium4, you have a new minimize() method that reduces browser windows to a taskbar icon, just like a user normally does. Like the “SwitchTo().window(id)” method, the minimize window is also accessible with the window.minimize() method in Selenium WebDriver 4.

Selenium 4 brings out the immense potential offered by the Selenium framework. Selenium 4 is built to work better with technology stacks native to the browser, including modern JavaScript frameworks. If you want to know more about Selenium 4, you can further deep-dive into our blog on what is new in Selenium 4.

Also, you can follow the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress testing, CI/CD, and more.

In order to minimize the browser window in our Selenium automation script, we can use the below-mentioned command.

driver.manage().window().minimize();

For using the minimize function, we just need the corresponding Selenium WebDriver package. In our use case, it is RemoteWebDriver since we are running the cases on an online Selenium Grid.

Now that we have seen the syntax for minimizing the browser let’s deep dive into how we can use the same in our Selenium automation framework. We would do the same by demonstrating through a Minimize Browser Window example.

We will make use of the LambdaTest cloud Selenium Grid to automate our test cases.

LambdaTest is a cloud-based cross browser testing tool that provides a solution to every obstacle you face while performing automation testing using your local machine. Selenium testing tools like LambdaTest offer a Selenium Grid consisting of 2000+ online browsers for you to perform Selenium automation testing effortlessly.

In the next section of this Selenium JUnit tutorial on how to minimize browsers in Selenium WebDriver, we will demonstrate how you could easily perform automation testing by making use of the cloud Selenium Grid.

How to minimize browser window in Selenium WebDriver

Log into the Selenium Playground offered by LambdaTest by launching the browser, followed by minimizing it and then getting the Page Title.

We will cover the below-mentioned steps in our test case:

Launch the web browser.
Open https://www.lambdatest.com/selenium-playground/.
Minimize browser.
Get the web page title and print the same.

Below is the test class file and the pom.xml, which will be needed to install all the necessary dependencies.

package LambdaTest;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;

import java.net.MalformedURLException;
import java.net.URL;

class MinimizeBrowserWindow {
   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "95.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "MinimizeBrowserWindow");
       capabilities.setCapability("name", "MinimizeBrowserWindowUsingSelenium");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }

   }

   @Test
   public void minimizeBrowserWindow() {
       try {
           System.out.println("Logging into Selenium Playground");
           driver.get("http://labs.lambdatest.com/selenium-playground/");
           driver.manage().window().minimize();
           System.out.println("Minimized the browser window");
           String title=driver.getTitle();
           System.out.println("The title of web page is:"+title);
       } catch (Exception e) {

       }

   }


   @AfterClass
   public void closeBrowser() {
       driver.close();
       System.out.println("Closing the browser");

   }

}

Below pom.xml will be needed for installing all the necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>org.example</groupId>
   <artifactId>LambdaTest</artifactId>
   <version>1.0-SNAPSHOT</version>
   <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-api</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-remote-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.10</version>
       </dependency>
   </dependencies>

   <properties>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
   </properties>

</project>

Note: Unescape JSON is a JavaScript utility that restores an escaped JSON string or file back to its unescaped original state.

Code Walkthrough

In this section of this Selenium JUnit tutorial on how to minimize browsers in Selenium WebDriverNow, let’s try to understand the test case using the TestNG Reporter Log, which we automated.

1. Import Dependencies: Here, we have imported all the necessary classes of JUnit, Desired Capabilities, and RemoteWebDriver to set the respective browser capabilities and run the test cases on the grid.

2. Global Variables: As we have used a Selenium Grid Cloud like LamdaTest to perform our test execution, we are using the below-shown variables.

3. @BeforeClass(Setup Method): Here, we have used the LambdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc., for our Selenium Remote WebDriver. In case you are new to JUnit annotations, do check out Annotations in JUnit blog that deep dives into the important annotations in JUnit.

4. @ Test(minimizeBrowserWindow): Here, we are simply logging into Selenium Playground, and then we are minimizing the browser using the driver.manage.window.minimize() command.

After minimizing the browser window, we get the title of the web page and print the same.

Console Output

Once you run the test case, your console output will look like below.

So as you can see, the test case runs seamlessly even when you minimize the actual browser window. Isn’t it cool?

Start your free testing on remote browser today.

This JUnit certification establishes testing standards for those who wish to advance their careers in Selenium automation testing with JUnit.

Here’s a short glimpse of the JUnit certification from LambdaTest:

How to minimize browsers in Selenium WebDriver using JUnit by setting its position?

In the above example of this Selenium JUnit tutorial, we saw how to minimize browsers in Selenium WebDriver using the minimize() function, which is one of the most widely used methods to do the same. However, wouldn’t it be interesting to explore a few more alternatives to do it? Let’s check them.

In order to minimize the browser window, we can also use the below command.

driver.manage().window().setPosition(new Point(int x,int y));

Here, x and y refer to the respective x and y coordinates of the window position. Since the window position and dimensions differ from one machine to another, we will use a generic method of finding out the corresponding x & y coordinates relevant to the browser window. In the end, we will use them for setting the minimized position.

The below test case demonstrates the same use case that was demonstrated earlier. The only change is the usage of setPosition method to minimize the corresponding browser window.

package LambdaTest;

import org.openqa.selenium.Dimension;
import org.openqa.selenium.Point;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import java.net.MalformedURLException;
import java.net.URL;

class MinimizeBrowserWindowUsingPosition {

   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "95.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "MinimizeBrowserWindowBySettingPosition");
       capabilities.setCapability("name", "MinimizeBrowserWindowBySettingPositionUsingSelenium");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }

   }

   @Test
   public void minimizeBrowserWindowBySettingPosition() {
       try {
           System.out.println("Logging into Selenium Playground");
           driver.get("http://labs.lambdatest.com/selenium-playground/");
           Point p = driver.manage().window().getPosition();
           System.out.println("The Position of the window is:"+p);
           Dimension d = driver.manage().window().getSize();
           System.out.println("The Size of the window is:"+d);
           driver.manage().window().setPosition(new Point((d.getHeight()-p.getX()), (d.getWidth()-p.getY())));
           System.out.println("The New X Coordinate After Minimizing Is:"+(d.getHeight()-p.getX()));
           System.out.println("The New Y Coordinate After Minimizing Is:"+(d.getWidth()-p.getY()));
           System.out.println("Minimized the browser window by setting its position");
           String title=driver.getTitle();
           System.out.println("The title of web page is:"+title);
       } catch (Exception e) {

       }

   }


   @AfterClass
   public void closeBrowser() {
       driver.close();
       System.out.println("Closing the browser");
   }
}

Code Walkthrough

Window position means the distance of the window from the left side(X Coordinates) of the screen and topside(Y Coordinates) of the screen.

We are first determining the Position of the window followed by the Dimension. Later, by using the setPosition method, we set the corresponding x and y coordinates of the window as shown below, which will minimize the window.

driver.manage().window().setPosition(new Point((d.getHeight()-p.getX()), (d.getWidth()-p.getY())));

The below-highlighted package imports are necessary to use the Dimension and Point methods.

Console Output

Once you run the test case, your console output will look like below.

How to minimize browsers in Selenium WebDriver using keyboard shortcuts?

In the above two sections of this Selenium JUnit tutorial, we looked at how to minimize browsers in Selenium WebDriver using the driver.manage.window() commands.

However, when it comes to minimizing the windows manually, we always fall back on keyboard shortcuts. The most widely used keyboard shortcut for doing the same is Windows + D.

Let’s see how we can replicate the keyboard shortcuts using our Selenium automation script. In this use case of replicating the keyboard shortcuts, we will make use of the Robot Class. Robot Class in Selenium generates native system input events for test automation and other applications where you need control over the mouse and keyboard. The major benefit of Robot Class is that it helps to handle keyboard actions in Selenium WebDriver.

However, one thing important to note is that the below use case of minimizing the browser using keyboard shortcuts holds only for a Windows Machine.

The below test case demonstrates the same use case for how to minimize browsers in Selenium WebDriver and getting the web page title with minimized browser window using the keyboard shortcut.

package LambdaTest;

import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import java.awt.*;
import java.awt.event.KeyEvent;
import java.net.MalformedURLException;
import java.net.URL;

class MinimizeBrowserWindowUsingRobotClass {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeClass
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "95.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "MinimizeBrowserWindow");
       capabilities.setCapability("name", "MinimizeBrowserWindowUsingRobotClass");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }

   }

   @Test
   public void minimizeBrowserWindowUsingRobotClass() {
       try {
           System.out.println("Logging into Selenium Playground");
           driver.get("http://labs.lambdatest.com/selenium-playground/");
           Robot robot = new Robot();
           robot.keyPress(KeyEvent.VK_WINDOWS);
           robot.keyPress(KeyEvent.VK_D);
           System.out.println("Minimizing the window");
           robot.keyRelease(KeyEvent.VK_WINDOWS);
           robot.keyRelease(KeyEvent.VK_D);
           System.out.println("Minimized the browser window");
           String title=driver.getTitle();
           System.out.println("The title of web page is:"+title);
       } catch (Exception e) {

       }

   }


   @AfterClass
   public void closeBrowser() {
       driver.close();
       System.out.println("Closing the browser");

   }

}

Code Walkthrough

To emulate the keyboard shortcut(Windows + D), we have used Robot Class. Here, we have made use of keyPress and keyRelease functions of Robot Class.

keyPress(int keycode): This method is used to press a given key. The parameter keycode is an integer value for the key pressed. For example, to press a key for alphabet A, the value that has to pass is KeyEvent.VK_A i.e., keyPress(KeyEvent.VK_A).

keyRelease(int keycode): This method releases the given key. The keycode parameter is the integer value for the pressed key. For example, to release the already pressed key for alphabet A, the value that has to pass is KeyEvent.VK_A i.e., keyPress(KeyEvent.VK_A).

Here, KeyEvent is a low-level event. In Java AWT, low-level events are events that indicate direct communication from the user like a keypress, key release, etc.

In order to use the above-specified methods, you will need the below package imports.

As a result, by using the Robot class and its keyPress and KeyRelease methods, we would easily emulate the keyboard actions of pressing Windows+D buttons together and releasing them once the browser window gets minimized.

Note: SVG favicons shows a browser compatibility score of 40. This is a collective score out of 100 to represent browser support of a web technology. The higher this score is, the greater is the browser compatibility. The browser compatibility score is not a 100% reflection for every browser and the web technology support. However, it does give you an estimate on how much you should rely on a particular web technology in terms of browser compatibility.

How to minimize multiple browser windows in Selenium WebDriver using JUnit?

In the above sections of this Selenium JUnit tutorial, we saw how to minimize browsers in Selenium WebDriver using different ways like using the minimize method, setPosition method, and the keyboard actions in Selenium WebDriver.

We would be demonstrating the same usecase in this section as well. However, we cover it through three different test methods in this example and perform it in three different browsers.

package LambdaTest;

import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import java.net.MalformedURLException;
import java.net.URL;

class MinimizeMultipleBrowserWindow {


   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @Test
   public void minimizeWindowInChromeBrowser() {
       try {
           RemoteWebDriver driver = null;
           DesiredCapabilities capabilities = new DesiredCapabilities();
           capabilities.setCapability("browserName", "Chrome");
           capabilities.setCapability("version", "latest");
           capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
           capabilities.setCapability("build", "MinimizeChromeBrowserWindow");
           capabilities.setCapability("name", "MinimizeChromeBrowserWindowUsingChromeBrowser");
           try {
               driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
           } catch (MalformedURLException e) {
               System.out.println("Invalid grid URL");
           } catch (Exception e) {
               System.out.println(e.getMessage());
           }
           System.out.println("Logging into Selenium Playground");
           driver.get("http://labs.lambdatest.com/selenium-playground/");
           driver.manage().window().minimize();
           System.out.println("Minimized the browser window");
           String title=driver.getTitle();
           System.out.println("The title of web page is:"+title);
           driver.close();
           System.out.println("Closing the browser");
       } catch (Exception e) {

       }

   }

   @Test
   public void minimizeWindowInFirefoxBrowser() {
       try {
           RemoteWebDriver driver = null;
           DesiredCapabilities capabilities = new DesiredCapabilities();
           capabilities.setCapability("browserName", "Firefox");
           capabilities.setCapability("version", "94.0");
           capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
           capabilities.setCapability("build", "MinimizeFirefoxBrowserWindow");
           capabilities.setCapability("name", "MinimizeFirefoxBrowserWindowUsingFireFoxBrowser");
           try {
               driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
           } catch (MalformedURLException e) {
               System.out.println("Invalid grid URL");
           } catch (Exception e) {
               System.out.println(e.getMessage());
           }
           System.out.println("Logging into Selenium Playground");
           driver.get("http://labs.lambdatest.com/selenium-playground/");
           driver.manage().window().minimize();
           System.out.println("Minimized the browser window");
           String title=driver.getTitle();
           System.out.println("The title of web page is:"+title);
           driver.close();
           System.out.println("Closing the browser");
       } catch (Exception e) {

       }

   }

   @Test
   public void minimizeWindowInMicrosoftEdgeBrowser() {
       try {
           RemoteWebDriver driver = null;
           DesiredCapabilities capabilities = new DesiredCapabilities();
           capabilities.setCapability("browserName", "MicrosoftEdge");
           capabilities.setCapability("version", "95.0");
           capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
           capabilities.setCapability("build", "MinimizeEdgeBrowserWindow");
           capabilities.setCapability("name", "MinimizeEdgeBrowserWindowUsingEdgeBrowser");
           try {
               driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
           } catch (MalformedURLException e) {
               System.out.println("Invalid grid URL");
           } catch (Exception e) {
               System.out.println(e.getMessage());
           }
           System.out.println("Logging into Selenium Playground");
           driver.get("http://labs.lambdatest.com/selenium-playground/");
           driver.manage().window().minimize();
           System.out.println("Minimized the browser window");
           String title=driver.getTitle();
           System.out.println("The title of web page is:"+title);
           driver.close();
           System.out.println("Closing the browser");
       } catch (Exception e) {

       }

   }


}

Code Walkthrough

In this test case, we cover the minimized window functionality in three different browsers, i.e., Chrome, Firefox, and Microsoft Edge. Here, we are using the LambdaTest grid to set up the corresponding browser name and versions.

Once the corresponding browsers are launched, we log into Selenium Playground, minimize the corresponding windows, and get the web page title.

As a result, by using the LambdaTest grid, we covered the same test case in 3 different browser flavors. We then ran the three different test cases simultaneously by making use of parallel testing with JUnit 5 and Selenium.

Life is easier, isn’t it?

This Selenium JUnit testing tutorial for beginners and professionals will help you perform parallel test execution with JUnit and Selenium on LambdaTest cloud-based Selenium Grid.

Once the tests are completed, you can view the test results, logs, and the test recording as well at your LambdaTest Automation Dashboard.

Note: Internationalization API shows a browser compatibility score of 90. This is a collective score out of 100 to represent browser support of a web technology. The higher this score is, the greater is the browser compatibility. The browser compatibility score is not a 100% reflection for every browser and the web technology support. However, it does give you an estimate on how much you should rely on a particular web technology in terms of browser compatibility.

Conclusion

In this Selenium JUnit tutorial, we learned how to minimize browsers in Selenium WebDriver while performing Selenium automation testing using driver.manage.window.minimize(). We also learned about its alternatives of setting the window position or pressing the keyboard keys using the Robot class in Selenium. In the end, we also implemented the same scenario across multiple browser windows of different flavors and ran them in parallel.

I hope you enjoyed reading this article and learned the different ways of minimizing the browser window.

Happy Testing!!

How To Handle Captcha In Selenium

Riadayal — Fri, 08 Apr 2022 10:24:37 +0000

With the rapidly evolving technology due to its ever-increasing demand in today’s world, Digital Security has become a major concern for the Software Industry. There are various ways through which Digital Security can be achieved, Captcha being one of them. Captcha is easy for humans to solve but hard for “bots” and other malicious software to figure out. However, Captcha has always been tricky for the testers to automate, as many of them don’t know how to handle captcha in Selenium or using any other test automation framework.

Now, let’s see what Captcha is and how to automate Captcha in Selenium WebDriver. We will also read in detail about ReCAPTCHA, which is hosted by Google and protects your site from spam and abuse. It uses advanced risk analysis techniques to tell humans and bots apart.

Let’s deep dive into the world of Captcha and reCAPTCHA and see how to handle image Captcha in Selenium WebDriver.

What is Captcha?

CAPTCHA stands for Completely Automated Public Turing Test To Tell Computers And Humans Apart and is a type of challenge-response test used to ascertain whether the user is a human or a bot. The primary purpose of Captcha is to prevent bots or automated programs from using various types of computing services or collecting certain types of sensitive information such as email addresses, phone numbers, etc.

The image shown here is one generated by reCAPTCHA. Captchas are mostly dynamic and are intended to defeat automation frameworks like Selenium. However, since they are dynamic, they can be carried out successfully only with human interpretation and analysis, and as a result, most of the automated bots fail.

Different test cases possible around Captcha

Before we jump into handling Captcha scenarios in Selenium, let us first see the different test cases that are possible around Captcha. They are:

To verify that the application accepts only valid Captcha.
To verify that the Captcha code is case-sensitive.
To verify that an error message is displayed if a user enters an incorrect Captcha code.
To verify that the Captcha code on the screen is properly visible to the user or not.
To verify that a new Captcha is getting generated on page refresh.
To verify that a new Captcha is generated if a user enters an incorrect Captcha code.
To verify that Copy & Paste action doesn’t work on the Captcha input box.
To verify that the application is not accepting partial Captcha code.

Different ways to handle Captcha in Selenium

Although automating Captchas in Selenium is not the best practice, automation engineers have still been trying to find ways to automate Captcha in Selenium for a very long time to achieve complete automation of their web pages.

However, Captcha forms vary a lot. For example, they can be visual or drag and drop, etc. Some Captchas even use audio to support visually challenged individuals. This diverse form of Captchas makes it challenging to automate.

Now that we have seen the possible test cases around Captchas, how do we efficiently handle Captcha in Selenium so that the tests run seamlessly without any hindrances? As of writing this article, the latest version of Selenium is Selenium 4. This Selenium WebDriver Tutorial for beginners and professionals will help you learn what’s new in Selenium 4 (Features and Improvements).

You can follow the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress testing, CI/CD, and more.

There are three ways by which we can efficiently handle Captcha in Selenium:

By disabling Captchas in test environments
By clicking the reCAPTCHA checkbox in Selenium
By adding a delay in your selenium script and manually solving Captcha while running.

Let’s understand these in a detailed manner.

How to disable Captchas in Test Environment?

The easiest and most foolproof way to handle captchas in Selenium is to disable the need for captchas during your test. By disabling captchas in test environments, you would no longer need to perform the Captcha task while testing a web application.

The disadvantage of this approach is that you are testing something different from your production environment. Ideally, you want your automated tests to test your product in an environment that resembles your production environment.

Disabling Captchas has now become very easy with Google’s open-source captcha widget called reCaptcha.

What is reCAPTCHA?

reCAPTCHA is a CAPTCHA system that enables web hosts to distinguish between human and automated access to websites. reCAPTCHA is a free service from Google and is very widely used nowadays since it supports major screen readers such as JAWS and NVDA for IE, Edge, or Chrome on Windows OS, ChromeVox for Chrome OS, and VoiceOver for Safari and Chrome on Mac OS.

reCAPTCHA v2

In case you are using reCAPTCHA v2, you can put the Site Key and Secret Key also known as the test keys. These keys help in bypassing the CAPTCHA verification request and as a result, your automation case can run seamlessly.

Below are the test keys for the same

Site Key: 6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI
Secret Key: 6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe

Once you enable the site keys you will see a warning message as shown below. This indicates that the CAPTCHA has been bypassed only for testing purposes and not in real-time.

reCAPTCHA v3

In the case of reCAPTCHA v3, the user needs to create their own keys for testing environments. Unlike reCAPTCHA v2, where the same keys are used for multiple environments, reCAPTCHA v3 enables the users to create separate keys for separate testing environments.

It is recommended to safeguard your code and credentials so that the test credentials can never be used in production mode. This must be done in order to avoid the risk of contaminating reCAPTCHA risk analysis with the data from the test environment, which can alter the test result analysis.

You can create your reCAPTCHA v3 keys from the Google reCAPTCHA website.

How to automate Captcha in Selenium WebDriver?

CAPTCHAs can be automated if you are able to decode the image using OCR (Optical Character Recognition). However, to do that, you’ll need to write complex algorithms to sort out the image pattern — and writing an algorithm is not that easy. Moreover, one has to be an expert in image pattern mapping as well.

But images, with time, have become progressively more unreadable, thereby reducing the chances of CAPTCHA automation.

That leaves us with one way to bypass the CAPTCHA, but it won’t automate it. In that case, we can tweak the script to wait for a certain interval of time at the screen where CAPTCHA is present, and the user will enter the CAPTCHA text himself, while other fields will be filled automatically.

Using this, we can achieve the target of complete web automation to a certain degree. But, this would still be a semi-automated test. In other scenarios, where we just have a reCAPTCHA checkbox, we can simply click it using Selenium.

Now we have seen how to automate Captcha in Selenium WebDriver. In the next section of this article on how to handle Captcha in Selenium, let us see both of these scenarios in our automation test.

Note: org.junit.TestCouldNotBeSkippedException — This represent that a test should be skipped is not skipped. Generally, it happens when the test uses method in Assume class that it should be skipped though it is completed before processing, test got completed or other failures occurred to skip the test.

By clicking the reCAPTCHA checkbox in Selenium

In case your application uses the reCAPTCHA checkbox, you will want to click the Captcha to complete the script. One of the mechanisms that reCaptcha uses is checking how long it took for the captcha to complete.

Humans will take a bit longer to complete a captcha task as compared to robots. Therefore, before clicking the Captcha, you will want to add a delay (for example using WebDriverWait) to replicate human behavior.

If you are wondering what is WebDriverWait in Selenium, let me share some insights on it. WebDriver equips the user with two kinds of waits in order to handle the recurring page loads, web element loads, the appearance of pop-ups and error messages, etc. on the web page. They are:

Implicit Wait
Explicit Wait

WebDriverWait falls under the category of Explicit Waits. Explicit Waits are used to halt the execution until the time a particular condition is met or the maximum time has elapsed. You will be able to understand it better once we use it in our implementation.

Let us now see the automation of Captchas using an example in Selenium. In the below example, we will automate the SIGN UP page of old.reddit.com.

We will make use of the LambdaTest cloud Selenium Grid to automate our test cases. LambdaTest is a cloud-based cross browser testing platform that supports Selenium Grid, providing a solution to overcome every challenge you might face while performing automation testing on your local machine. Selenium testing tools like LambdaTest offer a Selenium Grid consisting of 3000+ online browsers for you to perform Selenium automation testing effortlessly.

Use Case

Launch the web browser.
Open https://old.reddit.com/login.
Enter username.
Enter password.
Enter the password again in Verify Password.
Enter the email id
Wait for the reCAPTCHA checkbox to appear.
Click on it.

Below is the test class file which will help you to automate the checkbox. Here we have used Java with Selenium for automating Captcha in Selenium WebDriver.

If you’re a developer who’s looking to take your Java development and test engineering skills to the next level, this Selenium Java 101 certification from LambdaTest can help you reach that goal.

Here’s a short glimpse of the Selenium Java 101 certification from LambdaTest:

automateCaptchaInSelenium.java

package LambdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;

public class automateCaptchaInSelenium {


    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

    [@BeforeClass](http://twitter.com/BeforeClass)
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "95.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "CaptchaInSelenium");
        capabilities.setCapability("name", "TCaptchaInSeleniumSample");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        driver.get("[https://old.reddit.com/login](https://old.reddit.com/login)");


    }


    [@Test](http://twitter.com/Test)
    public void clickOnRecaptchaCheckBoxInSelenium() {
        try {
            System.out.println("Let's start with fresh registration");
            WebElement username=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='user']"));
            username.sendKeys("some_username_200");

            WebElement password=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='passwd']"));
            password.sendKeys("SuperStrongP@ssw0rd");

            WebElement verifyPassword=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='passwd2']"));
            verifyPassword.sendKeys("SuperStrongP@ssw0rd");

            WebElement email=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='email']"));
            email.sendKeys("[xyz@gmail.com](mailto:xyz@gmail.com)");

            WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(25));
            wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(
                    By.xpath("//iframe[starts-with([@name](http://twitter.com/name), 'a-') and starts-with([@src](http://twitter.com/src), '[https://www.google.com/recaptcha'](https://www.google.com/recaptcha'))]")));

            wait.until(ExpectedConditions.elementToBeClickable(
                        By.xpath("//div[[@class](http://twitter.com/class)='recaptcha-checkbox-border']"))).click();

            System.out.println("Clicked the checkbox");

        } catch (Exception e) {

        }

    }


    [@AfterClass](http://twitter.com/AfterClass)
    public void closeBrowser() {
        driver.close();
        Reporter.log("Closing the browser", true);

    }

}

You can use the below testng.xml file for running the class file.

Testng.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "[http://testng.org/testng-1.0.dtd](http://testng.org/testng-1.0.dtd)">
<suite name="automateCaptchaInSeleniumSuite">
   <test name="automateCaptchaInSeleniumTest">
       <classes>
           <class name="com.infa.dqcloud.testcases.profiling.automateCaptchaInSelenium">

           </class>
       </classes>
   </test>
</suite>

You can check the GitHub link here.

Below is the pom.xml file you will need to install the necessary dependencies.

Pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0)"
        xmlns:xsi="[http://www.w3.org/2001/XMLSchema-instance](http://www.w3.org/2001/XMLSchema-instance)"
        xsi:schemaLocation="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0) [http://maven.apache.org/xsd/maven-4.0.0.xsd](http://maven.apache.org/xsd/maven-4.0.0.xsd)">
   <modelVersion>4.0.0</modelVersion>

   <groupId>org.example</groupId>
   <artifactId>LambdaTest</artifactId>
   <version>1.0-SNAPSHOT</version>
   <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-api</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-remote-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-chrome-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>6.14.3</version>
       </dependency>
       <dependency>
           <groupId>io.github.bonigarcia</groupId>
           <artifactId>webdrivermanager</artifactId>
           <version>4.4.3</version>
       </dependency>
   </dependencies>

   <properties>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
   </properties>

</project>

Code Walkthrough

Let us now understand the different areas of code in detail.

Imported Dependencies: Here, we have imported all the necessary classes of Selenium WebDriver, WebDriverWait, Desired Capabilities, and RemoteWebDriver to set the respective browser capabilities and run the test cases on the grid.

Global Variables: As we have used a Selenium Grid Cloud like LambdaTest to perform our test execution, we are using the below-shown variables.
Here, you can populate the values for your corresponding username and access key, which can be collected by logging into your LambdaTest Profile Section. You can copy the Username and the Access Token to be used in the code. However, the grid URL will remain the same, as shown below.

@BeforeClass(Setup Method): Here, we have used the LambdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc., for our Selenium Remote WebDriver. After that, we are opening the website in the launched browser.

@ Test(clickOnRecaptchaCheckBoxInSelenium): In this case, we are locating the web elements for username and then entering the username value into it. Similarly, we are locating the corresponding web elements for the password, verify password, and email text boxes as shown in the below image.

We are making use of XPaths in Selenium for locating each element. So, in order to locate the element and write its XPath, you can simply right-click on the web element and click on Inspect. Then, in the Elements tab, you can start writing the locator.

Once all the above elements have been located and their values are entered, we wait for the frame having the reCAPTCHA checkbox to be visible and switch to it. We achieve this by making use of WebDriverWait class and ExpectedConditions. ExpectedConditions in Selenium lets you wait for the occurrence of a specified condition before execution can proceed to the next step. If the condition is not met within the expected time duration, an appropriate exception is raised.

Finally, when we have switched to the frame, we wait for the checkbox to be clickable and finally click on it. In case you are new to iFrames, you can check out the blog on handling iFrames in Selenium.

@AfterTest(closeBrowser): In this method, we are closing the browser that we had launched. Once the tests are completed, you can view the test results, logs, and the test recording as well in your LambdaTest Automation Dashboard.

We saw how to click the reCAPTCHA checkbox in Selenium; however, if you are using Puppeteer or Playwright, you can open an URL containing the captcha and find the specific captcha DOM element, and click the Captcha.

In order to see the Test Overview, you can navigate to the LambdaTest Analytics Dashboard. The Test Overview showcases the Test Case Health Snapshot for tests that consistently pass, consistently fail, etc. Test Summary, on the other hand, displays the total number of tests passed, failed, completed, etc.

Note: org.junit.runners.model.TestTimedOutException — This happens when test is not able complete within the specified time in junit.

Solving Captcha issues in Selenium

With this approach, your test will detect the Captcha and wait for a specific amount of time, allowing you to enter the correct captcha answer. While waiting for the captcha answer, you will need to manually look at the captcha question, solve the captcha and pass the answer to the (automated) test.

However, this option to handle Captcha in Selenium is not recommended, as it requires manual intervention during an automated test, and as a result, the test case is not 100% automated.

We can achieve it again by using WebDriverWait in Selenium and giving the user the time to solve the captcha manually. WebDriver will wait till the next action is ready.

We can see the same Use Case where once the reCAPTCHA checkbox has been clicked, we wait till the SIGN UP button gets enabled, and by the time the user gets the opportunity to solve the Captcha manually.

Below is the test class file you can use to automate the scenario.

automateCaptchaInSelenium.java

package LambdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;

public class automateCaptchaInSelenium {


    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

    [@BeforeClass](http://twitter.com/BeforeClass)
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "95.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "CaptchaInSelenium");
        capabilities.setCapability("name", "TCaptchaInSeleniumSample");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        driver.get("[https://old.reddit.com/login](https://old.reddit.com/login)");


    }

    [@Test](http://twitter.com/Test)
    public void manuallySolveCaptchaWithDelayInSelenium() {
        try {
            System.out.println("Let's start with fresh registration");
            WebElement username=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='user']"));
            username.sendKeys("some_username_200");

            WebElement password=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='passwd']"));
            password.sendKeys("SuperStrongP@ssw0rd");

            WebElement verifyPassword=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='passwd2']"));
            verifyPassword.sendKeys("SuperStrongP@ssw0rd");

            WebElement email=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='email']"));
            email.sendKeys("[xyz@gmail.com](mailto:xyz@gmail.com)");

            WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(25));
            wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(
                    By.xpath("//iframe[starts-with([@name](http://twitter.com/name), 'a-') and starts-with([@src](http://twitter.com/src), '[https://www.google.com/recaptcha'](https://www.google.com/recaptcha'))]")));

             wait.until(ExpectedConditions.elementToBeClickable(
                        By.xpath("//div[[@class](http://twitter.com/class)='recaptcha-checkbox-border']"))).click();

            System.out.println("Clicked the checkbox");

            wait.until(ExpectedConditions.elementToBeClickable(
                    By.xpath("//button[text()='sign up']"))).click();

            System.out.println("Clicked the sign up button");

        } catch (Exception e) {

        }

    }


    [@AfterClass](http://twitter.com/AfterClass)
    public void closeBrowser() {
        driver.close();
        Reporter.log("Closing the browser", true);

    }

}

You can use the below testng.xml file for running the class file.

Testng.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "[http://testng.org/testng-1.0.dtd](http://testng.org/testng-1.0.dtd)">
<suite name="automateCaptchaInSeleniumSuite">
   <test name="automateCaptchaInSeleniumTest">
       <classes>
           <class name="com.infa.dqcloud.testcases.profiling.automateCaptchaInSelenium">

           </class>
       </classes>
   </test>
</suite>

Code Walkthrough

Here, everything remains the same as explained in the code walkthrough of our first example except the part where we wait for the SIGN UP button to be clickable after the checkbox has been clicked. Now, after the reCAPTCHA checkbox has been clicked, the screen selects the applicable images. Once that is done, the SIGN UP button gets clickable. Hence, when the user manually solves the captcha, the web driver waits for the SIGN UP button to get clickable.

How to handle invisible reCaptcha in Selenium?

reCAPTCHA v2 offers an invisible captcha, which does not require the user to perform any interaction with the captcha. Unfortunately, the invisible captcha tries to block the web traffic that appears to come from a bot, so in order to avoid this, you can:

Change the user-agent of your test script.

How to change the user agent?

For Chrome

In case you are using the Chrome browser follow the below steps:

First, you should add a User-Agent Switcher to your Chrome browser.
Then, go to User-Agent Switcher settings at Chrome extensions section and get the desired agent’s information.

Later, in your test script, you can make use of the ChromeOptions class and add the corresponding arguments as shown below in the Before Setup Method.

ChromeOptions options = new ChromeOptions();
options.addArguments("--user-agent=Mozilla/5.0 (Linux; Android 6.0; HTC One M9 Build/MRA58K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.98 Mobile Safari/537.36");
driver = new ChromeDriver(options);

For Firefox

In case you are using the Firefox browser follow the below steps.

First, you should add User-Agent Switcher to your Firefox browser.
Save all device lists to the desktop and import them as shown below.

3- Go to Tools-> Default User Agent -> Edit User Agents

4- Then select Mobile Devices -> Devices -> HTC -> One M9 — Android 6.0 -Chrome 52.0 and then click Edit.

Then, you can see the user agent value of the HTC One M9 as shown below. Copy and save these values for user agent manipulation in our selenium web driver test automation code.

Later you can use the setPreference method in your BeforeSetup method with the general.useragent.override flag and pass the value you had collected in the previous step.

FirefoxProfile profile = new FirefoxProfile();
//Change User Agent to HTC ONE M9
profile.setPreference("general.useragent.override", "Mozilla/5.0 (Linux; Android 6.0; HTC One M9 Build/MRA58K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.98 Mobile Safari/537.36");
driver = new FirefoxDriver(profile);

These were some of the ways of handling invisible reCAPTCHAs in Firefox and Chrome browsers.

Conclusion

We know that automating Captchas in Selenium is not one of the best practices. However, we might need to replicate our actual use case. In this article on how to handle Captcha in Selenium, we read what are Captchas and how we can deal with them in Selenium automation testing. We also read about reCAPCTHAs and how to disable them in testing environments, followed by how to automate Captcha in Selenium WebDriver. Run your WebdriverIO tests & start your free testing. In the end, we also saw what Invisible Captchas are and how to handle them.

I hope you learned something new about Captchas in Selenium and enjoyed reading this blog.
Happy Testing!!

FindElement And FindElements In Selenium [Differences]

Riadayal — Thu, 07 Apr 2022 15:04:41 +0000

Finding an element in Selenium can be both interesting and complicated at the same time. If you are not using the correct method for locating an element, it could sometimes be a nightmare. For example, if you have a web element with both ID and Text attributes, ID remains constantly changing, whereas Text remains the same. Using an ID locator to locate web elements can impact all your test cases, and imagine the regression results over a few builds in such cases. This is where the methods findElement and findElements in Selenium can help.

The findElement method in Selenium can help you enormously while using Selenium locators for finding web elements while performing Selenium automation testing. Let’s see the different implements of findElement in Selenium and the differences between findElement and findElements in Selenium.

Let’s get started!!

How to find an Element in Selenium?

When you start to write your Selenium automation script, interaction with web elements becomes your first vital step because it’s the web elements you play around with within your test script. However, interaction with these web elements can only happen if you identify them using the right approach.

findElement method in Selenium is a command which helps you identify a web element. There are multiple ways that findElement provides to uniquely identify a web element within the web page using web locators in Selenium like ID, Name, Class Name, Link Text, Partial Link Text, Tag, which we will see later in the blog.

For now, let’s see the syntax of using findElement in Selenium. We would be using Selenium with Java for the implementation.

Syntax to find an Element in Selenium

The syntax to find an Element in Selenium is:

WebElement elementName= driver.findElement(By.<LocatorStrategy>("LocatorValue"));

As shown in the above syntax, this command accepts the “By” object as the argument and returns a WebElement object. The “By” is a locator or query object and accepts the locator strategy. The Locator Strategy can assume the below values:

ID
Name
Class Name
Tag Name
Link Text
Partial Link Text
XPath
CSS Selector

For example, if you want to use ID as the Locator Strategy to identify any web element, it would look like below.

WebElement ele1 = driver.findElement(By.id(“id”))

The Locator Strategy further accepts the Locator Value to identify a web element uniquely.

If there is no matching element within the web page, findElement throws NoSuchElementException.

Let us understand it using an example.

Use Case:

Log in to Selenium Playground offered by LambdaTest.
Try to find a web element that is not present on the screen.

LambdaTest is a cloud-based cross browser testing platform that supports Selenium Grid, providing a solution to every obstacle you face while performing Selenium automation testing using your local machine. Selenium testing tools like LambdaTest offer an online Selenium Grid consisting of 3000+ online browsers for you to perform Selenium automation testing effortlessly.

Refer to the below test case for the above scenario:

In the above test case, the checkbox web element is not present on the Selenium Playground main home page, and hence, it will throw NoSuchElementException. Check out the console output in this case.

Console Output:

Now, you must be wondering, what if the locator value returns multiple matching elements? FindElement would return you the first element within the web page which matches the locator value. The next question arises: What if you need all those matching web elements? This is where findElements in Selenium comes into the picture.

Let’s see what findElements has to offer!!

Note: org.junit.rules.ExpectedException

The ExpectedException is a rule which helps scripts to verify that the script throws the specific exception or not

How to find Elements in Selenium?

findElements in Selenium returns you the list of web elements that match the locator value, unlike findElement, which returns only a single web element. If there are no matching elements within the web page, findElements returns an empty list.

Syntax to find Elements in Selenium

The syntax to find Elements in Selenium is:

List<WebElement> elementName = driver.findElements(By.<LocatorStrategy>("LocatorValue"));

findElements in Selenium example: If you want to use ID as the Locator Strategy for identifying a list of web elements, it would look something like below:

List<WebElement> ele1 = driver.findElements(By.id(“id”))

Similar to the findElement() command, this method also accepts the “By” object as the parameter and returns a list of web elements.

Now, since we have seen findElement and findElements in Selenium example, let’s understand the difference between the findElement and findElements in Selenium Java.

Difference between findElement and findElements in Selenium Java

Now that we read about findElement and findElements, let’s have a quick look at their major differences.

findElement	findElements
Returns the first matching web element within the web page even if multiple web elements match the locator value.	Returns a list of multiple web elements matching the locator value.
Throws NoSuchElementException in case there are no matching elements.	Returns an empty list in case there are no matching elements.
Returns a single web element	Returns a collection of web elements.
No indexing is required since only one element is returned.	Each web element is indexed starting from 0.

Note: The latest version of Selenium is Selenium 4 when writing this article. This Selenium WebDriver Tutorial for beginners and professionals will help you learn what’s new in Selenium 4 (Features and Improvements).

You can follow the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress testing, CI/CD, and more.

Locator Strategies of findElement and findElements in Selenium Java

Let us now understand the various locator strategies that can be used with findElement and findElements in Selenium Java. We will see their implementation making use of Selenium Playground offered by LambdaTest.

We will also make use of the LambdaTest cloud Selenium Grid to automate our test cases.

Selenium Grid refers to a software testing setup that enables QAs to perform parallel tests across multiple browsers and devices with unique operating systems. When the entire setup of Selenium Grid is accessible using cloud-based servers, it is called Selenium Grid On Cloud. An online Selenium Grid helps you focus on writing better Selenium test scripts rather than worrying about infrastructure maintenance.

Find Element by ID

As we all know, the ID locator in Selenium is one of the widely used locators for locating desired WebElement on a document (or page). If a website uses dynamically generated IDs, this strategy cannot uniquely find an element. However, it will still return the first web element which matches the locator value.

For example, If you have a web element with a tag as Button which has a dynamic ID, where ID is getting changed from ‘ID-3465-text1’ to ‘ID-4434-textE2’, in such cases, it becomes difficult to use the ID attribute. However, if it remains static, you can easily use the ID to locate the Web Element.

Syntax to find Element by ID:

WebElement elementName = driver.findElement(By.id(“id value”));

Use Case:

Let us see the checkbox demo page of Selenium Playground and locate the checkbox web element using ID. Further, we will click on the same checkbox and validate the success message.

Locator:

The correct locator value making use of id in the above case would be

WebElement checkBox = driver.findElement(By.id(“isAgeSelected”));

Implementation:

Consider the below test case file.

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.Select;
import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class AutomationUsingFindElement {

    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "@hub.lambdatest.com/wd/hub";

    @BeforeTest
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "AutomationUsingFindElement");
        capabilities.setCapability("name", "AutomationUsingFindElementSuite");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }



    @Test
    public void findElementById() {
        try {
            System.out.println("Logging into Lambda Test Checkbox Demo Page");
            driver.get("https://www.lambdatest.com/selenium-playground/checkbox-demo");

            WebElement checkBox= driver.findElement(By.id("isAgeSelected"));
            checkBox.click();
            System.out.println("Clicked on the Checkbox");

            WebElement successMessage=driver.findElement(By.id("txtAge"));
            String expectedMessage=successMessage.getText();

            Assert.assertEquals("Success - Check box is checked", expectedMessage);
        } catch (Exception e) {

        }

    }

    @AfterTest
    public void closeBrowser() {
        driver.close();
        System.out.println("The driver has been closed.");

    }

}

You can use the below testng.xml file for running the test case.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="AutomationUsingFindElementSuite">

    <test name="AutomationUsingFindElementTest" >
        <classes>
            <class name="LambdaTest.AutomationUsingFindElement" >
            </class>
        </classes>
    </test>
</suite>

You can use the below pom.xml file for installing the necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>LambdaTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-api</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-remote-driver</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-chrome-driver</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.14.3</version>
        </dependency>
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>4.4.3</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

Code Walkthrough:

Let us now understand the different areas of code in detail.

1. Imported Dependencies: Here, we have imported all the necessary classes of Selenium WebDriver, WebDriverWait, Desired Capabilities, and RemoteWebDriver to set the respective browser capabilities and run the test cases on the grid.

2. Global Variables: As we have used a Selenium Grid Cloud like LamdaTest to perform our test execution, we are using the below-shown variables.

Here, you can populate the values for your corresponding username and access key, which can be collected by logging into your LambdaTest Profile Section. You can copy the Username and the Access Token to be used in the code. However, the grid URL will remain the same, as shown below.

We have also used the Listener class here in order to customize the TestNG Report. TestNG provides us with a lot of TestNG Listeners (e.g. IAnnotationTransformer, IReporter, etc). These interfaces are used while performing Selenium cloud testing mainly to generate logs and customize the TestNG reports.

To implement the Listener class, you can simply add an annotation in your test class just above your class name.

Syntax:

[@Listeners](http://twitter.com/Listeners)(PackageName.ClassName.class)

3. @ BeforeTest(Setup Method): Here, we have used the LambdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc., for our Selenium Remote WebDriver. After that, we are opening the website in the launched browser.

@ Test(findElementById): In this case, we first locate the web element for the checkbox using ID and then click on it. Later, we locate the success message and validate if it appears correctly after clicking on the checkbox.
@ AfterTest(closeBrowser): Here, we are just closing the launched browser.

Once the tests are completed, you can also view your test results, logs, and the test recording as well in your LambdaTest Automation Dashboard.

Find Element by Name

Name locator in Selenium is similar to find by ID, except the driver will locate an element by the “name” attribute instead of “id”.

Syntax to find Element by Name:

WebElement elementName = driver.findElement(By.name(“name”));

Use Case:

Let us see the input form page of Selenium Playground and write the locator for the input text boxes such as Name, Email, etc.

Locator:

The correct locator value making use of name in the above case would be:

WebElement emailTextBox= driver.findElement(By.name(“email”));

Implementation:

Now, let us automate entering the value of name and email making use of the findElement by Name.

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.Select;
import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class AutomationUsingFindElement {

    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "@hub.lambdatest.com/wd/hub";

    @BeforeTest
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "AutomationUsingFindElement");
        capabilities.setCapability("name", "AutomationUsingFindElementSuite");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }


    @Test
    public void findElementByName() {
        try {
            System.out.println("Logging into Lambda Test Input Form Demo Page");
            driver.get("https://www.lambdatest.com/selenium-playground/input-form-demo");

            WebElement nameTextBox = driver.findElement(By.name("name"));
            nameTextBox.sendKeys("LambdaTest");
            System.out.println("Entered Name");

            WebElement emailTextBox = driver.findElement(By.name("email"));
            emailTextBox.sendKeys("lambdatest@gmail.com");
            System.out.println("Entered Email");

        } catch (Exception e) {

        }

    }

    @AfterTest
    public void closeBrowser() {
        driver.close();
        System.out.println("The driver has been closed.");

    }

}

Code Walkthrough:

@ Test(findElementByName): In this case, we are first locating the web element for the Name text box and entering a value in the same. Later, we are locating the web element for the Email text box and the entering value in the email text box.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

Find Element by ClassName

The ClassName locator in Selenium finds the elements on the web page based on the CLASS attribute value. Here the value of the “class” attribute is passed as the locator.

Syntax to find Element by ClassName:

WebElement elementName = driver.findElement(By.classname(“className”));

Use Case:

Let us see the table pagination demo page of Selenium Playground and write the locator for the dropdown to change the number of rows being displayed to 10.

Locator:

The correct locator value making use of ClassName in the above case would be:

WebElement selectDropdown=driver.findElement(By.className(“form-control”));

Implementation:

Below is the test class file that can be used for implementing the test case.

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxProfile;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.Select;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;

public class automateCaptchaInSelenium {


    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "@hub.lambdatest.com/wd/hub";

    @BeforeClass
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "AutomationUsingFindElement");
        capabilities.setCapability("name", "AutomationUsingFindElementSuite");

        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        Reporter.log("Logging into Selenium Playground", true);

    }

    @Test
    public void findElementByClassName() {
        try {
            System.out.println("Logging into Lambda Test Table Pagination Demo Page");
            driver.get("https://www.lambdatest.com/selenium-playground/table-pagination-demo");

            WebElement selectDropdown=driver.findElement(By.className("form-control"));
            Select select = new Select(selectDropdown);
            select.selectByVisibleText("10");

            System.out.println("Changed the pagination dropdown to 10");
        } catch (Exception e) {

        }

    }


    @AfterClass
    public void closeBrowser() {
        driver.close();
        Reporter.log("Closing the browser", true);

    }

}

Code Walkthrough:

@ Test(findElementByClassName): In this case, we are first locating the web element for the dropdown using ClassName. Later, we are using Select Class for changing the dropdown value to 10 by using the selectByVisibleText option.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

Note: org.junit.runner.FilterFactory.FilterNotCreatedException

It happens when junit filters can’t be created

Find Element by TagName

A tagName is a part of a DOM structure where every element on a page is defined via tags like input tag, button tag or anchor tag, etc. Each tag has multiple attributes like ID, name, value class, etc. The TagName locator in Selenium finds the elements on the web page based on the element.

Syntax to find Element by TagName:

WebElement elementName = driver.findElement(By.tagName(“tagname”));

Use Case:

Let us see the same table pagination demo page of Selenium Playground and write the locator for the dropdown to change the number of rows displayed using the tag name.

Locator:

The correct locator value making use of tag name in the above case would be:

WebElement elementName = driver.findElement(By.tagName(“select”));

Implementation:

Below is the test class file that can be used for implementing the test case.

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxProfile;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.Select;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Reporter;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;

public class automateCaptchaInSelenium {


    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "@hub.lambdatest.com/wd/hub";

    @BeforeClass
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "AutomationUsingFindElement");
        capabilities.setCapability("name", "AutomationUsingFindElementSuite");

        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        Reporter.log("Logging into Selenium Playground", true);

    }

    @Test
    public void findElementByTagName() {
        try {
            System.out.println("Logging into Lambda Test Table Pagination Demo Page");
            driver.get("https://www.lambdatest.com/selenium-playground/table-pagination-demo");

            WebElement selectDropdown=driver.findElement(By.tagName("select"));
            Select select = new Select(selectDropdown);
            select.selectByVisibleText("10");

            System.out.println("Changed the pagination dropdown to 10");
        } catch (Exception e) {

        }

    }


    @AfterClass
    public void closeBrowser() {
        driver.close();
        Reporter.log("Closing the browser", true);

    }

}

Code Walkthrough:

@ Test(findElementByTagName): In this case, we are first locating the web element for the dropdown using TagName. Later, we are using Select Class for changing the dropdown value to 10 by using the selectByVisibleText option.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

Find Element by Link Text

The Link Text locator in Selenium is used to identify the hyperlinks on a web page. It is determined with the help of an anchor tag. For creating the hyperlinks on a web page, we can use an anchor tag followed by the link Text.

Accessing links using their exact link text is done through the findElement by Link Text method. However, if two links have the exact link text, this method will only access the first one.

Syntax to find Element by Link Text:

WebElement elementName= driver.findElement(By.linkText(“link text”));

Use Case:

Let us see the radio button demo page of Selenium Playground and write the locator for the Selenium Playground hyperlink, which is used for navigation to the home page as highlighted below.

Locator:

The correct locator value making use of link text in the above case would be

WebElement seleniumPlaygroundLink= driver.findElement(By.linkText(“Selenium Playground”));

Implementation:

Below is the test class file which can be used for implementing the case.

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.Select;
import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class AutomationUsingFindElement {

    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "@hub.lambdatest.com/wd/hub";

    @BeforeTest
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "AutomationUsingFindElement");
        capabilities.setCapability("name", "AutomationUsingFindElementSuite");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

    }

    @Test
    public void findElementByLinkText() {
        try {
            System.out.println("Logging into Lambda Test Radio Button Demo Page");
            driver.get("https://www.lambdatest.com/selenium-playground/radiobutton-demo");

            WebElement seleniumPlaygroundLink= driver.findElement(By.linkText("Selenium Playground"));
            seleniumPlaygroundLink.click();
            System.out.println("Clicked on the Selenium Playground Navigation Link");


        } catch (Exception e) {

        }

    }


    @AfterTest
    public void closeBrowser() {
        driver.close();
        System.out.println("The driver has been closed.");

    }

}

Code Walkthrough:

@ Test(findElementByLinkText): In this case, we are first locating the web element for the navigation link to the main Selenium Playground page using Link Text and later, click on the same.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

Find Element by Partial Link Text

Accessing links using a portion of their link text is done using the By.partialLinkText() method. If you specify a partial link text that has multiple matches, only the first match will be accessed.

Syntax to find Element by Partial Link Test:

WebElement elementName= driver.findElement(By.partialLinkText(“partial link text”));

Use Case:

Let us see the same radio button demo page of Selenium Playground and write the locator for the Selenium Playground hyperlink, which is used for navigating to the home page as highlighted below. However, this time we will make use of the partial link text.

Locator:

The correct locator value making use of link text in the above case would be:

WebElement seleniumPlaygroundLink= driver.findElement(By.partialLinkText(“Playground”));

Implementation:

Below is the test class file which can be used for implementing the case.

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.Select;
import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class AutomationUsingFindElement {

    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "@hub.lambdatest.com/wd/hub";

    @BeforeTest
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "AutomationUsingFindElement");
        capabilities.setCapability("name", "AutomationUsingFindElementSuite");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }


    @Test
    public void findElementByPartialLinkText() {
        try {
            System.out.println("Logging into Lambda Test Radio Button Demo Page");
            driver.get("https://www.lambdatest.com/selenium-playground/radiobutton-demo");

            WebElement seleniumPlaygroundLink= driver.findElement(By.partialLinkText("Playground"));
            seleniumPlaygroundLink.click();
            System.out.println("Clicked on the Selenium Playground Navigation Link");
        } catch (Exception e) {

        }

    }

    @AfterTest
    public void closeBrowser() {
        driver.close();
        System.out.println("The driver has been closed.");

    }

}

Code Walkthrough:

@ Test(findElementByPartialLinkText): In this case, we are first locating the web element for the navigation link to the main Selenium Playground page using Partial Link Text and later, click on the same.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

Find Element by CSS Selector

CSS Selectors are one of the locator strategies used in Selenium to identify the web elements. The CSS Selectors locator in Selenium mainly uses the character sequence pattern, which identifies the web elements based on their HTML structure. Locating an element using a CSS selector in Selenium may seem a little more difficult than using attributes like id, name, link, etc. Still, it’s one of the most efficient strategies to locate dynamic elements that don’t have consistent HTML attributes. CSS Selector syntax is quite similar to the XPath syntax. It can be represented as follows.

Node[attribute name=”attribute value”]

Let us now see the syntax of using a CSS selector with the findElement in Selenium.

Syntax to find Element by CSS Selector:

WebElement elementName= driver.findElement(By.cssSelector(“css selector”));

Use Case:

Let us see the single checkbox demo page of Selenium Playground and write the CSS selector for the checkbox, and later use the same in locating the web element using findElement.

Locator:

The correct locator value making use of CSS selector in the above case would be:

WebElement checkbox= driver.findElement(By.cssSelector(“input[id='isAgeSelected']”));

Implementation:

Below is the test class file which can be used for implementing the case.

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.Select;
import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class AutomationUsingFindElement {

    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "@hub.lambdatest.com/wd/hub";

    @BeforeTest
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "AutomationUsingFindElement");
        capabilities.setCapability("name", "AutomationUsingFindElementSuite");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }



    @Test
    public void findElementByCSSSelector() {
        try {
            System.out.println("Logging into Lambda Test Checkbox Demo Page");
            driver.get("https://www.lambdatest.com/selenium-playground/checkbox-demo");

            WebElement checkbox= driver.findElement(By.cssSelector("input[id='isAgeSelected']"));
            checkbox.click();
            System.out.println("Clicked on the Single Checkbox button");

            WebElement successMessage=driver.findElement(By.id("txtAge"));
            String expectedMessage=successMessage.getText();

            Assert.assertEquals("Success - Check box is checked", expectedMessage);
        } catch (Exception e) {

        }

    }



    @AfterTest
    public void closeBrowser() {
        driver.close();
        System.out.println("The driver has been closed.");

    }

}

Code Walkthrough:

@ Test(findElementByCSSSelector): In this case, we are first locating the web element for the checkbox using CSS selector and then clicking on it. Later, we locate the success message and validate if it appears correctly after clicking on the checkbox.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

Find Element by XPath

Also known as XML Path, the XPath locator in Selenium is one of the most commonly used locators in Selenium WebDriver that can help you navigate through the HTML structure of a page.

The basic format of XPath in Selenium is explained below.

XPath = //tagname[[@Attribute](http://twitter.com/Attribute)=’Value’]

Let us now see the syntax of using XPaths with find elements in Selenium.

Syntax to find Elements by XPath:

WebElement elementName= driver.findElement(By.xpath(“xpath”));

Use Case to find Element by XPath:

Let us see the same example as we saw in the CSS selector, single checkbox demo page of Selenium Playground, and write the XPath for the checkbox.

Locator:

The correct locator value making use of XPath in the above case would be

WebElement checkbox= driver.findElement(By.xpath(“//input[[@id](http://twitter.com/id)='isAgeSelected']”));

Implementation:

Below is the test class file which can be used for implementing the case.

package LambdaTest;

    import io.github.bonigarcia.wdm.WebDriverManager;
    import org.openqa.selenium.By;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.chrome.ChromeDriver;
    import org.openqa.selenium.remote.DesiredCapabilities;
    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.testng.Assert;
    import org.testng.annotations.AfterTest;
    import org.testng.annotations.BeforeTest;
    import org.testng.annotations.Listeners;
    import org.testng.annotations.Test;
    import org.openqa.selenium.support.ui.Select;
    import java.net.MalformedURLException;
    import java.net.URL;

    @Listeners({util.Listener.class})
    class AutomationUsingFindElement {

        public String username = "YOUR USERNAME";
        public String accesskey = "YOUR ACCESSKEY";
        public static RemoteWebDriver driver = null;
        public String gridURL = "@hub.lambdatest.com/wd/hub";

        @BeforeTest
        public void setUp() throws Exception {
            DesiredCapabilities capabilities = new DesiredCapabilities();
            capabilities.setCapability("browserName", "chrome");
            capabilities.setCapability("version", "96.0");
            capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
            capabilities.setCapability("build", "AutomationUsingFindElement");
            capabilities.setCapability("name", "AutomationUsingFindElementSuite");
            try {
                driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
            } catch (MalformedURLException e) {
                System.out.println("Invalid grid URL");
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }


        @Test
        public void findElementByXPath() {
            try {
                System.out.println("Logging into Lambda Test Checkbox Demo Page");
                driver.get("https://www.lambdatest.com/selenium-playground/checkbox-demo");

                WebElement checkbox= driver.findElement(By.xpath("//input[@id='isAgeSelected']"));
                checkbox.click();
                System.out.println("Clicked on the Single Checkbox button");

                WebElement successMessage=driver.findElement(By.id("txtAge"));
                String expectedMessage=successMessage.getText();

                Assert.assertEquals("Success - Check box is checked", expectedMessage);
            } catch (Exception e) {

            }

        }

        @AfterTest
        public void closeBrowser() {
            driver.close();
            System.out.println("The driver has been closed.");

        }

    }

Code Walkthrough:

@ Test(findElementByCSSSelector): In this case, we are first locating the web element for the checkbox using XPath and then clicking on it. Later, we locate the success message and validate if it appears correctly after clicking on the checkbox.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

Use Case to find Elements by XPath:

Let us see an implementation using findElements as well.

Locator:

When we inspect the section headers using XPath, we see that multiple elements are being returned making use of the same XPath. Hence, in such cases, it would be appropriate to use findElements.

List<WebElement> sectionHeaders= driver.findElements(By.xpath(“//h2[[@class](http://twitter.com/class)='st_heading']”));

Implementation:

Below is the test class file which can be used for implementing the case.

package LambdaTest;

    import io.github.bonigarcia.wdm.WebDriverManager;
    import org.openqa.selenium.By;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.chrome.ChromeDriver;
    import org.openqa.selenium.remote.DesiredCapabilities;
    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.testng.Assert;
    import org.testng.annotations.AfterTest;
    import org.testng.annotations.BeforeTest;
    import org.testng.annotations.Listeners;
    import org.testng.annotations.Test;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.List;

    @Listeners({util.Listener.class})
    class AutomationUsingFindElement {

        public String username = "YOUR USERNAME";
        public String accesskey = "YOUR ACCESSKEY";
        public static RemoteWebDriver driver = null;
        public String gridURL = "@hub.lambdatest.com/wd/hub";

        @BeforeTest
        public void setUp() throws Exception {
            DesiredCapabilities capabilities = new DesiredCapabilities();
            capabilities.setCapability("browserName", "chrome");
            capabilities.setCapability("version", "96.0");
            capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
            capabilities.setCapability("build", "AutomationUsingFindElement");
            capabilities.setCapability("name", "AutomationUsingFindElementSuite");
            try {
                driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
            } catch (MalformedURLException e) {
                System.out.println("Invalid grid URL");
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }

        @Test
        public void findElementsByXPath() {
            try {
                System.out.println("Logging into Lambda Test Selenium Playground Page");
                driver.get("https://www.lambdatest.com/selenium-playground/");

                List<WebElement> sectionHeaders= driver.findElements(By.xpath("//h2[@class='st_heading']"));
                for(WebElement e: sectionHeaders){
                    System.out.println("The list of headers are:"+e.getText());
                }
            } catch (Exception e) {

            }

        }

        @AfterTest
        public void closeBrowser() {
            driver.close();
            System.out.println("The driver has been closed.");

        }

    }

Code Walkthrough:

@ Test(findElementsByXPath): In this case, we are locating the section headers using XPath and storing them in a list of web elements. Later, we iterated through the list and printed their text.

The remaining areas remain the same as we did in the Code Walkthrough of our first example.

List<WebElement> sectionHeaders= driver.findElements(By.xpath("//h2[[@class](http://twitter.com/class)='st_heading']"));
                for(WebElement e: sectionHeaders){
                    System.out.println("The list of headers are:"+e.getText());

Console Output:

Once you run the above test case, your console output would look something like below.

Once the tests are completed, you can also view your test results, logs, and the test recording as well in your LambdaTest Automation Dashboard.

Upon completion of the test, test results will be displayed on the LambdaTest Analytics Dashboard. The dashboard shows all the details and metrics related to your tests.

Navigate to the LambdaTest Analytics Dashboard to view the metrics of your tests. The Test Overview will allow you to quickly assess test performance and overall health. Meanwhile, the Test Summary will show how many passes and fails your team has run and the overall efficacy of these tests.

If you’re a developer who’s looking to take your development and test engineering skills to the next level, this Selenium 101 certification from LambdaTest can help you reach that goal.

Here’s a short glimpse of the Selenium 101 certification from LambdaTest:

Conclusion

In this article on the difference between findElement and findElements in Selenium, we learned about what is findElement and findElements in Selenium Java and had a glance at their major differences. We also saw the various implementations of findElement using ID, Name, ClassName, TagName, etc. In the end, we also implemented a use case using findElements.

Hope you enjoyed reading this article and learned something new about Find Element.

Happy Testing!!

How To Handle Multiple Windows In Selenium WebDriver Using Java?

Riadayal — Wed, 06 Apr 2022 11:00:23 +0000

When automating any website or a web application in Selenium, you might have come across a scenario where multiple windows open within an application when a button is clicked, and appropriate action needs to be performed on the opened windows. Alas, you might not be in a position to work on all windows at the same time. Hence there is a need for some mechanism through which you can gain control over the parent and child windows.

In this Selenium Java tutorial, we will understand what Windows are and how to handle multiple windows in Selenium WebDriver using Java.

Starting your journey with Selenium WebDriver? Check out this step-by-step guide to perform Automation testing using Selenium WebDriver.

Let’s get started!!

What is a Window in Selenium?

A window in any browser is the main web page on which the user lands after hitting a URL. Such a window in Selenium is referred to as the Parent Window or Main Window. It opens when the Selenium WebDriver session is created and has all the focus of the WebDriver.

For example, when you open any website or link, the page you land in is the Main Window.
Here, I am logging into the Selenium Playground offered by LambdaTest, and the below-shown window is the Main Window.

LambdaTest is a cloud-based cross browser testing platform that supports Selenium Grid, providing a solution to every obstacle you face while performing automation testing on your local machine. Automation testing tools like LambdaTest offer a cloud-based Selenium Grid consisting of an online device farm of 3000+ real browsers and operating systems for you to perform Selenium automation testing at scale.

How to identify parent and child windows in Selenium?

As discussed in the above section of this blog on how to handle multiple windows in Selenium WebDriver using Java, when you open any website, the main page where you will perform any operation is the Parent Window. This is the same webpage that will open when the Selenium automation script is executed.

Now, all the other windows that open inside your main window are termed as Child Windows. In order to understand this better, let’s log in to the Selenium Playground and use the Window Popup Model option.

Once you click on the Window Popup Model option, the page you land in is the Parent Window, and the window which opens by clicking on Follow On Twitter option is the Child Window.

It is important to note that there can be single or multiple child windows inside your parent window.

What is Window Handle in Selenium?

Now that you have understood the concept of Windows in Selenium let’s look at how to control these different browser windows. This is where the Window Handle comes into the picture.

A window handle stores the unique address of the browser windows. It is just a pointer to a window whose return type is alphanumeric. The window handle in Selenium helps in handling multiple windows and child windows. Each browser window has a unique window handle value through which it can be identified.

In the previous section of this article on how to handle multiple windows in Selenium WebDriver using Java, when a new window was opened by clicking on the Follow On Twitter option, it had its Window Handle (or ID). This helps to switch the Selenium WebDriver context to the corresponding window and perform any operation.

Note: Selenium WebDriver 4 is a major architectural update in Selenium 4. WebDriver is the de facto standard for automating web browsers, enabling you to run automated tests on a variety of browsers. Follow along with this video to learn what’s new in Selenium 4.

You can follow the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress testing, CI/CD, and more.

What are the different methods used for window handling in Selenium?

Let’s see what are the different methods through which we can handle these windows in Selenium. Selenium WebDriver provides us with various methods for handling windows. Below are a few of them:

getWindowHandle(): With this method, we get a unique ID of the current window which will identify it within this driver instance. This method will return the value of the String type.
getWindowHandles( ): With this method, we get the IDs of all the windows opened by the web driver. Its return type is Set .
switchTo(): Using this method, we can perform switch operations within windows.

How to handle a single child window in Selenium?

Let us now implement a code snippet for handling the single-child window in Selenium.

Use Case

Log in to the Window Popup Modal Demo page of Selenium Playground.
Click on Follow On Twitter option in the Single Window Popup section
Switch to the child window opened
Print the header of the web page.

Implementation

We will implement the case using Selenium with Java and use the cloud Selenium grid offered by LambdaTest for executing our test case.

Selenium Grid refers to a software testing setup that enables QAs to perform parallel tests across multiple browsers and devices with unique operating systems. When the entire setup of Selenium Grid is accessible using cloud-based servers, it is called Selenium Grid on Cloud. An online Selenium Grid helps you focus on writing better Selenium test scripts rather than worrying about infrastructure maintenance.

MultipleWindowsInSelenium.java

package LambdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.Reporter;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.Iterator;
import java.util.Set;

[@Listeners](http://twitter.com/Listeners)({util.Listener.class})
class MultipleWindowsInSelenium {


    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

    [@BeforeTest](http://twitter.com/BeforeTest)
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "96.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "MultipleWindowsInSelenium");
        capabilities.setCapability("name", "MultipleWindowsInSeleniumTest");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        driver.get("[https://www.lambdatest.com/selenium-playground/window-popup-modal-demo](https://www.lambdatest.com/selenium-playground/window-popup-modal-demo)");

    }


    [@Test](http://twitter.com/Test)
    public void singleWindowPopUp() {
        try {
            //Clicks on the follow on twitter option
            WebElement followOnTwitter = driver.findElement(By.xpath("//a[text()='  Follow On Twitter ']"));
            followOnTwitter.click();

            // To handle parent window
            String MainWindow = driver.getWindowHandle();
            System.out.println("Main window handle is " + MainWindow);

            // To handle child window
            Set<String> s1 = driver.getWindowHandles();
            System.out.println("Child window handle is" + s1);
            Iterator<String> i1 = s1.iterator();
            while (i1.hasNext()) {
                String ChildWindow = i1.next();
                if (!MainWindow.equalsIgnoreCase(ChildWindow)) {
                    driver.switchTo().window(ChildWindow);
                    String pageTitle=driver.getTitle();
                    System.out.println("The web page title of child window is:"+pageTitle);
                    driver.close();
                    System.out.println("Child window closed");
                }
            }

        } catch (Exception e) {

        }

    }

    [@AfterTest](http://twitter.com/AfterTest)
    public void closeBrowser() {
        driver.quit();
        Reporter.log("The driver has been closed.", false);

    }

}

You can use the below testng.xml file for running the above testcase.

testng.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "[http://testng.org/testng-1.0.dtd](http://testng.org/testng-1.0.dtd)">
<suite  name="MultipleWindowsInSeleniumSuite">

    <test name="MultipleWindowsInSeleniumTest" >
        <classes>
            <class name="LambdaTest.MultipleWindowsInSelenium" >
            </class>
        </classes>
    </test>
</suite>

And the below pom.xml file for installing all the necessary dependencies.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0)"
         xmlns:xsi="[http://www.w3.org/2001/XMLSchema-instance](http://www.w3.org/2001/XMLSchema-instance)"
         xsi:schemaLocation="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0) [http://maven.apache.org/xsd/maven-4.0.0.xsd](http://maven.apache.org/xsd/maven-4.0.0.xsd)">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>LambdaTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-api</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-remote-driver</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-chrome-driver</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.14.3</version>
        </dependency>
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>4.4.3</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

Code Walkthrough

Let us now see the different areas of code in detail.

Imported Dependencies: Here, we have imported all the necessary classes of Selenium WebDriver, WebDriverWait, Desired Capabilities, and RemoteWebDriver to set the respective browser capabilities and run Selenium IDE tests on cloud grid.

2. Global Variables: As we have used a Selenium Grid Cloud like LamdaTest to perform our test execution, we are using the below-shown variables.

We have also used the Java Listener class here in order to customize the TestNG Report. TestNG provides us with a lot of Listeners (e.g., IAnnotationTransformer, IReporter, etc.). These interfaces are used while performing Selenium automation testing mainly to generate logs and customize the TestNG reports.

To implement the Listener class, you can simply add an annotation in your test class just above your class name.

Syntax:

[@Listeners](http://twitter.com/Listeners)(PackageName.ClassName.class)

3. @BeforeTest(Setup Method): Here, we have used the LambdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc., for our Selenium Remote WebDriver. After that, we are opening the Window Popup Demo Page in the launched browser.

4. @test(singleWindowPopup): Here, we are first locating the Web Element for Follow On Twitter option and clicking on it.

In the next step, we store the handles of all the opened windows in a Set of String.

Now, we start iterating over the set of window handles we have by using the driver.switchTo() method, we switch to the child window. After switching to the child window, we print the web page title and close the same.

5. @AfterTest(closeBrowser): Here, we are just closing the launched browser.

Once the tests are completed, you can also view your test results, logs, and the test recording as well in your LambdaTest Automation Dashboard.

With LambdaTest, you can see how your automated browser testing efforts are going. You’ll get real-time reports on the performance of your test suites and an automated system to track change impact across all your automation efforts. You can use LambdaTest Analytics to get insight into this information and drive better testing practices.

Console Output

Once you run the test case, the console output will look something like below:

Note: org.openqa.selenium.remote.ScreenshotException

This exception raised by selenium webdriver when the selenium is unable to take the screenshot or capture the current screen.

How to handle multiple child windows in Selenium?

When it comes to handling multiple child windows in Selenium, the overall process remains the same as we do for a single child window. However, in the case of multiple child windows, you can use any of the available conditional operators like if-else, switch etc. and do the operations, which are particular to each child window.

Let us write our script for handling one of such scenarios.

Use Case

Log in to the Window Popup Modal Demo page of Selenium Playground.
Click on Follow On Twitter and Facebook in the Multiple Window Popup section.
Switch to each of the child windows opened.
Click on the Sign Up button for Facebook Window.
Click on the Sign Up button for Twitter Window.

Implementation

MultipleWindowsInSelenium.java

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.Reporter;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import org.testng.reporters.jq.Main;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.Iterator;
import java.util.Set;

[@Listeners](http://twitter.com/Listeners)({util.Listener.class})
class MultipleWindowsInSelenium {


    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

    [@BeforeTest](http://twitter.com/BeforeTest)
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "97.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "MultipleWindowsInSelenium");
        capabilities.setCapability("name", "MultipleWindowsInSeleniumTest");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        driver.get("[https://www.lambdatest.com/selenium-playground/window-popup-modal-demo](https://www.lambdatest.com/selenium-playground/window-popup-modal-demo)");

    }


    [@Test](http://twitter.com/Test)
    public void multipleWindowPopUp() {
        try {
            //Clicks on the follow on twitter and facebook option
            WebElement followOnTwitterAndFacebook = driver.findElement(By.xpath("//a[text()='Follow Twitter & Facebook']"));
            followOnTwitterAndFacebook.click();

            // To handle parent window
            String MainWindow = driver.getWindowHandle();
            System.out.println("Main window handle is " + MainWindow);

            // To handle child window
            Set<String> s1 = driver.getWindowHandles();
            System.out.println("Child window handle is" + s1);
            Iterator<String> i1 = s1.iterator();
            while (i1.hasNext()) {
                String ChildWindow = i1.next();
                if (!MainWindow.equalsIgnoreCase(ChildWindow)) {
                    driver.switchTo().window(ChildWindow);
                    String pageTitle=driver.getTitle();
                    System.out.println("The web page title of child window is:"+pageTitle);
                    if(pageTitle.contains("Facebook")){
                        WebElement signUpForFB= driver.findElement(By.xpath("//span[text()='Create New Account']"));
                        signUpForFB.click();
                        System.out.println("Clicked on Login Option For Facebook");
                    }else if(pageTitle.contains("Twitter")){
                        WebElement signUpForTwitter= driver.findElement(By.xpath("//span[text()='Sign up for Twitter']"));
                        signUpForTwitter.click();
                        System.out.println("Clicked on Follow Option For Twitter");
                    }
                }
            }

        } catch (Exception e) {
               e.printStackTrace();
        }

    }

    [@AfterClass](http://twitter.com/AfterClass)
    public void closeBrowser() {
        driver.quit();
        System.out.println("Closing the browser");
    }
}

Code Walkthrough

In this case, the process of iterating the child windows is exactly the same as how we did it in the case of a single child window. However, here we are distinguishing the windows respective to Facebook and Twitter by making use of their corresponding titles and by making use of if-else statements, we are clicking on their respective Sign Up buttons.

Console Output

Once you run the test case, the console output will look something like below:

How to switch back from child window to parent window in Selenium?

You saw how we switch to a child window from the parent window. Now, once the WebDriver has control of the child window, it has control only on that and you can no longer perform any operation in the parent window. So how do we switch back to the parent window in case we need to?

This can be simply done by using the **switchTo() **function. This function helps in shifting the focus back to the parent window.

Use Case

Let us see how to implement the switchTo*()* function. We will implement the same use case as discussed in the last section of this article on how to handle multiple windows in Selenium WebDriver using Java.

Implementation

MultipleWindowsInSelenium.java

package LambdaTest;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.Reporter;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import org.testng.reporters.jq.Main;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.Iterator;
import java.util.Set;

[@Listeners](http://twitter.com/Listeners)({util.Listener.class})
class MultipleWindowsInSelenium {


    public String username = "YOUR USERNAME";
    public String accesskey = "YOUR ACCESSKEY";
    public static RemoteWebDriver driver = null;
    public String gridURL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

    [@BeforeTest](http://twitter.com/BeforeTest)
    public void setUp() throws Exception {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "97.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "MultipleWindowsInSelenium");
        capabilities.setCapability("name", "MultipleWindowsInSeleniumTest");
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

    }


    [@Test](http://twitter.com/Test)
    public void switchToParentWindow() {
        try {
            //Clicks on the follow on twitter option
            WebElement followOnTwitter = driver.findElement(By.xpath("//a[text()='  Follow On Twitter ']"));
            followOnTwitter.click();

            // To handle parent window
            String MainWindow = driver.getWindowHandle();
            System.out.println("Main window handle is " + MainWindow);

            // To handle child window
            Set<String> s1 = driver.getWindowHandles();
            System.out.println("Child window handle is" + s1);
            Iterator<String> i1 = s1.iterator();
            while (i1.hasNext()) {
                String ChildWindow = i1.next();
                if (!MainWindow.equalsIgnoreCase(ChildWindow)) {
                    driver.switchTo().window(ChildWindow);
                    String pageTitle=driver.getTitle();
                    System.out.println("The web page title of child window is:"+pageTitle);
                    driver.close();
                    System.out.println("Child window closed");
                }
            }
            System.out.println("Switched back to parent window");
            driver.switchTo().window(MainWindow);
            driver.close();

        } catch (Exception e) {

        }

    }

}

Code Walkthrough

In this test case, after navigating to the child window and closing it. We specifically switch back to the parent window and close that too, and as a result, we don’t need to close the browser again after the test.

Console Output

Once you run the test case, the console output will look something like below:

Note: org.openqa.selenium.ScriptTimeoutException

The WebDriver error — script timeout error happens when a user script fails to complete before the script timeout duration of the session expires.

The script timeout duration is a configurable capability — meaning you can change how long it takes for the driver to interrupt an injected script. The driver will wait up to 30 seconds, by default, before interrupting the script and returning with a script timeout error. This can be modified to be longer, shorter, or indefinite.

If the session script timeout duration is set to null, the timeout duration to becomes indefinite, and there is a risk of a non-recoverable session state.

How to close all windows while handling multiple windows in Selenium?

While we are handling multiple windows in Selenium, it is very important to understand how you can actually close the windows.

As you saw in the above example, in order to close the parent window, we had to explicitly switch to the parent window and then close it using the driver.close() method. The driver.close() method helps us to close the driver, which is being controlled at the moment. But what if we want to close all the opened windows at once?

In such cases, the method which can come in handy is the driver.quit(). The driver.quit() method closes all the open windows regardless of where the control is lying.

So now you know what to use when you want to tackle all the open windows at once! 🙂

This certification demonstrates your knowledge of Selenium and Java, and your expertise at automating tests for any project.

Here’s a short glimpse of the Selenium Java 101 certification from LambdaTest:

Conclusion

In this article on how to handle multiple windows in Selenium WebDriver using Java, we read about Windows in Selenium. We saw what are Parent and Child Windows and how we can handle them using their corresponding Window Handles. We also implemented the automation script for handling both single and multiple child windows. Additionally, we learned about switching back to the parent window, and the trick of closing all the opened windows at once.

I hope you enjoyed reading this article on how to handle multiple windows in Selenium WebDriver using Java, and it helps you in handling multiple windows for your Selenium automation 🙂

Happy Testing !!

How To Find Element By Text In Selenium WebDriver

Riadayal — Tue, 05 Apr 2022 17:18:10 +0000

Find element by Text in Selenium is used to locate a web element using its text attribute. The text value is used mostly when the basic element identification properties such as ID or Class are dynamic in nature, making it hard to locate the web element.

Sometimes, developers tend to group similar web elements with the same ID or the same Class together. For example, if you have an element with the tag as Button which has a dynamic ID and Class name, where ID is getting changed from ‘ID-3465-text1’ to ‘ID-4434-textE2,’ and the Class name gets changed from “ID-Class-text45” to “ID-Class-text73” on every new session.

In such cases, it becomes very difficult to locate the web elements using ID or Class attribute, and this is when the Text attribute comes to the rescue while performing Selenium automation testing.

The text value can be fully matched or partially matched to locate the element. In this article on how to find element by text in Selenium WebDriver, you will read about how to use the Text attribute in order to find any element.

Let’s get started!

What is Find Element In Selenium?

When you start writing your Selenium automation script, interaction with web elements becomes your first and a very vital step because it’s the WebElements that you play around with within your test script. Now, interaction with these web elements can only happen if you identify them using the right approach.

Find Element method in Selenium is a command which helps you identify a web element. There are multiple ways that Find Element provides to uniquely identify a web element within the web page using Web locators in Selenium like ID, Name, Class Name, etc. Here is the syntax of Find Element In Selenium.

The syntax of Find Element is

WebElement elementName= driver.findElement(By.<LocatorStrategy>("LocatorValue"));

ID
Name
Class Name
Tag Name
Link Text
Partial Link Text
XPath
CSS Selector

What is Find Element By Text in Selenium?

We saw in the previous section about find element in Selenium and its syntax. Now, you must be wondering how to find element by text in Selenium WebDriver.

The answer is by making use of XPath in Selenium!!

Wondering how? Let’s look at the sections below.

In order to use Text, you will need to make use of XPath as your Locator Strategy and the text attribute of the element in the Locator Value.

The basic format of XPath in Selenium is as below.

XPath = //tagname[[@Attribute](http://twitter.com/Attribute)=’Value’]

However, before we get started, it’s important to understand two built-in methods of Selenium, which will ultimately be used in findElement.

1. text() — This is a built-in method in Selenium that is used with XPath in order to locate an element based on its exact text value. The syntax of using text() with findElement is:

WebElement ele = driver.findElement(By.xpath(“//<tagName>[text()=’text value’]”))

2. contains() — Similar to the text() method, contains() is another built-in method which is used with XPath. However, this is used when we want to write the locator based on a partial text match. The syntax of using text() & contains() with findElement is:

WebElement ele=driver.findElement(By.xpath(“//<tagName>[contains(text(),’textvalue’)]”))

Let us now read about these in detail.

Note: The ConnectionClosedException occured whenever connection between driver and client has been lost and client is sending the request to the driver after disconnecting the driver.

Find Element by Text in Selenium for Complete Text match

Now that you saw the syntax for using text() in case of complete text match. In this section on how to find element by text in Selenium, let us see it using an example.

We will use Selenium Playground offered by LambdaTest for understanding the same. LambdaTest is a cloud-based cross browser testing platform that supports Selenium Grid, providing a solution to every obstacle you face while performing automation testing using your local machine. Test Automation Platforms like LambdaTest offer a Selenium Grid consisting of 3000+ online browsers for you to perform Selenium automation testing effortlessly.

Use Case

Log in to Selenium Playground.
Identify the Web Element for the Checkbox Demo link on the above web page using the text() method.
Click on it and print the page header.

Implementation

We will implement the case using Selenium with Java and use the cloud Selenium Grid offered by LambdaTest for executing our test case.
Selenium Grid refers to a software testing setup that enables QAs to perform parallel testing across multiple browsers and devices with unique operating systems. When the entire setup of Selenium Grid is accessible using cloud-based servers, it is called Selenium Grid Cloud. An online Selenium Grid helps you focus on writing better Selenium test scripts rather than worrying about infrastructure maintenance.

Let us now inspect the locator for the Checkbox Demo page. In order to inspect, you can simply right-click on the Web Element and click on Inspect. On the Elements tab, you can start writing your locator.

As shown in the above picture, we use the Checkbox Demo text with its tag a for a complete match, and hence, the correct implementation here would be:

WebElement checkbox= driver.findElement(By.xpath(“//a[text()=’Checkbox Demo’]”))

Let us now use the same and write our test case.

You can refer to the below testcase.

package LambdaTest;

    import org.openqa.Selenium.By;
    import org.openqa.Selenium.WebElement;
    import org.openqa.Selenium.remote.DesiredCapabilities;
    import org.openqa.Selenium.remote.RemoteWebDriver;
    import org.testng.Assert;
    import org.testng.annotations.AfterTest;
    import org.testng.annotations.BeforeTest;
    import org.testng.annotations.Listeners;
    import org.testng.annotations.Test;

    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.List;

    [@Listeners](http://twitter.com/Listeners)({util.Listener.class})
    class AutomationUsingFindElementByText {

        public String username = "YOUR USERNAME";
        public String accesskey = "YOUR ACCESSKEY";
        public static RemoteWebDriver driver = null;
        public String gridURL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

        [@BeforeTest](http://twitter.com/BeforeTest)
        public void setUp() throws Exception {
           DesiredCapabilities capabilities = new DesiredCapabilities();
            capabilities.setCapability("browserName", "chrome");
            capabilities.setCapability("version", "96.0");
            capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
            capabilities.setCapability("build", "AutomationUsingFindElement");
            capabilities.setCapability("name", "AutomationUsingFindElementSuite");
            try {
                driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
            } catch (MalformedURLException e) {
                System.out.println("Invalid grid URL");
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }



        [@Test](http://twitter.com/Test)
        public void findElementByCompleteTextMatch() {
            try {
                System.out.println("Logging into Lambda Test Selenium Playground");
                driver.get("[http://labs.lambdatest.com/Selenium-playground/](http://labs.lambdatest.com/Selenium-playground/)");

                WebElement checkBoxDemoPage= driver.findElement(By.xpath("//a[text()='Checkbox Demo']"));
                checkBoxDemoPage.click();
                System.out.println("Clicked on the Checkbox Demo Page");

                WebElement header=driver.findElement(By.xpath("//h1"));
                System.out.println("The header of the page is:"+header.getText());
            } catch (Exception e) {

            }

        }


        [@AfterTest](http://twitter.com/AfterTest)
        public void closeBrowser() {
            driver.close();
            System.out.println("The driver has been closed.");

        }

    }

You can use the below testng.xml file for running the above testcase.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "[http://testng.org/testng-1.0.dtd](http://testng.org/testng-1.0.dtd)">
<suite  name="AutomationUsingFindElementSuite">

    <test name="AutomationUsingFindElementTest" >
        <classes>
            <class name="LambdaTest.AutomationUsingFindElementByText" >
            </class>
        </classes>
    </test>
</suite>

And the below pom.xml file for installing all the necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0)"
         xmlns:xsi="[http://www.w3.org/2001/XMLSchema-instance](http://www.w3.org/2001/XMLSchema-instance)"
         xsi:schemaLocation="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0) [http://maven.apache.org/xsd/maven-4.0.0.xsd](http://maven.apache.org/xsd/maven-4.0.0.xsd)">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>LambdaTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.Seleniumhq.Selenium</groupId>
            <artifactId>Selenium-api</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.Seleniumhq.Selenium</groupId>
            <artifactId>Selenium-remote-driver</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.Seleniumhq.Selenium</groupId>
            <artifactId>Selenium-chrome-driver</artifactId>
            <version>4.0.0-alpha-7</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.14.3</version>
        </dependency>
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>4.4.3</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

Code Walkthrough

In this section on how to find element by text in Selenium, let’s look at the different areas of code in detail.

Imported Dependencies: Here, we have imported all the necessary classes of Selenium WebDriver, WebDriverWait, Desired Capabilities, and RemoteWebDriver to set the respective browser capabilities and run the test cases on the grid.

2. Global Variables: As we have used a Selenium Grid Cloud like LambdaTest to perform our test execution, we are using the below-shown variables.

We have also used the Listener class here in order to customize the TestNG Report. TestNG provides us with a lot of Listeners (e.g., IAnnotationTransformer, IReporter, etc.). These interfaces are used while performing Selenium automation testing mainly to generate logs and customize the TestNG reports.

To implement the Listener class, you can simply add an annotation in your test class just above your class name.
Syntax:

[@Listeners](http://twitter.com/Listeners)(PackageName.ClassName.class)

4. @test(findElementByCompleteTextMatch): In this case, we are first logging into the Selenium Playground web page. After that, we locate the Checkbox Demo button using a complete text match and click on the same. In the end, we are printing the header of the web page.

5. @AfterTest(closeBrowser): Here, we are just closing the launched browser.

Once the tests are completed, you can also view your test results, logs, and the test recording as well in your LambdaTest Automation Dashboard.

Console Output

Once you run the test case, the console output will look something like the below:

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress E2E testing, CI/CD, and more.

Note: The ConnectionFailedException occured when client is not able to establish connection with selenium hub or webdriver endpoints.

Find Element by Text in Selenium for Partial Text match

In the previous example of this article on how to find element by text in Selenium WebDriver, you saw how you could use findElement by Text for a complete text match. In this section, we will understand how we can use partial Text match in order to locate web elements.

Use Case

Log in to Selenium Playground.
Identify all the Web Elements which have a table in their names.
Print the text of all such Web Elements.

Let us see the locator for the above test case.

Implementation

As shown in the above picture, we use the Table text with its tag a for a partial match, and as a result, we get a total of 5 Web Elements using the above locator. Since there are more than 1 Web Element, in this case, we will use FindElements.

FindElements in Selenium returns you the list of web elements that match the locator value, unlike FindElement which returns only a single web element. In case, there are no matching elements within the web page, FindElements returns an empty list.

The syntax of FindElements in Selenium is:

List<WebElement> listName= driver.findElements(By.<LocatorStrategy>(“LocatorValue”))

Hence, the correct implementation using FindElements with partial text match here would be:

List<WebElement> tableOptions=driver.findElements(By.xpath(“//a[contains(text(),’Table’)”)

Let us now use the same and write our test case.

You can refer to the below testcase.

package LambdaTest;

    import org.openqa.Selenium.By;
    import org.openqa.Selenium.WebElement;
    import org.openqa.Selenium.remote.DesiredCapabilities;
    import org.openqa.Selenium.remote.RemoteWebDriver;
    import org.testng.Assert;
    import org.testng.annotations.AfterTest;
    import org.testng.annotations.BeforeTest;
    import org.testng.annotations.Listeners;
    import org.testng.annotations.Test;

    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.List;

    [@Listeners](http://twitter.com/Listeners)({util.Listener.class})
    class AutomationUsingFindElementByText {

        public String username = "YOUR USERNAME";
        public String accesskey = "YOUR ACCESSKEY";
        public static RemoteWebDriver driver = null;
        public String gridURL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

        [@BeforeTest](http://twitter.com/BeforeTest)
        public void setUp() throws Exception {
           DesiredCapabilities capabilities = new DesiredCapabilities();
            capabilities.setCapability("browserName", "chrome");
            capabilities.setCapability("version", "96.0");
            capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
            capabilities.setCapability("build", "AutomationUsingFindElement");
            capabilities.setCapability("name", "AutomationUsingFindElementSuite");
            try {
                driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
            } catch (MalformedURLException e) {
                System.out.println("Invalid grid URL");
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }

        [@Test](http://twitter.com/Test)
        public void findElementByPartialTextMatch() {
            try {
                System.out.println("Logging into Lambda Test Selenium Playground");
                driver.get("[http://labs.lambdatest.com/Selenium-playground/](http://labs.lambdatest.com/Selenium-playground/)");
                List<WebElement> tableOptions= driver.findElements(By.xpath("//a[contains(text(),'Table')]"));
                for(WebElement e: tableOptions){
                    System.out.println("The different options with table in name are:"+e.getText());
                }

            } catch (Exception e) {

            }

        }

        [@AfterTest](http://twitter.com/AfterTest)
        public void closeBrowser() {
            driver.close();
            System.out.println("The driver has been closed.");

        }

    }

You can use the below testng.xml file for running the above testcase.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "[http://testng.org/testng-1.0.dtd](http://testng.org/testng-1.0.dtd)">
<suite  name="AutomationUsingFindElementSuite">

    <test name="AutomationUsingFindElementTest" >
        <classes>
            <class name="LambdaTest.AutomationUsingFindElementByText" >
            </class>
        </classes>
    </test>
</suite>

And the below pom.xml file for installing all the necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

&lt;groupId&gt;org.example&lt;/groupId&gt;
&lt;artifactId&gt;LambdaTest&lt;/artifactId&gt;
&lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;
&lt;dependencies&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.Seleniumhq.Selenium&lt;/groupId&gt;
        &lt;artifactId&gt;Selenium-api&lt;/artifactId&gt;
        &lt;version&gt;4.0.0-alpha-7&lt;/version&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.Seleniumhq.Selenium&lt;/groupId&gt;
        &lt;artifactId&gt;Selenium-remote-driver&lt;/artifactId&gt;
        &lt;version&gt;4.0.0-alpha-7&lt;/version&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.Seleniumhq.Selenium&lt;/groupId&gt;
        &lt;artifactId&gt;Selenium-chrome-driver&lt;/artifactId&gt;
        &lt;version&gt;4.0.0-alpha-7&lt;/version&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.testng&lt;/groupId&gt;
        &lt;artifactId&gt;testng&lt;/artifactId&gt;
        &lt;version&gt;6.14.3&lt;/version&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;io.github.bonigarcia&lt;/groupId&gt;
        &lt;artifactId&gt;webdrivermanager&lt;/artifactId&gt;
        &lt;version&gt;4.4.3&lt;/version&gt;
    &lt;/dependency&gt;
&lt;/dependencies&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;8&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;8&lt;/maven.compiler.target&gt;
&lt;/properties&gt;



</project>

Code Walkthrough

In this section on how to find element by text in Selenium, let us now check the test case walkthrough in detail. The BeforeTest and import statements remain the same as we saw in our previous example.

@test(findElementByPartialTextMatch): In this case, we are first logging into the Selenium Playground web page. After that, we locate all the Web Elements which have Table in their text and store them in a list. Later, we iterate over the list and print their text.

Once the tests are completed, you can also view your test results, logs, and the test recording as well in your LambdaTest Automation Dashboard.

You can also see the test results on the LambdaTest Analytics Dashboard. The dashboard shows all the details and metrics related to your tests.

Navigate to the LambdaTest Analytics Dashboard to view the metrics of your tests. You can quickly assess test performance and overall health from Test Overview. The Test Summary will show how many passed and failed tests your team has run and the overall efficiency of these tests.

Console Output

Once you run the test case, the console output will look something like the below:

If you’re a developer or a tester and want to take your skills to the next level, this Selenium 101 certification from LambdaTest can help you reach that goal.

Here’s a short glimpse of the Selenium 101 certification from LambdaTest:

Conclusion

In this Selenium Java tutorial on how to find element by text in Selenium WebDriver, we explored finding an element using text in Selenium. We saw how we could use the text() method in case of both complete and partial text matches. We also saw how we could use it in the case of FindElements and get a list of Web Elements through text match. In the end, we also implemented the cases using Selenium with Java on a cloud Selenium Grid.

Honestly, using text() is one of my personal favorite methods in Selenium when it comes to locating Web Elements, as it’s very easy to implement and can be tweaked in any way to match our use case.

I hope you enjoyed reading this article on how to find element by text in Selenium, learned some more about FindElement By Text, and I believe this method will become your personal favorite too. 🙂

Happy Testing!!