DEV Community: Vipulgupta9090

How To Write Test Cases in Java

Vipulgupta9090 — Mon, 12 Aug 2024 09:00:10 +0000

Writing test cases is a fundamental skill for ensuring the reliability and robustness of your code. Test cases can help identify bugs and validate that the code works as intended.

Test cases can be written using any programming language like Java, Python, C#, and more. However, many testers prefer writing test cases in Java due to its strong community support and alignment with project needs. Automating these test cases in Java helps testers save execution time and catch errors in the early stages of testing.

What Is a Test Case in Java?

Java is one of the most used programming languages for automation testing. Writing a test case in Java means building an entire automation project that follows and implements OOP concepts. This makes the project and test case more robust, and the whole code is categorized into many classes and methods, making it more maintainable and easy to use.

Automated test cases help to test the feature quickly in case of regression and help save a lot of manual effort. These test cases execute some flow on the webpage and then use asserts to verify if the output matches the desired output.

For example, For the Two Input Fields section on the LambdaTest Selenium Playground page, a few of the test cases would look like the below:

Verify all the labels, text input boxes, and buttons are present on the page.

Verify that the sum is displayed correctly under Result when entering both numbers.

Verify that the error message is displayed under Result if one or both numbers are not entered.

While writing test cases in Java, several things need to be considered, like the test flow, the test scope, naming, assertions, test data, grouping, locating WebElements, etc. When used accurately, all these make a good test case that is easy to understand and maintain in the future as more changes come.

However, the initial action to start with the test flow is to locate a WebElement for which you must write an effective test case in Java.

Locating WebElements in Java

Another thing to learn about writing test cases in Java is locating the WebElements. This is required as the test case flow will interact with these WebElements to perform actions like entering data, clicking a button, retrieving data, etc., to get the results. There are multiple ways to find the WebElement locators in Selenium, such as ID, Name, CSS, XPath, linkText, etc.

Before demonstrating how to write test cases in Java, let’s learn how different WebElements used in the test flow can be located using their locator strategies. We will use XPath or ID locators to locate all the WebElements for this test case.

You can use one of the most common methods to find elements, i.e., findElement() in Selenium.

To locate the Two Input Fields label from the LambdaTest Selenium Playground page using XPath, you can use the following XPath expression:

driver.findElement(By.xpath("//*[contains(text(),'Two')]"));

To locate the Enter first value label from the LambdaTest Selenium Playground page using XPath, you can use the following XPath expression:

driver.findElement(By.xpath("//*[contains(text(),'first value')]"));

To locate the Enter second value label from the LambdaTest Selenium Playground page using XPath, you can use the following XPath expression:

driver.findElement(By.xpath("//*[contains(text(),'first value')]"));

To locate the Get Sum button from the LambdaTest Selenium Playground page using XPath, you can use the following XPath expression:

driver.findElement(By.xpath("//*[contains(text(),'Sum')]"));

To locate the First value textbox from the LambdaTest Selenium Playground page using ID, you can use the following ID expression:

driver.findElement(By.id("sum1"));

To locate the Second value textbox from the LambdaTest Selenium Playground page using ID, you can use the following ID expression:

driver.findElement(By.id("sum2"));

To locate the Result label from the LambdaTest Selenium Playground page using ID, you can use the following ID expression:

driver.findElement(By.id("user-message"));

To locate the Result/Error Message from the LambdaTest Selenium Playground page using ID, you can use the following ID expression:

driver.findElement(By.id("addmessage"));

You can also refer to this Selenium locator guide to learn how to locate WebElements when writing test cases in Java.

How To Write a Test Case in Java?

Before writing an effective test case in Java, you must set up the project with all the required libraries and tools. We will use Eclipse IDE to demonstrate the setup for a Maven project. Additionally, we will add TestNG as the testing framework to handle test execution and implement setup and teardown methods.

In this demonstration, we will initially write 3 test cases to cover all the test cases in Java mentioned and implement all the best practices as applicable.

Test Scenario 1:

Navigate to the Two Input Fields section on the Selenium Playgrounds (Simple Form Demo)
Assert all the WebElement of this section for visibility

Identify the locator for the Two Input Fields label.
Identify the locator for the **first **and **second **value labels.
Identify the locator for the **first **and **second **value input boxes.
Identify the locator for the Get Sum button.
Result label.

Test Scenario 2 :

Navigate to the Two Input Fields section on the Selenium Playgrounds (Simple Form Demo) page.
Enter valid values in both input boxes.
Click on the Get Sum button.
Assert the sum is correct and displayed under the **Result **label.

Test Scenario 3 :

Navigate to the Two Input Fields section on the Selenium Playgrounds (Simple Form Demo) page.
Enter the value in any one of the input boxes.
Click on the Get Sum button.
The assert error message is displayed under the Result label.

Let’s start installing the necessary libraries as we have the test flow in place and are ready to use the tools and libraries.

Project Setup:

As mentioned, we will use Eclipse IDE to write the test case in Java. However, you can use any IDE to write the test cases. You just need to create a new Maven project.

Launch Eclipse IDE and open the New Project wizard by clicking File > New > Project.
Under Wizards, expand Maven, select Maven Project, and click Next.
Click on Create a simple project checkbox and click on Next.
On this New Maven Project wizard, enter the Group Id and Artifact Id and click on Finish to create your project. Here, Group Id is the unique name that helps identify one project group from another, and Artifact Id is the unique name given to the project we will create.

Once the project is created, the project structure will include a pom.xml file in the root folder. Here, we will add the dependencies needed to write and execute automation test cases in Java. We will add its dependency since we will use TestNG as the testing framework. Additionally, we will add the Selenium dependency, as the test case we will write involves web automation.

You can fetch the latest TestNG and Selenium dependencies from the Maven Repository.

The updated pom.xml would look like the one below.

    <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>demo.lambdaTest</groupId>
     <artifactId>JavaTestCase</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <dependencies>
       <dependency>
         <groupId>org.testng</groupId>
         <artifactId>testng</artifactId>
         <version>7.10.1</version>
         <scope>test</scope>
       </dependency>
       <dependency>
         <groupId>org.seleniumhq.selenium</groupId>
         <artifactId>selenium-java</artifactId>
         <version>4.21.0</version>
       </dependency>
     </dependencies>
    </project>

The next step is to add the test class files where we will write the test case in Java. Add 2 Java class files under src/test/java package.

BaseTest.java: This file will have the setup() and tearDown() methods to create and remove the *WebDriver *instances for test cases.
**TwoInputFieldTests.java: **This file will be the test class file where all the test cases discussed above will be written.

The completed BaseTest.java would look like the one below.

    package LocalGrid;


    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;
    import org.testng.annotations.*;


    public class BaseTest {
       public static WebDriver driver;

       @BeforeMethod
       public void setup()
       {
           driver = new ChromeDriver();

           System.out.println("Navigating to Two Input Field section");
           driver.get("https://www.lambdatest.com/selenium-playground/simple-form-demo");
       }

       @AfterMethod
       public void tearDown()
       {
           driver.quit();
       }
    }

Code Walkthrough:

Below is the complete code walkthrough to understand the code written in the above BaseTest.java file.

In this class, create a WebDriver instance, which will be used to interact with the browser, then create the first method as setup() and annotate it with the @BeforeMethod. @BeforeMethod is a TestNG annotation. This annotation helps invoke this method before executing each test method, i.e., each test case. This will help create a new WebDriver instance for each test case in Java and navigate to the website.

Initialize the driver variable with the ChromeDriver() class. This will execute all the test cases in Java on the Chrome browser.

Use the get() method of Selenium WebDriver to navigate to the test webpage on LambdaTest Playground.

Add the next method, tearDown(), and annotate it with @AfterMethod annotation to execute it after each test case in Java is executed. @AfterMethod is called the quit() method, which quits the driver instance and closes the open browser windows.

With this, the BaseTest file is created, and we are ready to create a test file to run the test case in Java.

Create a file called TwoInputFieldTests.java. This file will contain all the code for the test scenarios discussed earlier.

    package LocalGrid;


    import org.openqa.selenium.By;
    import org.testng.Assert;
    import org.testng.annotations.Test;


    public class TwoInputFieldTests extends BaseTest
    {


       @Test(groups = {"uiTest"})
       public void shouldVerifyAllElementsWhenThePageIsLoaded()
       {
           System.out.println("Verify Two Input Fields title is displayed.");
           Assert.assertTrue(driver.findElement(By.xpath("//*[contains(text(),'Two')]")).isDisplayed());

           System.out.println("Verify enter first value label is displayed.");
           Assert.assertTrue(driver.findElement(By.xpath("//*[contains(text(),'first value')]")).isDisplayed());

           System.out.println("Verify enter first value textbox is displayed.");
           Assert.assertTrue(driver.findElement(By.id("sum1")).isDisplayed());

           System.out.println("Verify enter second value label is displayed.");
           Assert.assertTrue(driver.findElement(By.xpath("//*[contains(text(),'second value')]")).isDisplayed());

           System.out.println("Verify enter second value textbox is displayed.");
           Assert.assertTrue(driver.findElement(By.id("sum2")).isDisplayed());

           System.out.println("Verify Get Sum button is displayed.");
           Assert.assertTrue(driver.findElement(By.xpath("//*[contains(text(),'Sum')]")).isDisplayed());

           System.out.println("Verify result label is displayed.");
           Assert.assertTrue(driver.findElement(By.id("user-message")).isDisplayed());
       }

       @Test(groups = {"positiveTest", "sanity"})
       public void shouldReturnTheResultWhenBothNumbersAreValid()
       {
           System.out.println("entering first value");
           driver.findElement(By.id("sum1")).sendKeys("5");

           System.out.println("entering second value");
           driver.findElement(By.id("sum2")).sendKeys("10");

           System.out.println("click on sum");
           driver.findElement(By.xpath("//*[contains(text(),'Sum')]")).click();

           System.out.println("fetch the result and assert it");
           String result =  driver.findElement(By.id("addmessage")).getText();
           Assert.assertEquals(result, "15", "Sum is incorrect. Expected : 15 but Found : " + result);
       }

       @Test(groups = {"errorTest", "sanity"})
       public void shouldShowErrorWhenAnyNumberIsMissing()
       {
           System.out.println("entering first value");
           driver.findElement(By.id("sum1")).sendKeys("5");

           System.out.println("click on sum");
           driver.findElement(By.xpath("//*[contains(text(),'Sum')]")).click();

           System.out.println("fetch the error message and assert it");
           String errorMessage =  driver.findElement(By.id("addmessage")).getText();
           String expectedError = "Entered value is not a number";
           Assert.assertEquals(errorMessage, expectedError, "Incorrect error message. Expected : " + expectedError + " but Found : " + errorMessage);
       }  
    }
``

**Code Walkthrough:**

Below is the complete code walkthrough to understand the code written in the above TwoInputFieldTests.java file.

 1. Add a new class file as TwoInputFieldTests.java and extend BaseTest. This helps to inherit and access the *driver* variable and methods of the base class in all the test cases and prevents redundant code.

![](https://cdn-images-1.medium.com/max/2000/0*JZL0nPf0UImC1Id0.png)

 1. Add the first test case as *shouldVerifyAllElementsWhenThePageIsLoaded()* and *annotate* it with the *@Test* annotation. This annotation helps to identify a method as a test case and execute it as a TestNG case. We have used the *groups* attribute of *@Test* annotation here to mark this test as part of the *uiTests* group so that it gets executed whenever these group cases are triggered.

![](https://cdn-images-1.medium.com/max/2000/0*GlX1JPNMuoLofOo8.png)

 1. In this test case, we verify if all the Two Input Fields section elements are displayed when the web page is loaded.

![](https://cdn-images-1.medium.com/max/2800/0*EA4iLasTcTUWdlcY.png)

 1. For this, we use the *isDisplayed()* method of WebElement to check whether the element is displayed. This returns a boolean *true* value if the element is displayed and *false* if not.

![](https://cdn-images-1.medium.com/max/2366/0*RiQQJN2v6STGNyrO.png)

 1. To assert the same, we use the *assertTrue()* method of the *Assert* class. It passes if the passed value is true, meaning the element is displayed.

![](https://cdn-images-1.medium.com/max/2800/0*rZzpUe7-pAyduRlI.png)

Assertions are crucial in the automation testing process, ensuring the software functions as expected. To learn assertTrue(), follow this guide on assertTrue() in Java and gain valuable insights.

 1. Write a similar assert statement using the *isDisplayed()* method for all the web elements to verify the entire UI of this section.

![](https://cdn-images-1.medium.com/max/2800/0*lpbYo28S0JkC_7DB.png)

 1. Add the second test case as *shouldReturnTheResultWhenBothNumbersAreValid*(). Similar to the previous case, annotate it with the *@Test* annotation and add it to *positiveTest* and *sanity* groups. We have added 2 group names here, unlike 1 in the previous case. This means that this test case in Java will get executed as part of both these groups.

![](https://cdn-images-1.medium.com/max/2000/0*2QKhpdKdnPFDab3r.png)

 1. Enter the first and second values using the *sendKeys()* method. This method of Selenium WebDriver is used to enter data in any input text box field while working with web automation.

![](https://cdn-images-1.medium.com/max/2000/0*RQ-l0HoIOoD2z5p0.png)

 1. After entering the values, click the **Get Sum** button to get the result. For this, another method of WebDriver, *click()* is used.

![](https://cdn-images-1.medium.com/max/2224/0*IbS3nRVYVVh7Lw-e.png)

 1. Finally, we fetch the result using the *getText()* method and store it in a variable. This method retrieves any text value from the web page using Selenium web automation. Assert’s a*ssertEquals()* method compares this value with the expected result.

![](https://cdn-images-1.medium.com/max/2800/0*a-ZWuMt-_8RLHy0U.png)

This method is used to compare two values as part of an assertion. Learn how to use asserts in TestNG correctly to help you verify and validate your actual and expected results.

 1. Add the last test case and name it as *shouldShowErrorWhenAnyNumberIsMissing()*. Like the previous cases, annotate it with *@Test* and add it to the *negativeTest *and *sanity *groups.

![](https://cdn-images-1.medium.com/max/2000/0*I4LECAw3YERpc_zK.png)

 1. Enter any one value using the *sendKeys()* method. Here, we are entering the first value field.

![](https://cdn-images-1.medium.com/max/2000/0*yVfcS0EUO-Ecb_j4.png)

 1. Click on the **Get Sum** button.

![](https://cdn-images-1.medium.com/max/2198/0*BuB7-eQ6QLzHw4Y0.png)

 1. Fetch the error message using the *getText()* method and assert it to be the same as the expected error message using the *assertEquals()* method.

![](https://cdn-images-1.medium.com/max/2800/0*OC7FyNMPWW1D0niF.png)

**Test Execution And Results**

Right-click > Select Run As > TestNG, Test to execute the tests individually.

![](https://cdn-images-1.medium.com/max/2712/0*wSRnKyaBsNhsuBKo.png)

**Result:**

*shouldVerifyAllElementsWhenThePageIsLoaded()*

![](https://cdn-images-1.medium.com/max/2800/0*i-g-dOOvHCSm_IWt.png)

**Result:**

*shouldReturnTheResultWhenBothNumbersAreValid()*

![](https://cdn-images-1.medium.com/max/2800/0*Z1N0ZkDC5QbeFzeV.png)

**Result:**
*shouldShowErrorWhenAnyNumberIsMissing()*

![](https://cdn-images-1.medium.com/max/2800/0*o5xzpQYYwZIts82P.png)

Running tests locally is manageable when working with up to three or four browsers and one operating system. However, this limitation makes it difficult for testers to conduct tests on more than four browsers and multiple operating systems. To address this, testers can use a cloud-based platform where they do not have to worry about maintaining test infrastructure and can conduct comprehensive cross-browser and cross-platform testing seamlessly. One such platform is LambdaTest.

It is an AI-powered test execution platform that lets you run manual and automated [cross-browser testing](https://www.lambdatest.com/cross-browser-testing?utm_source=medium&utm_medium=organic&utm_campaign=aug_12&utm_term=rj&utm_content=blog) at scale, with over 3000+ real devices, browsers, and OS combinations.

This platform provides the speed and resources to make test executions faster and more reliable. It facilitates parallel execution, allowing multiple tests to run simultaneously for large automation suites. This cloud grid platform also offers enhanced logging, maintenance, and debugging resources.

Now, let’s move the local test script to the LambdaTest platform with a few modifications to leverage all the features this cloud grid offers.

## How To Write a Test Case in Java for Cloud Execution?

Having understood the flow of writing and executing the first test case in Java using Selenium and TestNG, let us move ahead and learn how we can do the same on a cloud grid platform.

To use the LambdaTest cloud grid to run the Selenium automation test cases, we need to make some changes to the code to use Selenium *RemoteWebDriver*, which will help connect to the LambdaTest cloud grid and execute the cases over there.

Most of these changes involve configuring the WebDriver settings in BaseTest.java. The modified BaseTest.java with the cloud grid integration will look similar to the example below.

package CLoudGRid;


import java.net.*;
import java.util.HashMap;


import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.testng.annotations.*;


public class BaseTest {
   public RemoteWebDriver driver = null;


   String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME");
   String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" : System.getenv("LT_ACCESS_KEY");

   String status = "failed";


   @BeforeMethod
   public void setup() {
       try {
           ChromeOptions chromeOptions = new ChromeOptions();
           chromeOptions.setPlatformName("Windows 10");
           chromeOptions.setBrowserVersion("125");


           HashMap<String, Object> ltOptions = new HashMap<String, Object>();
           ltOptions.put("build", "Test case in Java");
           ltOptions.put("name", "Test case in Java");
           ltOptions.put("w3c", true);
           chromeOptions.setCapability("LT:Options", ltOptions);


           driver = new RemoteWebDriver(
                   new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), chromeOptions);


           System.out.println("Navigating to Two Input Field section");
           driver.get("https://www.lambdatest.com/selenium-playground/simple-form-demo");


       } catch (MalformedURLException e) {
           e.printStackTrace();
       }
   }


   @AfterMethod
   public void tearDown() {
       driver.executeScript("lambda-status=" + status);
       driver.quit();
   }
}




**Code Walkthrough:**

Below is the complete code walkthrough to understand the code written in the above BaseTest.java file.

 1. Start by creating required class objects and variables with public access to access them in the test classes. For this, first, create an object of *RemoteWebDriver* and initialize it to null.

![](https://cdn-images-1.medium.com/max/2000/0*op0j-cF96roH7ld5.png)

 1. Next, add the username and access key for your LambdaTest account to connect to the cloud grid for test execution. You can find these in the [Password & Security](https://accounts.lambdatest.com/security) section tab.

![](https://cdn-images-1.medium.com/max/2800/0*lAewimHoMT1xE08m.png)

 1. You can also configure these as environment variables and directly fetch them in code instead of defining them in plain text.

**For Windows:**
>  set LT_USERNAME=LT_USERNAME
set LT_ACCESS_KEY=LT_ACCESS_KEY

**For macOS and Linux:**
>  export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY

 1. Add a String variable as *status* and initialize it with value as *failed*. Before quitting the driver instance, this variable helps mark the test case’s final status as passed/failed on the LambdaTest dashboard. This value is updated to be *passed* in the test case if the test passes with no assertion failures or exceptions.

![](https://cdn-images-1.medium.com/max/2000/0*R5zUDdWmlgqgVlJ8.png)

 1. Update the code inside the *setup()* method to set the required browser properties and LambdaTest configurations to connect to the cloud grid.

 2. Create an object of the *ChromeOptions *class and set the OS and browser versions.

![](https://cdn-images-1.medium.com/max/2000/0*HVdfuVIZhf5IAgYJ.png)

 1. Next, create a *HashMap* type variable to specify the additional browser capabilities for the LambdaTest platform. This will help to identify the dashboard test results using the build name and other details.

![](https://cdn-images-1.medium.com/max/2000/0*CCXAp5caKB33BHL-.png)

You can fetch the required browser capabilities from the LambdaTest platform by navigating to the [Automation Capabilities Generator](https://www.lambdatest.com/capabilities-generator/). This helps by offering ready-to-use code for setting up browser capabilities that can be used in execution.

![](https://cdn-images-1.medium.com/max/2800/0*9GMkI4S4Ry4lTFB9.png)

 1. Finally, use the Selenium *RemoteWebDriver* to connect to the LambdaTest remote grid using your credentials and *ChromeOptions* class object containing all specified browser capabilities.

![](https://cdn-images-1.medium.com/max/NaN/0*piISf2ZGBaAenDMt.png)

 1. Use this driver to navigate the Two Input Fields page on the LambdaTest Selenium Playground for test execution.



![](https://cdn-images-1.medium.com/max/2000/0*RU5GigHc8a_NTHMH.png)

 1. Inside the *tearDown()* method, add a step to execute the script to update the test case status on the LambdaTest dashboard.



![](https://cdn-images-1.medium.com/max/2000/0*Nq-KEWqz9Wlxr0B1.png)

 1. Next, move to the test class TwoInputFieldTests.java and add the step to update the status to *passed *after the execution of all test cases.

![](https://cdn-images-1.medium.com/max/2800/0*CLwA0CmlF_4P7Wsq.png)

![](https://cdn-images-1.medium.com/max/2800/0*5pAfEyqzyf-KeMUv.png)

![](https://cdn-images-1.medium.com/max/2800/0*QAeAKc20sMNaLTDh.png)

**Results:**

We can execute the test cases similarly to how we did for local execution. The console output in the IDE will remain unchanged, but the primary focus will shift to monitoring the execution results on the LambdaTest dashboard.

The execution results are on the LambdaTest Dashboard under the **Automation > Web Automation** tab.

![](https://cdn-images-1.medium.com/max/2800/0*I5iLpBNPJZ6gpxJ8.png)

![](https://cdn-images-1.medium.com/max/2800/0*3wV40bGiaiUtBtRY.png)

![](https://cdn-images-1.medium.com/max/2800/0*pMZADnQkc5DRzQrd.png)

![](https://cdn-images-1.medium.com/max/2800/0*geLMoQkFsBbXCb5U.png)

## Best Practices for Writing Test Cases in Java

All the test executions we’ve learned above are written following best practices. Adhering to these practices helps avoid repeating the same or similar mistakes and ensures a smooth test flow in your automation projects.

Some of the best practices are given below.

* **Understanding the Requirements**

The first and foremost requirement of writing a good test case is understanding the changes and features clearly. The tester needs to know what is expected from the code based on the input. We can refer to the product requirement documentation or the acceptance cases to know the expected behavior.

* **Maintainable and Reusable Code**

The test cases should be readable and follow clean coding principles. This helps to keep test cases maintainable and allows quick refactoring in case of requirement changes without much hassle.

* **Clear and Descriptive Test Case Names**

The names should be clear and meaningful so that anyone who sees the code or test case can understand what a particular test is supposed to do. The name should be descriptive enough to describe the purpose of the test case. One of the naming conventions one can follow is *should[ExpectedResult*]*When[Condition]*. For example, *shouldReturnTheResultWhenBothNumbersAreValid *or *shouldShowErrorWhenAnyNumberIsMissing*.

* **Arrange-Act-Assert Structure**

Try to follow the AAA structure for your test cases for effective test management by splitting it into three parts.

* **Arrange:** Define and set up the test environment and test data on which we want to execute the test.

* **Act:** Write the execution steps which interact with the feature using the above data.

* **Assert:** Write proper assertions which verify the actual and expected results.

* **One Test Case, One Assertion**

Use specific and meaningful assertions for each test case, which helps to verify the required details. One test should not be used to verify multiple flows and should not have a dependency on any other test case. For example, valid results for valid input and error responses for invalid input should be two separate test cases. You can use assertions like *assertEquals(), assertTrue(), assertFalse(), assertNotNull()*, etc., to assert to-the-point data and provide meaningful messages to better understand the failures.

* **Using Setup and Teardown Methods**

Use *@Before* and *@After* annotations of JUnit or TestNG, depending on your framework, to write setup and teardown methods. These methods help to prevent duplicity by making the common code, like driver setup, browser launch, driver termination, etc, reusable across all the test cases.

* **Using Mock Data and Stubs for Error Cases**

Mock data or stubs means to simulate a function behavior in the software to return some particular result as desired by the tester to test some particular test cases. We can use mocking frameworks like Mockito or write a stub function to mock dependencies and verify test cases for external dependency failures.

* **Covering Edge and Boundary Value Cases**

Write test cases to cover all the edge cases or unusual scenarios due to software or hardware downtimes. You can use mocking for such types of test cases. Also, testing for boundary values by passing various test data helps verify if the code and software function properly for limiting cases.

* **Using Tags, Groups, and Categories**

Use tags, groups, or categories to group the related test cases together that serve some common purpose, flow, or requirement in general. For instance, you can group all test cases for login flow, positive and negative cases, etc.

## Conclusion

With this, we have concluded this blog on how to write a test case in Java. In this blog, we learned how a good test case can be written with a basic understanding of Java language and test case fundamentals like flow, assertions, and WeElement locators. We learned the working examples on local and cloud grids and understood how following the best practices makes the test case robust and reliable. Now, it’s time for you to go ahead and try writing your first [test case](https://www.lambdatest.com/learning-hub/test-case?utm_source=medium&utm_medium=organic&utm_campaign=aug_12&utm_term=rj&utm_content=blog) in Java.

Happy learning!!

How To Scroll Down in Selenium WebDriver

Vipulgupta9090 — Tue, 06 Aug 2024 15:17:31 +0000

Scrolling in Selenium is crucial for interacting with elements beyond the visible viewport. It ensures proper visibility and accessibility of elements during test execution, especially in scenarios involving dynamic content or lazy loading. Before diving into operations like how to scroll up and scroll down in Selenium, it’s important to understand the classes and interfaces in Selenium WebDriver.

Selenium WebDriver is mainly represented by the WebDriver interface. This interface defines a set of methods for web browsers, allowing users to automate their interactions with WebElements and perform various testing operations. We will learn more about the SeleniumWebDriver interfaces detailed in this tutorial on how to scroll down in Selenium.

In this blog, we will explore performing scrolling actions on web pages using the JavaScriptExecutor interface in Selenium, focusing on how to scroll down in Selenium WebDriver.

We will use Java as a programming language to demonstrate these scroll actions, covering scenarios such as scrolling to a specific element and horizontal scrolling.
This straightforward guide on incorporating scroll functionality into your Selenium automation scripts will help you build confidence when scrolling down in Selenium.

Understanding the hierarchy of Selenium interfaces

WebDriver is the foundation for building browser automation scripts in different programming languages. Other Selenium interfaces, such as SearchContext, *Remote WebDriver, *TakesScreenshot, and JavaScriptExecutor interfaces, extend the capabilities of Selenium WebDriver

The SearchContext interface in Selenium ensures a consistent method for locating elements within the HTML structure during web automation testing, providing a standardized approach for interaction with WebElements. In addition to the core WebDriver and SearchContext interfaces, Selenium WebDriver incorporates two essential interfaces.

The TakesScreenshot interface enables users to capture screenshots during test execution, enhancing visual information in Selenium scripts.

The JavaScriptExecutor interface empowers users to execute JavaScript code within the Selenium framework, offering two methods: executeScript() for synchronous JavaScript and executeAsyncScript() for asynchronous JavaScript, further expanding the capabilities of Selenium scripts.

Understanding this hierarchy and the relationships between these interfaces is crucial for effectively utilizing Selenium WebDriver for automation testing. It provides a structured approach to performing actions on WebElements and facilitates the creation of robust and maintainable test scripts.

Let’s explore the basics of scrolling down in Selenium WebDriver to understand the significance of scrolling in Selenium.

What is scrolling in Selenium?

Scrolling in Selenium involves navigating up or down a web page to view its contents that extend beyond the visible area of the browser window. In the real-world scenarios of Selenium WebDriver automation, where conventional mouse or keyboard actions are not applicable, we rely on JavaScriptExecutor to scroll down through the content or web pages.

Scrolling in Selenium involves adjusting the view of a web page either vertically or horizontally to access hidden or dynamically loaded content. This becomes particularly useful when the elements you intend to interact with on a web page are not immediately visible and require scrolling into view before interaction is possible.

When performing automation testing with Selenium, various scenarios may demand scrolling, and one crucial aspect is scrolling down in Selenium. These scenarios include:

Locating and interacting with hidden elements: This is a typical situation in Selenium automation. Some web pages have initially hidden elements that only become visible when you scroll down. Incorporating the scroll down in the Selenium technique is crucial to interact with these elements smoothly, ensuring they come into the viewport for effective automation.
Infinite scroll: Infinite scrolling is a feature on certain web pages where new content dynamically loads as the user scrolls down. In automated testing scenarios, there’s a need to scroll down in Selenium WebDriver to initiate the loading of additional content.
Navigating through dropdowns or menus: Navigating through dropdowns or menus, especially those with numerous options, may necessitate scrolling down in Selenium to access the desired option effortlessly.
Verifying page layout: Verifying the page layout occasionally requires scrolling down in Selenium to ensure a comprehensive check of the appearance and arrangement of elements across different page sections.

To implement scroll down in Selenium, especially to an element and other relevant operations, the initial step involves importing the org.openqa.selenium.JavascriptExecutor package into your code.

Below is the syntax of JavaScriptExecutor for Selenium, which is important for seamlessly incorporating scroll down in Selenium functionality and various related operations:

The syntax for JavaScriptExecutor is shown below:

    JavascriptExecutor js = (JavascriptExecutor) driver;
    js.executeScript(script,arguments);

In the provided code snippet, we create an instance of the JavascriptExecutor interface by casting the WebDriver object. JavaScript, a language capable of communicating with HTML in a browser, is used through the JavascriptExecutor interface for executing JavaScript code in Selenium automation.
This interface acts as a bridge, enabling the WebDriver to interact with HTML elements within the browser and facilitating various actions, such as scrolling, as this blog emphasizes.

Subsequently, the JavascriptExecutor object invokes the executeScript() method. This method executes the specified test script as an anonymous function for the current browser window in focus.

Notably, the executeScript() method returns a WebElement if the script involves an HTML element and includes a return statement, which is relevant when incorporating the scroll down in Selenium WebDriver functionality.

Some examples of this script would be.

To click a button
To enter some data
To scroll down in Selenium WebDriver

Now that the basic premise is set let’s delve into scrolling a web page using Selenium WebDriver. In this blog on how to scroll down in Selenium WebDriver, we will learn to incorporate scroll down functionality for effective automation testing.

Scrolling a web page using Selenium WebDriver

Effectively scrolling a web page using Selenium WebDriver is crucial, especially when confronted with elements that aren’t immediately visible or that trigger specific behaviors on a web page. Selenium WebDriver offers multiple methods for seamless scrolling, providing diverse techniques to simulate this action.

There are various approaches to achieving this, including the natural integration of the scroll down in Selenium WebDriver.

scrollTo() method

This scrollTo() method is valuable for scrolling a web page to a specific location using Selenium WebDriver. This method requires the (x, y) coordinates of the desired location as arguments. For instance, to effortlessly scroll down to the bottom of the web page, you would pass the y-coordinate set as the maximum height of the document (web page).

js.executeScript(“window.scrollTo(0, document.body.scrollHeight)”);

This approach proves particularly useful when dealing with scroll down in Selenium WebDriver functionality.

scrollBy() method

This scrollBy() method is handy when adjusting the view by a specific number of pixels in Selenium WebDriver. Similar to the scrollTo() method, it also takes (x, y) coordinates as arguments. However, in the scrollBy() method, the coordinates signify the number of pixels to scroll rather than the absolute position to scroll to. For instance, to smoothly scroll 50 pixels on the x-axis and 100 pixels on the y-axis, you would provide these values as arguments to the method.

 js.executeScript(“window.scrollBy(50,100)”);

This approach proves effective, especially with scroll down in Selenium WebDriver functionality.

scrollIntoView() method

This scrollIntoView() method in Selenium WebDriver is a valuable approach for scrolling to a specific WebElement that is currently not visible on the screen. This method takes the script to scroll and the WebElement as arguments. Like the scrollTo() and scrollBy() methods, it effectively manages elements’ visibility during automation testing.

js.executeScript(“arguments[0].scrollIntoView();”, element);

This functionality becomes particularly relevant when seamlessly integrating the scroll down in the Selenium WebDriver technique.

In the following section of this blog, we will learn how to scroll down in Selenium WebDriver with a demonstration and code walkthrough.

How to scroll down to the bottom of the page in Selenium WebDriver?

To achieve a smooth scroll down in Selenium WebDriver, we will obtain the height of the page. Once the page height is determined, we will perform a scroll down in Selenium to reach the end of the page. This method is frequently used in Selenium automation testing, where scrolling is essential to carry out relevant operations on the WebElements within the Document Object Model (DOM).

The following code helps you scroll down to the bottom of the page using the JavascriptExecutor interface.

js.executeScript(“window.scrollTo(0, document.body.scrollHeight)”);

In the following implementation, we navigate to the LambdaTest Selenium Playground web page and execute a scroll down to the bottom of the page in Selenium WebDriver.

Demonstration: Scroll down to the bottom of the page in Selenium WebDriver

Before proceeding with the demonstration of scrolling to the bottom using Selenium, let’s establish the basic setup for the project. This setup involves creating a Maven — TestNG project and configuring it to connect to a remote cloud grid where we will execute all the test cases and assess the results.

We will be using a cloud-based platform to access Selenium Grid, and one such platform is LambdaTest. LambdaTest is an AI-powered test orchestration and execution platform that lets you run manual and automated tests at scale with over 3000+ real devices, browsers, and OS combinations. It also provides detailed execution reports that can be viewed on its dashboard and analytics for test execution trends and other key performance indicator metrics.

This platform will assist us in executing and managing all the test cases over the cloud. Furthermore, this platform enables you to use the Selenium Grid for parallel testing. This preparation is crucial, especially when integrating the scroll down in Selenium technique later in the project.

If you are new to automation testing over the cloud, follow this detailed video tutorial on using LambdaTest to run your tests. It provides valuable insights and step-by-step instructions, helping you start automation testing projects over a cloud platform.

Let’s look at the project setup, including the configuration for connecting to the LambdaTest cloud grid. This setup will be utilized in all demonstrations involving scrolling using Selenium.

Project Setup:

Below are the steps to set up your project and perform scroll down functionalities using Selenium WebDriver.

Step 1. Launch Eclipse IDE or any other IDE of your choice. The steps for project setup and all demonstrations remain the same for the chosen IDE. If you do not have Eclipse installed, download the IDE from their official website.

Step 2. Create a new Maven project and name it as SeleniumScroll.

Step 3. Inside the src package, add a new package as a test. This package will have all the Java test files for this blog demonstration.

Step 4. Add a class file and name it BaseTest.java. This Java file will contain all the common code for test execution, like setup and initializing the WebDriver, declaring and initializing public variables for the project, handling driver termination after test completion, etc.

This file will have the details and steps required to connect to the LambdaTest cloud grid on which all the test cases will be executed.

If you wish to learn how to install TestNG in Eclipse, follow this detailed guide that covers all the steps needed to set up TestNG in Eclipse and start your automation testing process.

As this project uses Selenium and TestNG as the testing framework, add the latest stable versions of Selenium 4 and TestNG dependencies inside the pom.xml for the best execution results. You can fetch the latest dependencies from the Maven repository.

For an in-depth understanding of Selenium 4, including its architecture, types, and differences compared to Selenium 3, you can follow this comprehensive video tutorial. It provides valuable insights into the workings of Selenium 4.

The updated pom.xml should look like this.

    <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>SeleniumScroll</groupId>
     <artifactId>SeleniumScroll</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <build>
       <sourceDirectory>src</sourceDirectory>
       <plugins>
         <plugin>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.1</version>
           <configuration>
             <release>17</release>
           </configuration>
         </plugin>
       </plugins>
     </build>
     <dependencies>
           <dependency>
               <groupId>org.seleniumhq.selenium</groupId>
               <artifactId>selenium-java</artifactId>
               <version>4.16.1</version>
           </dependency>
           <dependency>
               <groupId>org.testng</groupId>
               <artifactId>testng</artifactId>
               <version>7.8.0</version>
               <scope>test</scope>
           </dependency>
       </dependencies>
    </project>

And the finalized BaseTest.java with all the cloud configuration and LambdaTest configurations should look like below.

Code Implementation:

The following code implementation consists of the cloud capabilities and establishes a common file containing the base code for performing scroll operations.

    package test;


    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.HashMap;


    import org.openqa.selenium.chrome.ChromeOptions;
    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.openqa.selenium.JavascriptExecutor;
    import org.testng.annotations.*;


    public class BaseTest {


       public RemoteWebDriver driver = null;
    JavascriptExecutor js;
       String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME");
       String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" : System.getenv("LT_ACCESS");


       @BeforeTest
       public void setup() {
           try {
               ChromeOptions chromeOptions = new ChromeOptions();
               chromeOptions.setPlatformName("Windows 10");
               chromeOptions.setBrowserVersion("121.0");


               HashMap<String, Object> ltOptions = new HashMap<String, Object>();
               ltOptions.put("build", "Scroll with Selenium WebDriver");
               ltOptions.put("project", "Scroll with Selenium WebDriver");
               chromeOptions.setCapability("LT:Options", ltOptions);


               driver = new RemoteWebDriver(
                       new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), chromeOptions);
               js = (JavascriptExecutor) driver;
           } catch (MalformedURLException e) {
               e.printStackTrace();
           }
       }


       @AfterTest
       public void tearDown() {
           driver.quit();
       }
    }

Before we jump to the result, let us understand the above code in the step-by-step process below.

Code Walkthrough:

The code below consists of the functions used to connect to the cloud grid, set up RemoteWebDriver, add LambdaTest username and access key, and more.

The above code creates an object of RemoteWebDriver and initializes it as null.

The above code creates an object of the JavascriptExecutor interface. We will initiate it after connecting to the cloud grid later.

The above code displays how to add your username and access key once you have fetched it from the LambdaTest platform. To fetch the credentials, click Profile > Account Settings > Password & Security, copy the details, and connect to the cloud grid for test execution.

Alternatively, you can configure these as environment variables and directly fetch them in code.

For macOS and Linux:

export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME
set LT_ACCESS_KEY=LT_ACCESS_KEY

The above code creates a method for this class and names it setup(). Annotate it with the @BeforeTest annotation in TestNG so that it is executed before each test.

The above code creates an object of the ChromeOptions class. This can be used to set the OS and browser versions.

The above code creates a HashMap type variable to pass the additional browser capabilities required by the LambdaTest platform to support test execution on their cloud grid. This will help identify the dashboard test results using the build name and other details.

Lastly, fetch the required browser capabilities for the LambdaTest platform by navigating to the Automation Capabilities Generator. This helps by offering ready-to-use code for setting up browser capabilities that can be used in execution.

The above code uses the Selenium RemoteWebDriver to connect to the LambdaTest remote Grid using the credentials and the ChromeOptions objects containing all specified browser capabilities.

In the above code, the driver is initialized, which is used to initialize the JavascriptExecutor object that we created towards the beginning as well.

The above code adds a new method to close the browser and terminate the WebDriver session after each test execution. Name it as tearDown(), and annotate it with @AfterTest.

With this, the setup for the BaseTest.java file to hold the common code is completed. We will extend this file in all test classes going forward in this blog to demonstrate different scrolling operations used with Selenium.

Let’s proceed and explore the process of scrolling down to the bottom of a web page using Selenium WebDriver.

Code Implementation:

Below is the code implementation of performing scroll down in Selenium WebDriver with Java.

    package test;


    import org.testng.annotations.Test;


    public class ScrollDown extends BaseTest{

       @Test
       public void testScrollDown()
       {
           //launch the website
           driver.get("https://www.lambdatest.com/selenium-playground/");

           //get the height of the web page and scroll to the end
           js.executeScript("window.scrollTo(0, document.body.scrollHeight)");   
       }
    }

Let us try to understand the above code’s workings in the step-by-step procedure below.

Code Walkthrough:

The above code extends the test class with the BaseTest.java file to inherit and use its functionalities, including the WebDriver and JavascriptExecutor.

The above code adds a new test method as testScrollDown() and annotates it with @test annotation.

The above code uses the JavascriptExecutor object to scroll down to the bottom of the page using the scrollTo() method.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

How to scroll down to the WebElement visibility in Selenium WebDriver?

In any web page, several WebElements may load dynamically. To execute scroll down in Selenium, the relevant WebElement must be present or visible in the DOM.

The JavaScript scrollIntoView() interface is invaluable for this purpose, smoothly scrolling an element into the visible part of the window and enhancing the effectiveness of scroll down operations in Selenium WebDriver.

    // Locate the desired WebElement
    WebElement element = driver.findElement(By.linkText("Espresso Testing"));
    js.executeScript("arguments[0].scrollIntoView();", element);

In the following implementation, we navigate to the LambdaTest Selenium Playground web page and execute a scroll down to the WebElement in Selenium WebDriver.

Demonstration: Scroll down to the WebElement in Selenium WebDriver

Below is the code to cover the complete working of visibility of an element on the web page.

Code Implementation:

The code below consists of the functions that perform scroll down in Selenium WebDriver for element visibility on the web page.

    package test;


    import org.openqa.selenium.By;
    import org.openqa.selenium.WebElement;
    import org.testng.annotations.Test;


    public class ScrollDownByElementVisibility extends BaseTest{

       @Test
       public void testScrollDownByElementVisibility()
       {
           //launch the website
           driver.get("https://www.lambdatest.com/selenium-playground/");

           //specify the WebElement till which the page has to be scrolled
           WebElement element = driver.findElement(By.linkText("Espresso Testing"));


           //get the height of the web page and scroll to the end
              js.executeScript("arguments[0].scrollIntoView();", element);  
       }
    }

Let us understand the code in detail below before jumping to the result.

Code Walkthrough:

The above code creates a new test class and extends BaseTest.java.

The above code adds a test method testScrollDownByElementVisibility() and annotates it with @test.

The above code navigates to LambdaTest Selenium Playground.

The above code locates the WebElement to which we want to scroll. We have used the element’s Link Text to locate it.

To learn more about how to *findElement()* by Link Text or Partial Link Text, follow this guide on using Link Text and Partial Link Text in Selenium and get valuable information.

The above code uses the JavascriptExecutor object to execute the scrollIntoView() method with the element as the argument to scroll to it.

Result:

On executing the above code, you can see the result on the local and LambdaTest dashboard.

To learn more about WebElements and how you can interact with them, follow the video tutorial and get practical insight on dealing with WebElements to make your automation testing process efficient.

Not sure how to optimize your website for all devices? Follow our responsive design best practices to ensure a seamless user experience.

How to scroll down by specified pixels in Selenium WebDriver?

You can also scroll to a particular point by specifying the exact location or coordinates on the page. This can be done using the scrollBy() method.

js.executeScript(“window.scrollBy(0,3000)”);

In the following implementation, we navigate to the LambdaTest Selenium Playground web page and execute a scroll down by specified pixels in Selenium WebDriver.

Demonstration: Scroll down by specified pixels in Selenium WebDriver

Below is the code for scrolling down by a specified number of pixels on a web page using Selenium WebDriver.

Code Implementation:

The provided code consists of functions that scroll down in Selenium WebDriver to a specified number of pixels on a web page using Selenium WebDriver.

    package test;


    import org.testng.annotations.Test;


    public class ScrollDownByPixel extends BaseTest{


       @Test
       public void testScrollDownByPixel()
       {
           //launch the website
           driver.get("https://www.lambdatest.com/selenium-playground/");

           //specify the number of pixels the page has to be scrolled
           js.executeScript("window.scrollBy(0,3000)");
       }
    }

Let us understand the working of the above code in detail below before jumping to the result.

Code Walkthrough:

The above code creates a new test class and extends BaseTest.java.

In the above code, we use a test method, testScrollDownByPixel(), which annotates it with @test.

The above code navigates to LambdaTest Selenium Playground.

The above code uses the JavascriptExecutor object to execute the scrollBy() method by specifying the location pixels we want to scroll.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

How to scroll left in the horizontal direction in Selenium WebDriver?

When performing automation testing for websites or web apps, there are times when it becomes crucial to scroll the page in the horizontal direction. Particularly, when focusing on horizontal scrolling, the requirement may arise to scroll to the page’s left or right.

Use the below code snippet to scroll left horizontally during an automation test.

js.executeScript(“window.scrollBy(-3000,0)”);

In the following implementation, we navigate to the LambdaTest website and scroll left in the horizontal direction in Selenium WebDriver.

Demonstration: Scroll left in the horizontal direction in Selenium WebDriver

This demonstration is part of performing scroll down in Selenium, aiming to scroll a web page to the left in the horizontal direction using Selenium WebDriver.

Code Implementation:

The provided code below consists of functions that perform a horizontal scroll to the left on a web page using Selenium WebDriver.

    package test;


    import org.openqa.selenium.Dimension;
    import org.testng.annotations.Test;


    public class ScrollToHorizontalLeft extends BaseTest{


       @Test
       public void testScrollToHorizontalLeft()
       {
           //launch the website
           driver.get("https://www.lambdatest.com");


           //decrease the size of window to show both scoll bars
           driver.manage().window().setSize(new Dimension(450,630));

           //scroll to the right
           js.executeScript("window.scrollBy(6000,0)");


           //scroll to the left
           js.executeScript("window.scrollBy(-3000,0)");
       }
    }

Let us understand the working of the above code in detail below before jumping to the result.

Code Walkthrough:

The above code creates a new class, ScrollToHorizontalLeft, and extends BaseTest.java.

The above code adds the test method testScrollToHorizontalLeft() and annotates it with the @test annotation of TestNG.

The above code navigates to the LambdaTest website.

The above code resizes the browser window from a maximized size to a smaller one to make both scroll bars visible.

The above code visualizes the movement of the scroll bar in the horizontal left direction, and we first scroll to the right and then to the left.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

How to scroll right in the horizontal direction in Selenium WebDriver?

To scroll the web page horizontally in the right direction, use the below code snippet.

js.executeScript(“window.scrollBy(2000,0)”);

In the following implementation, we navigate to the LambdaTest website and scroll right in the horizontal direction in Selenium WebDriver.

Demonstration: Scroll right in the horizontal direction in Selenium WebDriver

This demonstration is part of the scroll down in Selenium WebDriver, aiming to scroll a web page to the right in the horizontal direction using Selenium WebDriver.

Code Implementation:

The provided code below consists of functions that perform the scroll right on a web page horizontally using Selenium WebDriver.

    package test;


    import org.openqa.selenium.Dimension;
    import org.testng.annotations.Test;


    public class ScrollToHorizontalRight extends BaseTest{


       @Test
       public void testScrollToHorizontalRight()
       {
           //launch the website
           driver.get("https://www.lambdatest.com");


           //decrease the size of window to show both scroll bars
           driver.manage().window().setSize(new Dimension(450,630));

           //scroll to the right
           js.executeScript("window.scrollBy(6000,0)");  
       }
    }

Before delving into the results, let’s delve into a detailed breakdown of the code. The provided example illustrates scrolling to the right in the horizontal direction using Selenium WebDriver.

Code Walkthrough:

The above code is similar to the last demonstration; add a new class as ScrollToHorizontalRight *and extend *BaseTest.java to it.

The above code adds the test case as testScrollToHorizontalRight() navigates to the LambdaTest website and resizes the browser window to show both scroll bars.

The above code scrolls to the right using the *scrollBy() *method.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

How to scroll horizontally and vertically in Selenium WebDriver

When working with Selenium for automated testing, it’s essential to scroll horizontally and vertically on web pages. To accomplish this, use the following code snippet in your automation script.

Here, values are set for both x and y coordinates, allowing for a natural scroll in horizontal and vertical directions.

js.executeScript(“window.scrollBy(3000,50)”);

In the following implementation, we navigate to the LambdaTest website and scroll horizontally and vertically in Selenium WebDriver.

Demonstration: Scroll horizontally and vertically in Selenium WebDriver

This demonstration is part of scroll down in Selenium, aiming to scroll horizontally and vertically using Selenium WebDriver.

Code Implementation:

The provided code below consists of functions that perform a scroll horizontally and vertically on a web page using Selenium WebDriver.

    package test;


    import org.openqa.selenium.Dimension;
    import org.testng.annotations.Test;


    public class VerticalAndHorizontalScroll extends BaseTest{


       @Test
       public void testVerticalAndHorizontalScroll()
       {
           //launch the website
           driver.get("https://www.lambdatest.com");


           //decrease the size of window to show both scroll bars
           driver.manage().window().setSize(new Dimension(450,630));

           //scroll to the right and left
           js.executeScript("window.scrollBy(3000,50)");  
       }
    }

Before delving into the results, let’s thoroughly understand the code functionality in a step-by-step process.

Code Walkthrough:

The above code is similar to previous horizontal and vertical scroll demonstrations. We add a new class and test method, which navigates to the LambdaTest website and resizes the browser.

The above code performs a vertical and horizontal scroll by passing non-zero values for both the x and y coordinates of the scrollBy() method.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

How to move the scroll bar in Selenium WebDriver?

If a web page features a scroll bar, users can adjust its value and navigate it to their desired position.

Below is the example taken from LambdaTest Selenium Playground to demonstrate the scroll bar activity.

To achieve this, it is necessary to locate the WebElement representing the scroll bar and execute the scrolling action.

In the following implementation, we navigate the LambdaTest Selenium Playground web page and move the scroll bar in Selenium WebDriver.

Demonstration: Move the scroll bar in Selenium WebDriver

This demonstration is part of the scroll down in Selenium WebDriver, aiming to scroll the bar on a page using Selenium WebDriver.

Code Implementation:

The provided code below consists of functions that perform a scroll bar on a web page using Selenium WebDriver.

    package test;


    import org.openqa.selenium.By;
    import org.openqa.selenium.Keys;
    import org.openqa.selenium.WebElement;
    import org.testng.annotations.Test;


    public class ScrollOnAPage extends BaseTest{


       @Test
       public void testScrollOnAPage()
       {
           //launch the website     driver.get("https://www.lambdatest.com/selenium-playground/drag-drop-range-sliders-demo");

           //locate the scroll bar element on page
           WebElement element = driver.findElement(By.xpath("(//input[@type='range'])[1]"));

           //scroll the range element on page
           element.sendKeys(Keys.END);
       }
    }

Let us understand the working of the code snippet before looking into the results in the step-by-step process below.

Code Walkthrough:

The above code ***creates a new test class and extends *BaseTest to it. This class adds a test method testScrollOnAPage() and annotates it with @test annotation.

The above code navigates to the Slider Demo page of LambdaTest Selenium Playground.

The above code identifies the range element on the web page for the intended scrolling action.

Since this element appears multiple times, we utilize the index to interact specifically with the first occurrence.

The above code uses the send*Keys()* function to scroll to the end of the range element.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

How to perform infinite scrolling in Selenium WebDriver?

Many websites incorporate long or infinite scrolling to enhance user engagement. With infinite scrolling, users can seamlessly navigate through content without the need for repetitive clicks on the Previous or Next buttons. You can visit this Infinite Scrolling sample website to examine infinite scrolling briefly.

To enable infinite scrolling, we obtain the page’s height and then scroll to that height. This process iterates until the maximum height and the current height of the web page are equal, signifying that we have reached the end of the web page.

Below is the code snippet that enables infinite scrolling on a web page.

Code Implementation:

    //find the initial page height
    long intialLength = (long) js.executeScript("return document.body.scrollHeight");

    //start the loop to perform infinite scroll to reach end of page
    while(true)
    {
        js.executeScript("window.scrollTo(0,document.body.scrollHeight)");

        //find the height of page again
        long currentLength = (long) js.executeScript("return document.body.scrollHeight");

        //check if its end of page
        if(intialLength == currentLength) {
            break;
        }
        intialLength = currentLength;
    }

Demonstration: Infinite scrolling in Selenium WebDriver

This demonstration is part of scroll down in Selenium, aiming to perform infinite length scrolling on a web page using Selenium WebDriver.

Code Implementation:

The provided code below consists of functions that perform infinite scroll on a web page using Selenium WebDriver.

    package test;


    import org.testng.annotations.Test;


    public class InfiniteScroll extends BaseTest
    {
       @Test
       public void testInfiniteScroll()
       {
           //launch the website
           driver.get("https://the-internet.herokuapp.com/infinite_scroll");

           //find the initial page height
           long intialLength = (long) js.executeScript("return document.body.scrollHeight");

           //start the loop to perform infinite scroll to reach end of page
           while(true)
           {
               js.executeScript("window.scrollTo(0,document.body.scrollHeight)");

               //find the height of page again
               long currentLength = (long) js.executeScript("return document.body.scrollHeight");

               //check if its end of page
               if(intialLength == currentLength) {
                   break;
               }
               intialLength = currentLength;
           }
       }
    }

Let’s delve into the functionality of the code before looking at the results. The following code is designed to perform the specific task of infinite scrolling. Let’s break down the steps involved in this process.

Code Walkthrough:

The above code creates a new test class, testInfiniteScroll(), and adds a test method.

The above code navigates to the infinite scroll website to simulate infinite scrolling.

The above code fetches the initial height of the page and stores it in a variable.

The above code starts a loop to scroll till the end of the web page is reached.

The above code executes the first *scrollTo() *script using the initial height to start scrolling.

The above code fetches the web page height again and checks if the heights equal the initial height value. If heights are equal, it means the end of the web page is reached, and it breaks the loop and stops scrolling.

The above code condition is responsible for checking if the height is equal or not equal, replacing the value, and continuing scrolling until the end of the web page is reached.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

Ready to enhance your UX? Explore the best usability testing tools and ensure your site meets user needs.

How to scroll up to the top in Selenium WebDriver?

In addition to Selenium’s functionalities for scrolling down and scrolling to a specific element, scrolling to the top of the web page is a frequently used operation facilitated by the *JavaScriptExecutor *interface. There are various approaches to scrolling to the top of the page.

To achieve this operation, we initially perform a scroll down using Selenium in Java, followed by a scroll up of the page.

In the following implementation, we navigate to the LambdaTest Selenium Playground web page and scroll up to the top in Selenium WebDriver.

Demonstration: Scroll up to the top in Selenium WebDriver

This demonstration is part of the scroll down in the Selenium WebDriver, aiming to perform a scroll to the top of the web page using Selenium WebDriver.

Code Implementation:

The provided code below consists of functions that perform a scroll to the top of a web page using Selenium WebDriver.

    package test;


    import org.testng.annotations.Test;


    public class ScrollToTheTopOfPage extends BaseTest
    {
       public void navigateAndScrollToBottom()
       {
           //launch the website
           driver.get("https://www.lambdatest.com/selenium-playground/");

           //get the height of the web page and scroll to the end
           js.executeScript("window.scrollTo(0, document.body.scrollHeight)");
       }

       @Test
       public void testScrollToTop_Method_1()
       {
           navigateAndScrollToBottom();

           js.executeScript("window.scrollTo(document.body.scrollHeight,0)");
       }

       @Test
       public void testScrollToTop_Method_2()
       {
           navigateAndScrollToBottom();

           js.executeScript("window.scrollTo(0,0)");
       }

       @Test
       public void testScrollToTop_Method_3()
       {
           navigateAndScrollToBottom();

           js.executeScript("window.scrollTo(0,-document.body.scrollHeight)");
       }
    }

Let’s delve into the functionality of the code before examining the results. The below walkthrough will give us a better understanding of the functions used in the code implementation above.

Code Walkthrough:

The above code adds a new test class and extends BaseTest.

The provided code introduces the first method named navigateAndScrollToBottom().

This is a common method for navigating the LambdaTest Selenium Playground and scrolling down the page. This method will be invoked in various approaches to showcase scrolling to the top.

The above code in the first approach uses the scrollTo() method with the x coordinate as the max scroll height and the y coordinate as the 0 value.

The above code uses the scrollTo() method that uses x and y coordinates as 0.

The above code passes the y-coordinate value as a negative max height to scroll to the top.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

How to scroll horizontally to a specific element in Selenium WebDriver?

The scrollIntoView() method in JavaScript is used in conjunction with the WebElement to which horizontal scroll has to be performed. Their combination is passed to the executeScript() method to realize the scroll to an element in Selenium.

js.executeScript(“arguments[0].scrollIntoView();”, Element);

In the following implementation, we navigate to the LambdaTest Selenium Playground web page and scroll horizontally to a specific element in Selenium WebDriver.

Ready to boost your web development skills? Explore the best Python web frameworks and take your projects to the next level.

Demonstration: Scroll horizontally to a specific element in Selenium WebDriver

This demonstration is part of the scroll down in the Selenium WebDriver, aiming to perform a scroll operation to a specific page element using Selenium WebDriver.

Code Implementation:

The provided code below consists of functions that perform the scroll to specific elements on a web page using Selenium WebDriver.

    package test;


    import org.openqa.selenium.*;
    import org.testng.annotations.Test;


    public class ScrollToSpecificElement extends BaseTest
    {


       @Test
       public void testScrollToSpecificElement()
       {
           //launch the website
           driver.get("https://www.lambdatest.com/selenium-playground");

           //locate the element
           WebElement element = driver.findElement(By.linkText("Changelog"));

           //scroll to the element
           js.executeScript("arguments[0].scrollIntoView();", element);


       }
    }

Let us understand the working code implementation above by breaking down the functionality of the code in step by step procedure.

Code Walkthrough:

The above code adds a new test class, testScrollToSpecificElement(), and creates a test method by extending the *BaseTest *class.

The above code navigates to the LambdaTest Selenium Playground website and identifies the Changelog WebElement, which will be used for scrolling.

The above code scrolls to the element using the scrollIntoView() method.

Result:

On executing the above code, you can see output like the below on the local and the LambdaTest dashboard.

Conclusion

To summarize, we have learned many ways to scroll that can be performed on web pages using Selenium with Java. Automating the page scroll operation using the JavaScriptExecutor interface is one of the widely used operations for Selenium automation testing. Do let us know how you scroll down in Selenium for automated browser testing.

Happy Scrolling…!

How to Fix NoSuchElementException in Selenium

Vipulgupta9090 — Wed, 17 Jan 2024 07:57:41 +0000

Dynamic websites have become prevalent in today’s digital world. They introduce many challenges related to digital experiences, such as the dynamic loading of pages and WebElements. The dynamic loading of web pages and elements has become a significant concern.

These elements load asynchronously and at differing rates, often posing formidable challenges for automation engineers. The complexity of managing these slow-loading elements can turn into a recurring issue. The intermittently slow loading times can lead to test case failures, rendering automation scripts unreliable and flaky.

*Optimize your data management workflow with our SQL to YAML Converter. Convert SQL queries to YAML files and easily manage and share data configurations. *

One of the top contributors to these failures is the NoSuchElementException. This exception is raised when an element cannot be found in the DOM while working with Selenium for writing automation for lazy loading websites on which all the elements are not loaded instantly. Dealing with NoSuchElementException is challenging as it’s an Unchecked Exception, necessitating graceful in-code handling due to its inability to be declared in a method’s throws clause.

In this blog, we will dive deep into the NoSuchElementException in Selenium and understand the reasons for its occurrence. By the end of this blog, you will have a better understanding of how to handle *NoSuchElementException *in Selenium Java and improve the reliability of automated test cases on dynamic websites.

What is a NoSuchElementException?

NoSuchElementException is one of the most common exceptions in Selenium, which occurs when an element is not found on the page. It indicates that the code could not locate and interact with a particular element on the page.

In Selenium automation tests, NoSuchElementException is thrown by WebDriver.findElement() and WebDriver.findElements() methods. It is derived from NotFoundException. You can learn more about it through this blog on *findElement() and findElements() *methods in Selenium.

For example, if you navigate to the LambdaTest eCommerce Playground, you can notice that a few elements are loaded dynamically, and the page looks like this.

At this point, if WebDriver in the Selenium automation code tries to interact with one of the dynamic elements, it throws a NoSuchElementException. So, we should wait for these slow-loading elements to be available first and then proceed further.

Reasons for NoSuchElementException in Selenium

A NoSuchElementException can occur due to failure in locating or interacting with a WebElement on a web page while working with Selenium automation scripts due to the reasons listed below:

*Online CSS to STYLUS converter to convert CSS string to Styl. Get clean, readable code instantly. Start converting today! *

Invalid WebElement Locators

Incorrect or wrongly written WebElement *locators make for the most number of *NoSuchElementException(s). The *WebElement *locator given could be wrong or, at times, too broad that it references multiple elements.

In the screenshot above, the locator is correct, but it references 57 WebElements on the page, which could lead to *NoSuchElementException *when executing the tests.

Slow Loading WebElements

Selenium tests are considerably faster when executed in good network conditions. This causes elements to be absent when the automation script tries to act on them.

This can be resolved using waits such as Implicit waits and Explicit waits. We will be covering the same in the subsequent sections of the blog.

iFrame Issues

Many times, the WebElement is present inside another Frame (or iFrame). Selenium script needs to switch to the frame to interact with the WebElement; otherwise, it will result in NoSuchElementException.

Design changes on the web page

Website designs tend to be revamped regularly after the releases. This is mostly done to add new features and improve user experience and accessibility. Due to this HTML, the structure is impacted the most, and many WebElements could get a new reference path on the webpage or become obsolete in some cases. This leads to *NoSuchElementException *when the automation script still references the WebElement with old locators.

*Need realistic sample data? Use our free online easy-to-use Random XML Generator to create custom XML data for testing and prototyping. No sign-up required. *

Best Practices to fix NoSuchElementException in Selenium

Handling *NoSuchElementException *is important because it helps to make the test scripts more reliable and robust and also prevents them from failing intermittently due to the unavailability of the WebElement.

Check if the element exists and is displayed

Before directly interacting with the element, always make sure it is present on the page and is displayed. For this use, findElementBy() and isDisplayed() functions are provided by Selenium WebDriver.

findElementBy() returns the object of the first matching WebElement of the given element locator on the webpage.
isDisplayed() method of Selenium returns true if a certain WebElement is present and displayed on the webpage. If not, it returns false.

Use waits

Using waits is one of the most commonly used ways to prevent *NoSuchElementException *from occurring in case of slow-loading WebElements and pages. Waits help to make WebDriver wait for the presence of the element or for the page to be loaded before interacting with the element.

Selenium WebDriver provides support for Implicit and Explicit waits. Implicit waits means to set a wait time for an element to be loaded and is implemented to all the elements in the automation script. Explicit waits, the recommended approach, allow waiting for a specific element to prevent unnecessary execution time and NoSuchElementException. *WebDriverWait *has been used in the demonstration section to showcase this better.

Use more robust locators

Always use relative XPath locators compared to absolute ones. This is because relative XPaths are less susceptible to changes when page structure gets modified and thus reduces the chances of exception.

In addition, you must try and use unique locators like ID or Name or a combination of both. These tend to remain the same for the WebElements. This prevents rework in case of cosmetic changes to handle the NoSuchElementException.

If these approaches are not suitable and your page content is highly dynamic, try to use a dynamic locator like xpath[contains(text(),’text’)] to locate the element using text reference, which won’t change.

*Need YAML data for testing? No need to stress about YAML data — Try our Random YAML Generator for a quick and effortless way to generate YAML data in seconds. *

Use try..catch blocks

Wrap your code inside a try-catch block. This helps to catch the *NoSuchElementException *if it occurs and lets the code continue without making it stop abruptly. For this, add the automation code to fetch the WebElement and perform an action on it inside the try block. Then, add a catch block to catch the exception if it occurs and perform any required actions. This helps the code to gracefully handle an exception and prevent it from behaving abruptly.

Switch to Frames and iFrames

Always check if the element is present inside a frame. If yes, use the driver method switchTo() to change driver control to the required frame first and then interact with the WebElement. Once the action is completed, remember to switch the driver back to the main window or the parent frame using driver.switchTo().defaultContent(). You can learn more about it through this blog on iFrames in Selenium.

Demonstration: How to fix NoSuchElementException in Selenium?

To demonstrate the possible ways to fix and handle *NoSuchElementException *in Selenium, we will create a Java project with Maven and TestNG.

In this blog, Eclipse IDE has been used for demonstration purposes. You can choose any IDE of your choice. The implementation remains the same on all of them till a Maven project is created.

As we are working with the Selenium web automation script, we need to add Selenium dependency along with TestNG, which will be used for test execution to the pom.xml of the project.

Once the project is created and dependencies are added, the final pom.xml will be like the one below.

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>NoSuchElementException</groupId>
   <artifactId>NoSuchElementException</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <build>
       <sourceDirectory>src</sourceDirectory>
       <plugins>
           <plugin>
               <artifactId>maven-compiler-plugin</artifactId>
               <version>3.8.1</version>
               <configuration>
                   <release>19</release>
               </configuration>
           </plugin>
       </plugins>
   </build>
   <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-java</artifactId>
           <version>4.8.0</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>7.7.1</version>
           <scope>test</scope>
       </dependency>
   </dependencies>
</project>

Next add a new Java test file TestSeleniumNoSuchElementException.java. We will add our test cases to this to see how to fix *NoSuchElementException *in Selenium.

To handle *NoSuchElementException *in Selenium, we will use a cloud Selenium Grid like LambdaTest for Selenium Java testing.

*Need decimal fractions for your project or testing? Use our free and fast online Random decimal Fraction Generator to generate random decimal fractions in seconds! *

LambdaTest is an AI-powered test orchestration and execution platform to run manual and automated tests at scale. The platform allows you to perform real-time and automation testing across 3000+ environments and real mobile devices. With parallel testing in Java automation testing on LambdaTest, you can significantly reduce the time it takes to run your tests, especially if you have a large number of tests or need to test your application across a wide range of environments.

After adding all the WebDriver configurations and test case examples to demonstrate the fix for NoSuchElementException, the completed file should look like this:

package test;


import java.net.*;
import java.time.Duration;
import java.util.HashMap;


import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.*;
import org.openqa.selenium.By;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.support.ui.*;


public class TestSeleniumNoSuchElementException {


   public RemoteWebDriver driver = null;


   String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME");
   String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>"
           : System.getenv("LT_ACCESS_KEY");


   @BeforeTest
   public void setup() {
       try {
           ChromeOptions chromeOptions = new ChromeOptions();
           chromeOptions.setPlatformName("Windows 10");
           chromeOptions.setBrowserVersion("110.0");


           HashMap<String, Object> ltOptions = new HashMap<String, Object>();
           ltOptions.put("build", "NoSuchElementException in Selenium");
           chromeOptions.setCapability("LT:Options", ltOptions);


           driver = new RemoteWebDriver(
                   new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), chromeOptions);
       } catch (MalformedURLException e) {
           e.printStackTrace();
       }


   }


   @AfterTest
   public void tearDown() {
       driver.quit();
   }


   @Test
   public void testNoSuchElmentException() {
       driver.get("https://ecommerce-playground.lambdatest.io/");
       driver.findElement(By.id("entry_213244")).click();
   }


   @Test
   public void testNoSuchElmentException_fix_tryCatch() {
       driver.get("https://ecommerce-playground.lambdatest.io/");
       try {
           driver.findElement(By.id("entry_213244")).click();
       } catch (NoSuchElementException ex) {
           System.out.println("We are inside catch block");
           System.out.println("NoSuchElementException has been handled.");
       }
   }


   @Test
   public void testNoSuchElmentException_fix_wait() {
       driver.get("https://ecommerce-playground.lambdatest.io/");


       WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
       wait.until(ExpectedConditions.presenceOfElementLocated(By.id("entry_213244")));


       driver.findElement(By.id("entry_213244")).click();
       System.out.println("Web element located and clicked successfully.");
   }


   @Test
   public void testNoSuchElmentException_iframe() {
       driver.get("https://play1.automationcamp.ir/frames.html");
       driver.findElement(By.id("click_me_1")).click();
   }


   @Test
   public void testNoSuchElmentException_iframe_fix() {
       driver.get("https://play1.automationcamp.ir/frames.html");


       driver.switchTo().frame("frame1");
       System.out.println("Switched to frame 1");


       driver.findElement(By.id("click_me_1")).click();
       System.out.println("Web element located and clicked successfully.");


       driver.switchTo().defaultContent();
       System.out.println("Switched back to main window");
   }
}

       driver.findElement(By.id("click_me_1")).click();
       System.out.println("Web element located and clicked successfully.");


       driver.switchTo().defaultContent();
       System.out.println("Switched back to main window");
   }
}

Code Walkthrough

Step 1. We create an instance of RemoteWebDriver as we execute the code on the Selenium cloud Grid.

*Looking for an easy way to generate random octal numbers? Use our online Random Octal Generator tool to generate random numbers in octal format. Try it now for free. *

Step 2. Navigate to the LambdaTest Profile section once you create your account to fetch the username and access key. These will be used to make a connection to their cloud grid.

You can also configure the username and access key as environment variables using the following commands and directly fetch them in code.

For MacOS and Linux:

export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME
set LT_ACCESS_KEY=LT_ACCESS_KEY

Step 3. Create a base method, name it setup(), and annotate with @BeforeTest annotation in TestNG. This method will be used for driver setup and opening the webpage before each test.

In this blog on Selenium Java, we have used Selenium 4, which supports the ChromeOptions class. In this function, an object of the same is created to define browser properties like browser version, OS version, etc. It also accepts the variables required for LambdaTest execution as a capability. These variables are used to set values like build, name, or any other browser property, which will help to identify the run on the LambdaTest Dashboard or modify behavior.

Step 4. Finally, an instance of RemoteWebDriver is created to connect to the LambdaTest cloud grid using the *chromeOptions *and your LambdaTest username and the access key.

Step 5. The LambdaTest platform also contributes by offering ready-to-use code for various OS and browser combinations and numerous browser configurations. To get an instantly valid code for your automation script, go to their Automation Capabilities Generator and make the necessary setup selections.

*Want to decode a messy URL? Unleash the full potential of your website with our online URL Parse tool. Optimize your website’s URLs to improve your site’s visibility. *

Step 6. Add a method as tearDown() and annotate it with @AfterTest annotation. This will be used to close the session after each test case.

Example: NoSuchElementException in Selenium

Add the first test case and name it testNoSuchElmentException().

In this test, we navigate to a website with a few slow loading elements. Then, we try to click on one such element and observe the results.

On executing this, you can observe that the test case fails with *NoSuchElementException *as the element is not yet available to be clicked as it is not loaded yet, and hence the element is unavailable.

Another reason could be that the passed WebElement locator is incorrect, and no element is present with that reference.

Need to extract text from HTML code? Our free online tool makes it easy and fast. Save time by extracting only the text you need from HTML code in no time.

In the next examples, we see how to fix this *NoSuchElementException *in Selenium.

Fixing NoSuchElementException in Selenium using try-catch

As mentioned in earlier sections, one of the most popular ways to handle *NoSuchElementException *in Selenium is using the try-catch block.

You can enclose the WebElement interaction code within a try block and subsequently include a catch block to address any potential *NoSuchElementException *occurrences. Within the catch block, you can execute additional functions in alignment with your automation script’s needs.

For this, add a new test case named testNoSuchElmentException_fix_tryCatch().

In this, we use the same code as the previous example, which raised an exception, but place that inside the try block.

Add a catch block following this try block to catch the *NoSuchElementException *if it occurs and to continue the execution.

Let’s try to execute the code and see the output.

Fixing NoSuchElementException in Selenium using WebDriverWait

Another popular way to fix NoSuchElementException *in your code is to use *WebDriverWait. This should be used in case of slow loading elements on a webpage. These can also be helpful when we run automation code by throttling the network speeds to simulate different conditions and check the behavior. It allows the automation script to wait for a given amount of time for a WebElement to be visible and then proceed with the interaction instead of directly throwing the NoSuchElementException.

Using waits is very helpful when the automation script is running on slow internet networks. In such situations, we can analyze how long a certain WebElement takes to be present on the web page. This data can then be used to define wait duration in automation scripts for different WebElements.

**Extract text from JSON data with our powerful and easy-to-use online free tool. Get the data you need quickly and efficiently, no technical skills required. **

WebDriverWait *is a class provided as a part of Selenium dependency using an object to which we can add an *ExpectedCondition on the WebElement before proceeding.

For this, add another test case and navigate to the target website URL.

Create an object of the *WebDriverWait *class and pass the driver object and the duration we want to wait for the element.

Using this object with the until() function, we add an *ExpectedConditions *suggesting to wait for the presence of a given element by specifying the locator.

Since we have configured *WebDriverWait *time to be 5 seconds, this will make the WebDriver wait for a maximum of 5 seconds before throwing an exception if WebElement is not found.

If the element is found before the given time, WebDriver continues the execution by passing the control to next code statements. This allows the interaction by clicking on the element.

Executing this would provide a successful output as the WebElement is present before we click on it.

These *ExpectedConditions *are used to implement Explicit waits. These are dedicated to a single WebElement and, unlike Implicit waits, are not applied to all the WebElements on the webpage. Thus, these prevent *NoSuchElementException *from happening without adding unnecessary execution times.

Example: NoSuchElementException in Selenium due to iFrames

Another reason for *NoSuchElementException *is that the WebElement is inside an iFrame.

To understand the same, consider the below example.

Looking at this code, it seems quite similar to previous examples. But the difference here is that the WebElement is inside a child frame and not on the main window.

*Get your CSS validated by our CSS Validator and eliminate syntax errors and other issues that could affect your website’s performance. Ensure your CSS code is error-free today! *

You can check if a WebElement is inside an iFrame or not by going to the Inspect Tools.

Hence, executing this would result in a *NoSuchElementException *like the one below, as it will not be found by the driver in its focus window, which is the main window.

Fixing NoSuchElementException in Selenium due to iFrames

You can identify if you are dealing with an iFrame by right-clicking next to the WebElement. If it has options like View Frame Source or Reload Frame, it is an iFrame or Frame.

Next, to get the frame ID, click on Inspect from the same menu and try to locate the parent < *iframe *> tag for your WebElement.

Consider a new test case, testNoSuchElmentException_iframe_fix(), and navigate to the website.

Next, switch to the iFrame by passing its ID to the driver.

After this, click on the element. This time, there will be no NoSuchElementException *as the driver is focused on the current frame window, and the element is inside the same iFrame to which we switched earlier using the *switchTo() method.

Lastly, switch back the driver to focus on the main window as this is from where all interactions are started.

*Protect your XML data with our online free XML Escape tool. Quickly escape your code and be assured from vulnerabilities with just a few clicks! *

Executing the above test case would give a successful response like the one below.

Bonus: NoSuchElementException in Java

In Java, this exception can be thrown by various methods that can be used for data retrieval to indicate that the element requested does not exist.

For example, if you try to retrieve data from an empty data structure or (n+1)th element from a data structure of n length, then *NoSuchElementException *is thrown.

To fix the NoSuchElementException, it should be ensured that the underlying data structure contains more elements before trying to retrieve the next element or by implementing proper exception handling using try-catch mechanisms.

Fixing NoSuchElementException in Java

Let’s look at the example to fix *NoSuchElementException *in Java. For this, we keep using the same project setup and add another test class to understand this.

Test Scenario:

Create a HashMap.
Add 2 elements to this HashMap.
Create an object of Iterator to fetch keys from HashMap.
Execute the next() function of the iterator 3 times to fetch data.

Now, since we have added only 2 elements, this example should throw a NoSuchElementException.

@Test
   public void testNoSuchElementException()
   {
       HashMap<Integer, Integer> map = new HashMap<>();
       map.put(1, 1);
       map.put(2, 2);

       Iterator itr = map.keySet().iterator();
       System.out.println("first element : " + itr.next());
       System.out.println("second element : " + itr.next());
       System.out.println("third element : " + itr.next());
   }

Executing above code you should get an output like below:

From the above screenshot, you can see this test throws *NoSuchElementException *as there is no third element.

To fix this NoSuchElementException, we use the hasNext() function of the Iterator. This function is used to fix this exception, as before trying to fetch and print the element, it helps to check whether an element is present. If it finds more elements, it continues to print. Otherwise, it helps to stop the flow without any exceptions.

@Test
   public void testNoSuchElementExceptionFixed()
   {
       HashMap<Integer, Integer> map = new HashMap<>();

       map.put(1, 1);
       map.put(2, 2);

       Iterator itr = map.keySet().iterator();

       while(itr.hasNext()) {
           System.out.println("Element : "  + itr.next());
       }
   }

On executing the same test with this fix, you can see that the test passed without NoSuchElementException.

*Don’t let CSV errors slow you down. Validate and lint your CSV data with ease using our free online CSV Validator tool. Get accurate and error-free results in seconds! *

Conclusion

With this, we have come to the end of this blog. In this blog on how to fix *NoSuchElementException *in Selenium, we have learned what a *NoSuchElementException *is and why it could occur while working with Selenium. We also take some example automation scripts and try to understand how it can be fixed and handled more gracefully to prevent abrupt results. So, it’s time to fix all such cases in your automation scripts and get started.

How To Perform Storybook Visual Testing

Vipulgupta9090 — Tue, 02 Jan 2024 10:49:21 +0000

Consider working on a website to provide customers with the best possible user experience and seamless flow. While testing the website, you might find all automated tests passing on all browser and platform combinations with zero issues. However, as soon as the website goes live, bug reports come in large numbers.

These bugs are not related to the website’s functionality but to its user interface and user experience. They affect the website’s appearance, making it less user-friendly regarding its usability, navigation, and visual appeal. This is because automation testing typically only checks the flow, not whether the user interface (UI) appears correctly. Automation testers have been greatly concerned about this and are looking for ways to deal with it.

Make your XML code easy to read and understand with our free online XML Prettify tool. Format your code for better readability and save time!

The solution to this problem is visual testing. It helps to verify the visual behavior of the AUT (Application Under Test) and checks if the visual aspects of the website, such as the shape, size, color, and positioning of the elements on the webpage, are correctly placed and aligned as per the expected design on different browsers and their versions, operating systems, and screen sizes.

This is important because each platform, browser, and screen size has different properties, such as resolution and support for different fonts and colors. These properties must be verified to ensure the website looks and functions correctly on all platforms and devices, thus not restricting customers to certain platforms.

One of the most popular visual testing tools is Storybook, which we will implement in this blog. Storybook is an open-source tool for developing and testing user interfaces (UIs) in isolation from the rest of an application. Each piece of UI in Storybook is an independent component.

One advantage of components is that we don’t need to load the entire application to test a specific UI component. We can render the component in isolation and test it before moving on to the rest of the application. This helps us focus on each variation of a visual component, even the hard-to-reach edge cases. It also ensures that the component behaves consistently across platforms and versions.

In this blog on Storybook visual testing, we will learn about visual testing and its importance for web applications. We will also know about Storybook, how it works, and how to integrate it with web projects. To demonstrate Storybook visual testing, we will use a cloud platform like LambdaTest to access various browsers and operating system versions to test the web interface for the best results.

Let’s get started.

What is Visual Testing?

Visual testing is a software testing technique that verifies and validates an application’s Graphical User Interface (GUI). It focuses on the visual aspects of the GUI, such as layouts, colors, fonts, images, and overall aesthetics, to ensure that they are consistent, correct, and visually appealing across different platforms and devices.

Need to convert hex to decimal? Our online Hex to Decimal Converter tool converts hexadecimal to decimal numbers quickly. Get your conversions done in no time.

Consider a scenario of login screen version 1 like the one below:

This screen was updated to accommodate two new buttons, but that leads to alignment issues like in below version 2:

Such visual issues can be more prominent while working with web applications and lead to a bad user experience.

Conducting visual testing helps to enhance the user experience, maintain brand consistency, and prevent visual defects in applications, ultimately leading to a more polished and user-friendly product.

It can also identify issues related to responsiveness and multimedia elements, such as logos, icons, videos, and animations. Human testers can perform visual testing manually or using automated scripts and tools like Storybook. Automated visual testing compares the UI under test with reference images or expected results to detect discrepancies.

*Keep your data safe and secure by using our free online Base64 Encode. With our tool, you can easily convert any type of data into a secured Base64 string. Try it now! *

How is Visual Testing different from Functional Testing?

Visual and functional testing are two types of testing that verify different aspects of an application. Visual testing focuses on the appearance and user interface, while functional testing focuses on the application’s features. Functional testing verifies that the application works as expected, while visual testing verifies that the application’s visual elements appear correctly on different devices, browsers, and operating systems.

Visual testing is often used in conjunction with functional testing to ensure that an application is both functional and visually appealing.

How does Visual Testing Work?

Visual testing works by comparing screenshots. It does this by comparing the actual UI to a base screenshot of the page.

The base image is captured and is used as a reference whenever the visual test is executed. Each test run generates a new screenshot, which is then compared to the base screenshot. If any differences are found, the test is marked as failed. Otherwise, it is passed.

In the comparison above, the first image perfectly matches the baseline and passes, while the second image fails because of the many visual differences. These differences are all major and cannot be ignored, so the visual test is marked as failed.

**Binary to Decimal Converter is a tool that converts binary numbers into their equivalent decimal form. Simply enter a binary number and let this converter do it for you. https://www.lambdatest.com/free-online-tools/binary-to-decimal**

However, these differences can sometimes be minor, such as a slight change in color tone due to resolution differences or a different font due to an unsupported font on some platforms or versions. In these cases, the tool or framework used for visual testing should ideally have some built-in intelligence in the comparison algorithm to avoid such failures and only highlight major UI variations.

Why is Visual Testing Important?

Visual testing, like other software testing techniques, is integral to working with web applications. It provides numerous benefits when performed and helps produce more visually reliable results. These include:

**Browser — Device Compatibility and Responsiveness
**Visual testing ensures an application’s user interface (UI) looks and behaves as expected across different devices and platforms. This includes checking on various operating systems (OS), browsers, screen sizes, and orientations.
**Consistent User Experience
**Visual testing ensures the visual aspects of a user interface (UI) are correct and consistent. It helps to identify and fix issues with the layout, colors, fonts, and other visual elements of a UI, which can lead to a better user experience and satisfaction.
**Verify Images & multimedia
**Verifying that all images and other multimedia elements are displayed correctly and in the intended resolutions is useful. This includes checking that the images are not pixelated or blurry on different platforms and screen sizes and that the videos play smoothly.
Additionally, visual testing helps ensure that the images and videos are aligned correctly with the surrounding text and other elements on the page. By doing so, visual tests help to make web applications visually appealing and user-friendly.
**Testing Localization
**Visual testing is strongly advised when developing applications for international customers with diverse languages, cultures, and formats. It aids UI testing and ensures element consistency for different locales with minimal effort.

All the advantages of visual testing strongly advocate its usage while working with web applications to be used with a wide, varied customer base.

**Decimal to Binary Converter is a free online tool that will give you the binary equivalent of any decimal number. Enter your number, then simply click ‘convert’. **

When performing visual testing, it is essential to know its limitations. Visual testing is only suitable for certain types of applications, as it is limited to UI verification. Additionally, it can be time-consuming and resource-intensive for larger applications, which can add to maintenance overhead. Being mindful of these helps one make an informed decision on the extent of visual testing.

What is a Storybook?

Storybook is an open-source tool that lets you build, organize, and test user interface (UI) components in isolation. It is commonly used in web development, especially for building and testing components in JavaScript and related frameworks like React. Storybook allows testers to visualize, test, and debug the different states of UI components independently from the rest of the application.

In Storybook, each webpage is considered a story. A story represents the state of web elements in different environments. In a Storybook project, the first execution is always stored as-is, and the images from it are considered the base images or baseline. In this case, no screenshots or images are compared, and all are marked as approved. In subsequent runs after this one, you can see passed/failed stories based on the mismatch percentage, as screenshots are compared to this baseline.

The Storybook community is thriving with an impressive milestone. The Storybook Monorepo has surpassed 81,200 GitHub Stars, solidifying its position as one of the most popular repositories ever.

What is a Story?

In Storybook, each webpage is considered a story. A story represents the state of web elements in different environments. It captures the rendered state of a UI component.

What is a component?

Each piece of UI in Storybook is an independent component. With components, we don’t need to load the entire application to test a specific UI. We can render the component in isolation and test it before moving on to the rest of the application.

*A tool that converts decimal numbers into equivalent octal representation. Input a decimal number and click ‘Convert Decimal to Octal’ to get the result in seconds! *

How does a Storybook compare different components and stories?

In a Storybook project, the first execution is always stored as-is, and the images from it are considered the base images or baseline.

In this case, no screenshots or images are compared, and all are marked as approved.

In subsequent runs after this one, you can see passed/failed stories based on the mismatch percentage, as screenshots are compared to this baseline.

*A tool that converts decimal numbers into equivalent Hexadecimal representation. Input a decimal number and click ‘Convert Decimal to Hex’ to get the result in seconds! *

Advantages of Using Storybook

There are many reasons why Storybook is the best choice for visual testing. Some of them are:

**Component Development and Isolation
**Storybook allows you to create, showcase, and test individual UI components in isolation. A component is a small piece of UI. This is especially useful when working with complex applications, as it allows you to focus and test a single component at a time without navigating through the entire application.
**Component Documentation
**Storybook encourages the documentation of UI components by creating stories for each component. A story represents a component’s state and can include different variations for different environments. These stories serve as living documentation for the components, making it easier to understand and test how these should be used and how they look.
**Automation and Regression Detection
**Visual testing in Storybook can be automated using various tools, such as Chromatic or custom scripts. When code changes are made to the UI, visual testing tools can take screenshots and compare them to baseline images. If there are any differences, such as unexpected layout changes or styling issues, the tool can flag them, which helps to catch visual bugs early in the development process.
**Collaboration
**Storybook is a tool that can be used by developers, designers, and testers to collaborate on projects. Testers can use it to perform visual tests to verify the UI, designers can use it to see how components will appear in the final application, and developers can use it to receive feedback and bugs and iterate on them more effectively.
**Integration with Other Tools
**Storybook can be integrated with various testing tools and platforms, including cloud-based platforms like LambdaTest SmartUI, which we will use in this blog. It can also be integrated with version control systems, continuous integration (CI) pipelines, and design systems to ensure consistency and quality in UI development.

*Need to convert CSV to JSON? Try our free CSV to JSON converter tool to convert your CSV files to JSON format. Simple and easy to use. Try it now for free! *

Demonstration: How to perform Storybook Visual Testing?

Having understood and learned the basics about visual testing and Storybook, it is time to move to the demonstration. This section will show how Storybook visual testing can be performed for your application.

As mentioned previously, to perform Storybook visual testing, we will use SmartUI, a tool provided by the cloud-based LambdaTest platform.

LambdaTest is an AI-powered test orchestration and execution platform that lets you run manual and automated tests at scale with over 3000+ real devices, browsers, and OS combinations.

SmartUI is a LambdaTest tool that combines the robustness of cloud-based platforms with the accuracy of visual testing. It helps automate identifying and tracking visual changes in the user interface (UI) over time, which helps release more consistent applications. SmartUI uses cloud benefits to provide precision, collaboration, and scalability. Using LambdaTest enables you to test your application on a combination of 3000+ OS and browser versions, ideally serving the aim of Storybook visual testing for the visual elements.

Pre-requisites

Install Storybook

Install Storybook using the below command. You can check more details on installation on its official website.

npx storybook@latest init

Make sure you install a version higher than 6.4.0 for best results. Refer to Storybook recent releases for more information on Storybook release versions.

Install Node.js

Install Node.js on your system by downloading the installer from the official website. For compatibility reasons, ensure the installed version is higher than 14.15.0. If you need more details on the previous versions, you can check here.

*Looking to convert binary to hex? Convert binary numbers to hex with ease using our free online Binary to Hex Converter tool. Perfect for developers and coders. *

LambdaTest SmartUI credentials

Create your account on the LambdaTest platform to access SmartUI and perform Storybook visual testing.

SmartUI Project Setup on LambdaTest

After completing the prerequisite setup, the first step is to create a SmartUI Project on LambdaTest. In this project, we will combine all your executed builds for our Storybook visual test cases.

Step 1. Login to your LambdaTest account and select Smart UI.

Step 2. Click on the New Project button to create your SmartUI Storybook project.

Step 3. For Storybook tests, select the platform as Web. Add project name, approvers for the changes, and tags for filters or easy navigation.

Step 4. Click on Submit to create your first project. You can see no build and the token is available inside the project.

This token will be used in the next steps to link the project execution results on SmartUI.

*From SQL to JSON in a snap! Convert SQL queries to JSON effortlessly with our SQL to JSON converter, enhancing compatibility and data interchange. Try it now! *

Storybook Code Setup and Execution: Creating Baseline

For this blog demonstration on performing Storybook visual testing, we will reference the code from the GitHub repo below. This is a sample project to execute your first Storybook SmartUI project for visual testing.

Step 1. Clone the project from this GitHub repo.

git clone https://github.com/LambdaTest/smartui-storybook-sample.git

Step 2. Install the required NPM dependencies for LambdaTest Smart UI Storybook visual test execution.

npm install @lambdatest/smartui-storybook -g

Step 3. Verify that the .storybook directory is added to your main.js project. It should contain the following code. If not, add the same to it.

module.exports = {
   features: {
     buildStoriesJson: true,
   },
 };

Step 4. Install the Storybook node module inside your project using npm.

npm install

Once this is done, you should see @storybook under your < current-dir >/node_modules folder like below.

Step 5. Configure the SmartUI project token for the demo project that we created initially.

export PROJECT_TOKEN="123456#1234abcd-****-****-****-************"

Step 6. As mentioned, LambdaTest SmartUI provides configurations to execute visual tests on several available browser + OS combinations. These configurations are defined inside smartui.json.

Execute the following command to generate this configuration JSON.

smartui config create .smartui.json

Once the smartui.json file is created, you can see the default configurations in the same.

{
 "storybook": {
   "browsers": [
     "chrome",
     "firefox",
     "safari",
     "edge",
     // Add more browser configuration here
   ],
   "viewports": [
     [1920, 1080]        // Add more view ports to capture here
   ],
   "waitForTimeout": 0, // (Optional) Add wait time for the page to load
   "include": [],       // (Optional) Only compare limited stories
   "exclude": []        // (Optional) Don't compare the stories
 }
}

The configurations can be modified as per your requirements by changing the key-values on this JSON.

Stop using the same password for everything! Create strong and unique passwords that are difficult to guess with our Random Password Generator. Try it now!

Step 7. Build your Storybook application, in this case, the repo code, as a static web application. Storybook will create a static web application capable of being served by any web server for your code, which can be previewed locally on any system by sharing the application code.

npm run build-storybook

Executing this command should create an output directory /storybook-static/ from which the code will be built for execution on SmartUI.

Step 8. Finally, we execute the Storybook visual tests on the SmartUI cloud using the storybook static build created in previous steps.

smartui storybook ./storybook-static --config .smartui.json

This command would trigger the run to create a Baseline, as this is the first execution. All stories would be approved automatically for this execution.

You can view the created baseline for Storybook visual tests on SmartUI by navigating to your project on the LambdaTest Dashboard. This build will be created on the master branch.

With this, we have created a baseline for the stories to be executed further to perform Storybook visual tests. Let’s move forward to change any story, re-execute the run, and see results.

Storybook SmartUI Execution: Committed Code Changes

In this section, we see how SmartUI triggers the storybook visual test on changes committed to the existing code.

Step 1. Open src/stories/Page.stories.jsx story file and make some changes to it. For this demonstration, I have updated the value from Log in to Log out.

Step 2. Add the file with changes to GitHub. SmartUI uses the GitHub commitid for the comparison.

git add src/stories/Page.stories.jsx

Step 3. Commit the changes with a proper commit message. This message will be visible on the LambdaTest SmartUI project to identify the execution of a particular commit.

git commit -m "Demo blog changes in Page.stories.mdx"

Step 4. Execute the Storybook visual tests on the SmartUI cloud again as previously done. This time, it will give the comparison results and highlight failures if any mismatches occur.

smartui storybook ./storybook-static --config .smartui.json

You can see the output results on the CLI below.

Execution results on the SmartUI dashboard can be viewed for the particular commit.

With this, we have learned how Storybook visual testing works with LambdaTest SmartUI. So, use this powerful integration of tools and platforms to build a robust visual testing architecture for your static web applications.

*Generate custom QR codes for your business or personal needs with our fast and easy-to-use QR code generator online tool in seconds. Try it now! *

Conclusion

This concludes our blog on how to perform Storybook visual testing. In this Storybook testing tutorial, we learned about visual testing, its advantages and disadvantages, and why it is needed in web software development. We also understood about Storybook and its benefits for visual testing. Lastly, we saw how Storybook visual tests can be configured and executed on the LambdaTest SmartUI cloud platform to take advantage of a cloud platform and execute on various OS and browser combinations. It’s time for you to get started and perform Storybook visual tests on SmartUI for the best results and performance. Happy testing!

How to Handle Auto Suggestions in Selenium Java

Vipulgupta9090 — Wed, 09 Aug 2023 11:03:55 +0000

You may have observed that when searching on Google or browsing through an eCommerce platform, automatic suggestions appear almost instantly as you start typing. These suggestions, known as auto-suggestions, are intended to provide a rapid guide to potentially relevant keywords and top searches based on your input. As you type in the search box, the website presents a list of auto-suggestions to aid in refining your search and quickly accessing relevant information.

Automating website interactions with Selenium to handle auto-suggestions can present challenges due to the dynamic nature of these suggestions. Unlike static text on a web page, auto-suggestions form a constantly changing list, adapting to the input provided by users.

This blog delves into the intricacies of handling auto-suggestions in Selenium Java for web automation. We will explore different techniques to automate these suggestions in web automation scripts while gaining valuable insights into the dynamics of auto-suggestions. Additionally, we’ll address potential challenges during the automation process.

By the end of this blog on handling auto-suggestions in Selenium, you will be able to use different techniques to handle auto-suggestions and implement them in your automation scripts. So, let’s get started to explore the world of auto-suggestions!

What is Auto-Suggestion?

Auto-suggestion or auto-complete functionality offers potential suggestions to users based on their input in a search box or any other input field on a webpage. These suggestions aim to assist users in finding relevant information or completing their input more efficiently.

These are implemented as a drop-down list with a list of possible suggestions as the user proceeds to input. This helps the user select the desired term from the list without entering it completely.

Dynamic lists of suggestions change with user input, facilitated by AJAX (Asynchronous JavaScript and XML) requests. This ensures a seamless user experience as they type, with suggestions fetched from a server or API in the background.

Also, learn the ins and outs of test execution engines through our extensive guide, and enhance your testing workflow with automation.

Auto-suggestions are quite helpful since they rely on AJAX queries to provide relevant options in advance, which helps to shorten the time it takes to search for a term. These auto-suggestions also have wide applications in eCommerce and fintech domains, facilitating quick product searches and helping list all related ones.

This detailed guide explains how to detect flaky tests, its causes, strategies to reduce flakiness and much more.

Advantages of Auto-Suggestions

Auto-suggestions, or predictive search, offer several benefits by improving user experience using AJAX requests for quicker search. Here are some advantages that make auto-suggestions a popular strategy on any website.

Enhanced User Experience
Improved Search Efficiency
Higher Accuracy due to auto corrections
Mobile-Friendly Experience

Discover how TestRunner is transforming the world of automated testing. Explore its key features and benefits. Improve testing processes today with TestRunner.

Challenges of Handling Auto-Suggestions in Selenium

Auto-suggestions offer significant advantages for enhanced performance, as they provide relevant information about website topics without loading the entire content. This helps to save user time and effort in browsing through all the content on a website.

However, the content is dynamic; hence, we need to use the right approach in automation to handle the dynamism factor. Also, loading results might take time depending on external factors (particularly Internet speed). This becomes challenging while handling auto-suggestions in Selenium automation. Let’s look at some of these common challenges before we learn handling auto-suggestions in Selenium Java testing.

Delay in auto-suggestion list

The auto-suggestion list depends on asynchronous calls to show results. Sometimes, this can lead to timing issues if Selenium tries to interact with it instantly, and the suggestion list may not have fully loaded. This can also happen due to a flaky Internet connection in the test environment.

Highly dynamic content

Auto-suggestions are dynamically generated based on the search term. Even the slightest change in the same search term, like adding an extra space or any other character, can change the suggestions in the list. This becomes challenging while working with Selenium automation if specific web element locators are used.

Test native, hybrid, and web apps on any mobile OS with our free Android emulator online. Sign up to optimize app performance.

Best Practices for Handling Auto-Suggestions in Selenium

To overcome the challenges discussed above and make handling auto-suggestions in Selenium robust, we follow many practices while writing automation tests. Here are some of these best practices we will follow in the next demonstration section.

Using Explicit Waits

As previously mentioned in the challenges, the auto-suggestions list may experience delays in loading, potentially causing failures if the Selenium script attempts to interact with it immediately. To address these concerns, it is strongly advised to wait for the auto-suggestion list to fully load before interacting with it. Explicit waits in Selenium are particularly valuable for handling such situations.

Explicit waits and ExpectedConditions in Selenium make the automation test wait for a certain element before proceeding. In our use case, this web element would be the auto-suggestion list.

Unique WebElement locators

Handling auto-suggestions in Selenium can become a nightmare if proper and unique webElement locators are not used. This is because they are highly dynamic, and web element locators might keep changing based on input.

So, it is suggested to use unique locators such as ID, name, or class, which are rarely changed and help to interact with the list irrespective of search input term. Also, always remember not to use any such locator strategies with the search term reference in it, as the term might vary on each run and would make the locator obsolete.

Verifying the suggestion value

To select the correct term from the auto-suggestion list, you should always verify the value before selecting it to reach the results page. Consider the case-insensitive approach when making this comparison, as the results of different auto-suggestion runs may vary.

Selenium assertions can be used to verify that the search term on the results page is similar to the expected value.

Using keyboard events

One of the most common ways for handling auto-suggestions in Selenium automation is to use keyboard events like the arrow down key and enter button. This is recommended when selecting the first or second element from the list in your automation case without comparing the value.

From the above code snippet, you can see that we want to click on the 2nd element from the list. For the same, a for loop has been created to press the arrow down key using the sendKeys() method in Selenium.

Once the desired element from the list is reached, for loop breaks, the sendKeys() method is used again to hit the Enter button to select that option.

For this, we can also use ActionsChains in Selenium Java to create a chain of actions using the Actions class. This helps to perform low-level mouse actions like click, drag, hover, or keyboard actions using the WebDriver instance.

In this blog, we cover only the sendKeys() method implementation for handling auto-suggestions in Selenium Java. This is because, in this scenario, ActionChains is not required as we only have two quick key actions to perform.

So, we have understood the challenges and the best practices that would help in handling auto-suggestions in Selenium. Let us look at some practical implementations of how these can be used in Selenium Java automation projects.

Elevate Your Mobile App Test Quality: Make the most of your mobile application testing & Test on LambdaTest Cloud for Comprehensive Testing, Bug Detection & More.

Demonstration: Handling Auto-Suggestions in Selenium Java

To demonstrate the best approaches for handling auto-suggestions in Selenium automation, we will create a Java project with Maven and TestNG using Selenium 4.

The following test scenarios will be automated in this blog to help understand all the approaches and best practices discussed so far.

Test Scenario — 1 (Handling auto-suggestions in Selenium by fetching auto-suggestion list)

Navigate to https://www.google.com.
Enter lambdatest as the search term in the search box.
Wait for the auto-suggestion list to be available.
Fetch WebElement reference to all the auto-suggestions and store in a List variable of type WebElement.
Start a loop to traverse each WebElement from the list.
Compare if the auto-suggestion matches the required term.
If it matches, select the same by clicking and breaking the loop. Else, continue until the end of the list Wait for the search results page to load.
Assert that the search term on the results page is the same as expected or not.

Test Scenario — 2 (Handling auto-suggestions in Selenium using sendkeys())

Navigate to https://www.google.com.
Enter lambdatest as the search term in the search box.
Wait for the auto-suggestion list to be available.
Start a loop to reach the 2nd suggestion from the auto-suggestions list by clicking the down arrow key.
Click Enter on this term.
Wait for the search results page to load.
Assert that the search term on the results page contains the initially given search keyword.

Test Scenario — 3 (Handling auto-suggestions in Selenium using web scraping: Google)

Navigate to https://www.google.com
Enter **lambdatest **as the search term in the search box.
Wait for the auto-suggestion list to be available.
Fetch WebElement reference to the auto-suggestions list and store it in a variable.
Start a loop to scrape (or scrap) the suggestion data for each term from the auto-suggestions list.
Compare if the list data from web scraping matches the required term.
If it matches, select the same by clicking and breaking the loop. Else, continue until the end of the list
Wait for the search results page to load.
Assert whether the search term on the results page is the same as expected.

Automate Cypress testing and perform browser automation testing with LambdaTest. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

Project Setup

In this blog, Eclipse IDE is used for creating the project. You can also choose any other IDE of your choice.

For all the test scenarios in this blog, the same project setup is being used. We keep adding new test cases for each scenario in a new test file. So do the setup carefully on your machine to avoid any errors at the execution stage.

All the test scenarios demonstrated in this blog are Selenium web automation scripts. We will be executing them on a cloud Selenium Grid. Using a Selenium cloud Grid offers improved speed and scalability and makes automation testing faster and more reliable. It also allows executing multiple cases across various browsers and OS.

To achieve the same, the LambdaTest cloud Selenium Grid is being used in this blog. LambdaTest is an AI-powered test orchestration and execution platform that empowers users to conduct Java automation testing for web and mobile applications across a vast array of over 3000+ real browsers, devices, and operating system combinations.

Check out the documentation on how to get started with Selenium testing with Java on LambdaTest.

Additionally, it provides a diverse selection of automated testing tools and frameworks such as Selenium, Cypress, Playwright, and Appium, enabling efficient execution of test cases.

Step 1. Launch Eclipse IDE and create a new Maven project, HandlingAutoSuggestionsSelenium.

Step 2. Add 2 new packages inside the src package and name them as base *and *test.

Step 3. Add a Java class file inside the base package and name it BaseTest.java. This file will have the common code for all test cases, like initializing the WebDriver, browser interactions, and doing the initial search for the auto-suggestion list.

Step 4. Add 3 Java class files under the test package. These will have the code for our different test scenarios.

Once all these steps are done, the project structure should look like this:

As we use Selenium and TestNG for our project, add Selenium 4 and TestNG dependencies inside the pom.xml. Using the latest stable versions of the project is recommended for the best results.

The final pom.xml would be like the one below.


    <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>HandlingAutoSuggestionsSelenium</groupId>
       <artifactId>HandlingAutoSuggestionsSelenium</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <build>
           <sourceDirectory>src</sourceDirectory>
           <plugins>
               <plugin>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <version>3.8.1</version>
                   <configuration>
                       <release>19</release>
                   </configuration>
               </plugin>
           </plugins>
       </build>
       <dependencies>
           <dependency>
               <groupId>org.seleniumhq.selenium</groupId>
               <artifactId>selenium-java</artifactId>
               <version>4.8.3</version>
           </dependency>
           <dependency>
               <groupId>org.testng</groupId>
               <artifactId>testng</artifactId>
               <version>7.7.1</version>
               <scope>test</scope>
           </dependency>
       </dependencies>
    </project>

Next, we move to BaseTest.java. This file will have the primary driver functions like initialize driver, quit driver, etc.

package base;


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


    import org.openqa.selenium.By;
    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.openqa.selenium.safari.SafariOptions;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.openqa.selenium.support.ui.WebDriverWait;
    import org.testng.annotations.AfterTest;
    import org.testng.annotations.BeforeTest;


    public class BaseTest {


       public RemoteWebDriver driver = null;
       public WebDriverWait wait;


       String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME");
       String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" : System.getenv("LT_ACCESS");


       @BeforeTest
       public void setup() {
           try {
               SafariOptions safariOptions = new SafariOptions();
               safariOptions.setPlatformName("MacOS Ventura");
               safariOptions.setBrowserVersion("16.0");


               HashMap<String, Object> ltOptions = new HashMap<String, Object>();
               ltOptions.put("build", "Auto Suggestions in Selenium");
               ltOptions.put("name", "Handling Auto Suggestions");
               ltOptions.put("w3c", true);
               safariOptions.setCapability("LT:Options", ltOptions);


               driver = new RemoteWebDriver(
                       new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), safariOptions);
           } catch (MalformedURLException e) {
               e.printStackTrace();
           }
       }


       @AfterTest
       public void tearDown() {
           driver.quit();
       }


       /*
        * 1. Navigate to Google 2. Enter search term 3. Wait for auto-suggestions list
        * to be visible
        */
       public void navigateToGoogleAndSearch() {
           // to navigate to the website and enter the search term
           System.out.println("Navigating to the website");
           driver.get("https://www.google.com");


           System.out.println("Entering search term as lambdatest");
           driver.findElement(By.name("q")).sendKeys("lambdatest");


           // explicit wait to wait for the auto suggestions list to be present
           wait = new WebDriverWait(driver, Duration.ofSeconds(10));
           wait.until(ExpectedConditions.presenceOfElementLocated(By.xpath("//*[@role='listbox']")));
           System.out.println("Auto-suggestions list found");
       }
    }

This guide explores Digital Transformation, its benefits, goals, importance and challenges involved in Digital Transformation.

Code Walkthrough

*Step 1. **Create an object of *RemoteWebDriver and initialize it as null.

Also, create an object of WebDriverWait, which will be used at later stages to implement explicit waits. This wait object will allow the code to wait for a given time until a given condition is fulfilled before moving forward.

Step 2. Fetch the username and access key for your LambdaTest Account from the LambdaTest Password & Security section to connect to their cloud grid.

Alternatively, you can configure these as environment variables and directly fetch them in code.

For macOS and Linux:

 export LT_USERNAME=LT_USERNAME
    export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

 set LT_USERNAME=LT_USERNAME
    set LT_ACCESS_KEY=LT_ACCESS_KEY

Step 3. Next, add a method and name it setup(). This will contain the code for WebDriver initialization using browser properties and LambdaTest cloud Selenium Grid properties. Annotate this with the @BeforeTest annotation in TestNG to execute it before each test execution.

*Step 4. **Create an object of *SafariOptions class. This will help to set the required browser properties on which the tests are executed. Using this, set the OS and browser versions.

Step 5. Use a Hashmap type variable to specify the additional browser capabilities required by the LambdaTest platform to support test execution on their Selenium cloud grid. This will help to identify the test results on the dashboard using the build name and other details.

We can also fetch the required browser capabilities for the LambdaTest platform by navigating to Automation Capabilities Generator. This helps by offering ready-to-use code for setting up browser capabilities that can be used in execution.

Step 6. Finally, use the Selenium RemoteWebDriver to connect to the LambdaTest remote grid using your credentials and safariOptions object containing all specified browser capabilities.

Step 7. Add a new method, tearDown(), and annotate it with @AfterTest. This will be called after each test execution to close the browser and terminate the web driver session.

Step 8. Finally, we add the last utility method to this base file, containing common steps for each test scenario.

8.1) Use the driver.get() method to navigate to the website under test.

8.2) Fetch the web element of the search input box and enter the search term.

We are using the *name *locator here to locate this web element.

8.3) Instantiate the WebDriverWait class object we initially created, with the maximum time to wait for any condition as 10 sec. This will block the WebDriver for the given time, preventing it from performing any further action and unblocking it as soon as the condition is fulfilled.

8.4) Using this wait object, we implement ExpectedConditions in Selenium, which tells the driver to wait for the given web element to be visible. In this case, we wait for the auto-suggestions list to be visible before proceeding with different approaches.

Which are the most wanted automation testing tools in 2023 that have climbed the top of the ladder so far? Let’s take a look.

Handling Auto-Suggestions in Selenium using the auto-suggestion list

First and the most used approach for handling auto-suggestions in Selenium automation script is by traversing the whole auto-suggestion list and comparing the values to select the required one. This is highly useful when we already know the exact search term we are looking for and do not wish to select any random one.

It’s crucial to remember that, depending on the geolocation, the same search query would provide a different auto-suggestion list. This occurs because the same term may have different references in different places, or occasionally it may refer to something in one place while generating no results in another. So be careful and determine an accurate search term for your test case while applying this strategy.

package test;


    import java.util.List;


    import org.openqa.selenium.By;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.testng.Assert;
    import org.testng.annotations.Test;


    import base.BaseTest;


    public class TestUsingSuggestionsList extends BaseTest {


       @Test
       public void testUsingAutoSuggestionsList() {


           String expectedSearchTerm = "lambdatest careers";


           navigateToGoogleAndSearch();


           // to fetch the webElement for all the suggestions from list
           List<WebElement> autoSuggestionList = driver.findElements(By.xpath("//*[@role='option']"));


           // to traverse the list and navigate to required suggestion search results
           for (WebElement autoSuggestion : autoSuggestionList) {
               System.out.println("Auto Suggestion Value : " + autoSuggestion.getText());
               if (autoSuggestion.getText().equalsIgnoreCase(expectedSearchTerm)) {
                   System.out.println("\nFound required value in auto suggestion list. Clicking on it now\n");
                   autoSuggestion.click();
                   break;
               }
           }


           // wait for the search results page to load and verify if it has the same term as we
           // expected.
           wait.until(ExpectedConditions.presenceOfElementLocated(By.xpath("//*[@type='search']")));
           Assert.assertEquals(driver.findElement(By.xpath("//*[@type='search']")).getText(), expectedSearchTerm,
                   "Valid Search result page.");
           System.out.println("Reached to google search result page for : " + expectedSearchTerm);
       }
    }

Code Walkthrough
Step 1. Add a new Java file under the test package, TestUsingSuggestionsList. This class will extend BaseTest.java to inherit the common methods and variables from it.

Step 2. Add the test case as testUsingAutoSuggestionsList() and annotate it with @test annotation.

Step 3. Set the expected search term in a variable that we will find from the auto-suggestion list and then assert on the results page at the end.

*Step 4. **Call the *navigateToGoogleAndSearch() of BaseTest.java to navigate to the website, enter the search term, and wait for the auto-suggestion list to be visible.

Step 5. Next, we fetch the list of all the auto-suggestion options using a web element locator and store them in a variable.

The screenshot below shows that we are using role attributes to fetch the entire list. It gives a total number of occurrences, and each can be visited individually in the code.

Step 6. Start a loop to traverse this list of suggestions and fetch the values from it. We first log each value found and then compare it with the actual expected term.

If both matches, the loop is stopped, and that particular auto-suggestion value is clicked. If it is not a match, we continue the loop.

Step 7. Wait for the search results page for the selected term to load.

We use the same WebDriverWait object again, but this time ExpectedConditions is implemented to wait for a different element on the results page.

Step 8. Finally, assert that the search term on this page matches the expected search term. You can learn more about it through this blog on assertions in TestNG.

Executing this test case would give you an output like the below:

Execution logs on the LambdaTest Dashboard for this would look like the below. You can notice that all the auto-suggestion list values are being fetched.

Don’t miss out on thе latеst tutorials on automation tеsting! Subscribe to thе LambdaTеst YouTubе Channеl for tutorials on Sеlеnium tеsting, Playwright testing, and more.

In this blog on the mobile automation testing tools, we list the best 11 mobile automation testing tools with their advantages and business-friendly features.

Handling Auto-Suggestions in Selenium using sendKeys()

This approach to handling auto-suggestions in Selenium using keyboard key actions is useful when we do not have a predefined target search term to be selected. It is used in cases when only handling the auto-suggestions list and selecting a term is the requirement of our Selenium test case.

package test;


    import org.openqa.selenium.By;
    import org.openqa.selenium.Keys;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.testng.Assert;
    import org.testng.annotations.Test;


    import base.BaseTest;


    public class TestUsingKeyActions extends BaseTest {


       @Test
       public void testUsingArrowKeys() {


           navigateToGoogleAndSearch();


           // if we want to specifically click on the second term from auto-suggestions
           // list
           for (int i = 1; i < 3; i++) {
               driver.findElement(By.name("q")).sendKeys(Keys.ARROW_DOWN);
               System.out.println("Pressing down arrow key to reach " + i + " search term");
           }
           System.out.println("Hitting enter key on the required search term");
           driver.findElement(By.name("q")).sendKeys(Keys.ENTER);


           // wait for the search results page to load and verify if it has the same term as we
           // expected.
           wait.until(ExpectedConditions.presenceOfElementLocated(By.xpath("//*[@type='search']")));
           System.out.println(
                   "Search term on results page: " + driver.findElement(By.xpath("//*[@type='search']")).getText());


           // verify that search term on results page consists of the initial input term given
           Assert.assertEquals(driver.findElement(By.xpath("//*[@type='search']")).getText().contains("lambdatest"), true,
                   "Valid Search result page.");
           System.out.println("Reached to search result page for given term");
       }
    }

Code Walkthrough

Step 1. Add a new Java test file in the same package and name it TestHandleAutoSuggestions_UsingKeyActions. Just like the previous test file, this will also extend BaseTest.java.

Step 2. Create the test method in this class, testUsingArrowKeys(), and annotate it with @test annotation.

Step 3. The first step in this test case will also be similar to the previous one, i.e., to call the navigateToGoogleAndSearch() method of BaseTest.java to navigate to the test website and get the auto-suggestion list for our search input term.

Step 4. As already mentioned, in this approach, we do not have any specified term to select from the auto-suggestions list. We will use Key actions to press keyboard buttons to reach the 2nd item from the list.

4.1) Initial position for the driver will be the search input box. Keyboard actions will be performed about it. That is why the web element reference on the code is the locator for this box.

4.2) Now, to reach the first value from the list, LambdaTest, we need to press the arrow down key. At this point value for i = 1.

4.3) After this the value for i gets incremented to 2, which is valid to execute the loop again. The keyboard down arrow key is pressed again to reach the next value, lambdatest noida.

4.4) At this step, the value of i = 3, and our condition for the loop to continue fails. This means driver focus has reached the required element.

Step 5. Use the Keys action again to press the enter key on this value and reach the search results page.

Step 6. Wait for the search results page to load with the help of the WebDriverWait object by using ExpectedConditions.

Step 7. Once the search results page is loaded, fetch the search term value from the page.

Assert that this value contains the initial given search term.

An important point to note here is that, unlike the last test case, we would not assert an exact matching term as the code did not select a particular value from the auto-suggestions list by matching it.

On executing this test case, you get output like below.

Explore our in-depth guide comparing Protractor vs Selenium to make informed decisions for your test automation needs. Gain valuable insights into the key differences, advantages, and ideal use cases of these widely-used testing frameworks.

Handling Auto-Suggestions in Selenium using web-scraping: Google

This approach is similar to the first one, i.e., using the entire auto-suggestions list to compare and select the required search term. It only differs in how we access the list and fetch the values from the auto-suggestion list. This approach uses the technique of Web Scraping.

Web scraping is the process of automatically extracting data from websites. It involves writing a program to fetch web pages, parse the HTML content, and extract the desired information. Web scraping enables gathering data for analysis, research, or automation, but it should be done in compliance with website terms and legal regulations.

Let’s look at the below file to better understand how web scraping can be used for handling auto-suggestions in Selenium.

 package test;


    import java.util.List;


    import org.openqa.selenium.By;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.testng.Assert;
    import org.testng.annotations.Test;


    import base.BaseTest;


    public class TestUsingWebScrapping extends BaseTest {


       @Test
       public void testUsingWebScraping_Google() {


           String expectedSearchTerm = "lambdatest careers";


           navigateToGoogleAndSearch();


           // Fetch the list of all suggestions
           System.out.println("Fetching the web element list for all suggestions");
           WebElement autoSuggestionListBox = driver.findElement(By.xpath("//*[@role='listbox']"));
           List<WebElement> autoSuggestionList = autoSuggestionListBox.findElements(By.xpath(".//li"));


           // scrape the autoSuggestionList to get each suggested term for given search
           // term.
           System.out.println("<-------- Started Web scraping for suggestion list -------->");
           for (WebElement listTerm : autoSuggestionList) {
               WebElement term = listTerm.findElement(By.xpath(".//span"));
               System.out.println("Auto Suggestion Value : " + term.getText());
               if (term.getText().equalsIgnoreCase(expectedSearchTerm)) {
                   System.out.println("\nFound required value in auto-suggestion list. Clicking on it now\n");
                   term.click();
                   break;
               }
           }


           // wait for the search results page to load and verify if it has the same term as we
           // expected.
           wait.until(ExpectedConditions.presenceOfElementLocated(By.xpath("//*[@type='search']")));
           Assert.assertEquals(driver.findElement(By.xpath("//*[@type='search']")).getText(), expectedSearchTerm,
                   "Valid Search result page.");
           System.out.println("Reached to google search result page for : " + expectedSearchTerm);
       }
    }

Code Walkthrough

Step 1. Add a new java test file, TestHandleAutoSuggestions_UsingWebScrapping, and extend BaseTest.java to it.

Step 2. Add the first test case, testUsingWebScraping_Google(), and annotate it with the @test annotation of TestNG.

Step 3. Similar to the steps in previous cases, we define an expected search term and call the navigateToGoogleAndSearch() method of BaseTest.java to navigate to Google and enter the search term.

Step 4. This is the most important step when using the web scraping approach.

4.1) First, we need to identify the main container web element in which the entire auto-suggestion list is present.

The screenshot below shows it is inside a < ul > tag with attribute role=”listbox”.

4.2) Inside this element is the list of all auto-suggestion elements. We need to fetch this using the container element reference from the previous step.

Step 5. This web element list hosts the relevant auto-suggestion value data. It is present inside the < span > tag of these elements.

5.1) We start by traversing this list to fetch the required data for each element using a for loop.

5.2) For each element use the < span > tag to get the value. Log the auto-suggestion value for better debugging.

5.3) Compare it with the expected search term. If it matches, click on it and break the loop, if not continue the process.

Step 6. After selecting the search term, wait for the search results page to load and verify if it matches the expected result. This is similar to what we did in previous test scenarios.

Executing the above test case for handling auto-suggestions in Selenium using web scraping would give an output like the below

Boost Your Mobile App’s Performance! Discover Proven Strategies for Mobile Performance Testing. Increase User Satisfaction & Rankings. Get Results Fast.

Bonus: Handling Auto-Suggestions in Selenium using web-scraping: Amazon

Like the last test scenario, this one also uses web scraping to handle the auto-suggestions list and select the required term. In this one, we take the example of a popular eCommerce website, Amazon, to understand the working of auto-suggestions on an eCommerce platform.

A similar strategy can be added to your website’s test automation scripts. You should be mindful that the website’s design or the products’ availability may change. In such circumstances, you just need to change the search term, and the code will continue functioning correctly.

For this, add a new test case to the same file, *TestUsingWebScrapping.java*, and name it *testUsingWebScraping_Amazon()*.

    @Test
    public void testUsingWebScraping_Amazon()
    {
       String expectedSearchTerm = "samsung galaxy s22";

       // to navigate to the website and enter search term
       System.out.println("Navigating to the website");
       driver.get("https://www.amazon.com");


       System.out.println("Entering search term as : samsung galaxy s");
       driver.findElement(By.id("twotabsearchtextbox")).sendKeys("samsung galaxy s");


       // explicit wait to wait for the auto suggestions list to be present
       wait = new WebDriverWait(driver, Duration.ofSeconds(10));
       wait.until(ExpectedConditions.presenceOfElementLocated(By.xpath("//*[@class='left-pane-results-container']")));
       System.out.println("Auto-suggestions list found");

       // Fetch the list of all suggestions
       System.out.println("Fetching the web element list for all suggestions");
       WebElement autoSuggestionListBox = driver.findElement(By.xpath("//*[@class='left-pane-results-container']"));
       List<WebElement> autoSuggestionList = autoSuggestionListBox.findElements(By.xpath(".//div[@class='s-suggestion-container']"));

       // scrape the autoSuggestionList to get each suggested term for a given search term.
       System.out.println("<-------- Started Web scraping for suggestion list -------->");
       for (WebElement listTerm : autoSuggestionList) {
           WebElement term = listTerm.findElement(By.xpath(".//div"));
           System.out.println("Auto Suggestion Value : " + term.getText());
           if (term.getText().equalsIgnoreCase(expectedSearchTerm)) {
               System.out.println("\nFound required value in auto suggestion list. Clicking on it now\n");
               term.click();
               break;
           }
       }
       wait.until(ExpectedConditions.presenceOfElementLocated(By.xpath("//*[contains(@cel_widget_id,'MAIN-SEARCH_RESULTS')]")));
       //scraping the search results page to get the price of required product
       List<WebElement> productDetails = driver.findElements(By.xpath("//*[contains(@cel_widget_id,'MAIN-SEARCH_RESULTS')]"));
       for(WebElement product : productDetails) {
           WebElement productName = product.findElement(By.xpath(".//h2"));
           WebElement productPrice = product.findElement(By.xpath(".//*[@class='a-price']"));
           System.out.println("Product Name: " + productName.getText());
           if(productName.getText().contains("Ultra 5G S908U")) {
               System.out.println("\nFound Required Product");
               System.out.println("Required Product Price : " + productPrice.getText());
               break;
           }
       }
    }

Code Walkthrough

Step 1. Add a new test case testUsingWebScraping_Amazon(), and annotate it with @test annotation.

Step 2. Store the expected search term to a variable that will be used to compare and select from the auto-suggestion list at a later stage.

Step 3. Navigate to Amazon.com and enter the search term as samsung galaxy s and wait for the auto-suggestions list to load.

To verify that the auto-suggestion dropdown list has loaded, you can wait for the web element for the same to be present.

Step 4. Again using the same locator, we store the web element reference to a variable. This refers to the main container web element, which has the auto-suggestion list in child tags.

Step 5. Use the container web element to fetch the list of all auto-suggestions-related data that is present inside the < div > tag in this element.

We are using the XPath locator here for tag along with its class attribute.

Step 6. Use the web scraping approach to fetch relevant auto-suggestion values from the list of web elements fetched in the last step. For this, locate the child < *div *> tag again, which holds this information, and print it for each element.

6.1) Inside the loop only, compare the auto-suggestion value with the expected product name. If it matches, select the same to see a detailed list of all related products.

You should see a page like the one below on selecting the product.

Step 7. Use the explicit wait object again to wait for the page load to complete using ExpectedConditions.

Step 8. Implement the web scraping approach again on this page. This time, we scrape the entire page to get the name and price for the required product.

8.1) Fetch the web element locator, which contains all this information, and store it in a list.

8.2) Scrape the information inside this element to get the product name and price as per requirement. The product name is present inside < h2 > tag and price inside a tag with a class attribute having value class = ‘a-price’.

8.3) Use an if condition to check if the product name contains the required model number. If yes, print the price, if not continue to the next element until all product elements are processed.

Executing this automation script to handle auto-suggestions on Amazon for a product search and get its price for a matching product using web scraping, you will get an output like the one below.

This guide focuses on test automation metrics, its significance, strategies, challenges, and key test automation metrics for measuring success.

Conclusion

This brings us to the conclusion of our blog on handling auto-suggestions in Selenium Java automation to create robust and reliable automation. We learned details on auto-suggestions, the challenges they might pose, and how to handle them. Auto-suggestions can be successfully handled in automation by using explicit waits, validating suggestions, handling suggestions load time, etc. It is now time for you to begin handling the auto-suggestions on your test website using Selenium automation.

How To Handle NoSuchWindowException In Selenium

Vipulgupta9090 — Wed, 14 Jun 2023 06:23:00 +0000

In today’s digital landscape, websites are brimming with dynamic content, captivating users with interactive experiences. A notable feature is the frequent emergence of new windows and tabs triggered by specific actions taken by users. These dynamic elements play a vital role in enhancing user engagement and providing seamless navigation.

As an automation tester, encountering scenarios where multiple windows or tabs need to be handled within an end-to-end flow is a common occurrence. Successfully managing this dynamic behavior becomes essential to ensure the accuracy and reliability of your automated tests.

However, this becomes highly challenging as automated tests tend to fail and make your test scripts less reliable. Your automation testing script should be able to manage many windows for better testing. In such situations, switching focus to perform any action on the necessary window or tab becomes an unsaid requirement.

Selenium offers various methods to work with multiple windows. But any slightest mistake, like using an invalid window handle, switching to a closed window, etc., can lead to NoSuchWindowException in the automation script. We will discuss more about these in the next sections.

NoSuchWindowException occurs when the WebDriver tries to interact with a window that is not available at that moment. This could be due to a closed window or the window in focus being different.

In this Selenium Java tutorial, we will discuss how to handle NoSuchWindowException *in Selenium. We will discuss the most common reasons for the same and the best practices to handle it. The practical implementation of these practices using Selenium Java will help you to learn how to handle *NoSuchWindowException in your automation scripts to make tests run smoothly and reliably.

So, Let’s get started.

What is a window and window handle?

In Selenium, a window refers to a graphical user interface (GUI) window or a web browser window/tab, in particular while working with web automation. When Selenium WebDriver launches a web browser, it opens a new window in which the webpage gets loaded.

Each window is represented by a unique ID called a window handle. It allows the WebDriver to interact with the window and its elements. These handles are also used to switch between different windows, manipulate the size and position of the window, and perform other actions on the window and its contents.

If you have multiple browser windows open, you can use this method to retrieve a set of all the window handles. In this blog, Selenium with Java language has been used for demonstration and to provide code samples.

driver.getWindowHandles()


    Returns a Set<String> containing handles of all the windows

To get the current window handle:

driver.getWindowHandle()



Returns the handle of the current window as a String

To switch to a specific window by passing in its handle:

driver.switchTo().window("<random_window_handle>")

To switch to the main window back:

    driver.switchTo().defaultContent()

To understand these methods better, consider the following test scenario.

We want to reach the Twitter page and click on the Login button. This button is available on the page loaded in a new window. This new window, Window2 is loaded by clicking the Follow button on the previous/main window, Window1.

Now, if we want the test scenario to pass, the driver focus must be switched first to Window2 once it is loaded. If you try to switch driver focus before the load is completed, it will raise a NoSuchWindowException.

Which are the most wanted automation testing tools in 2023 that have climbed the top of the ladder so far? Let’s take a look!

What is a NoSuchWindowException in Selenium?

NoSuchWindowException is one of the most frequently encountered exceptions in Selenium WebDriver while working with multiple windows/tabs. The NoSuchWindowException is raised when the WebDriver cannot find the desired browser window or tab that it needs to interact with.

This exception would occur if there are multiple open windows and WebDriver is looking for one with incorrect window handles. Another reason could be that the required window is closed already and is no longer available.

The NoSuchWindowException can also occur if there is a problem with the browser itself, like it has crashed due to some previous actions or has become unresponsive.

An important thing to note here is that handling multiple frames in Selenium is slightly different than handling multiple windows in Selenium. As for frames, the methods provided to switch are different, and similarly, the expectation raised in case a frame is not found is NoSuchFrameException.

Perform browser automation testing platform on the most powerful cloud infrastructure. Leverage LambdaTest automation testing for faster, reliable and scalable experience on cloud.

Reasons for NoSuchWindowException in Selenium

This exception can occur for many reasons while working with multiple windows. A few of the most common ones are.

Closure of window
Driver focuses on another window
Invalid window handle
Window load timing issue

Demonstration: How to fix NoSuchWindowException in Selenium?

To demonstrate the best practices for handling NoSuchWindowException in Selenium, we will create a Java project with Maven and TestNG framework using Selenium 4.

Test Scenario — 1 (Demonstrate NoSuchWindowException)

Navigate to https://www.lambdatest.com/selenium-playground/window-popup-modal-demo.
Click Follow on Twitter.
Get a list of all window handles and print them on the console.
Try to switch to the new window using an invalid window handle.
Verify NoSuchWindowException is raised.

Test Scenario — 2 (Handle NoSuchWindowException using Try-Catch)

Navigate to https://www.lambdatest.com/selenium-playground/window-popup-modal-demo
Click Follow on Twitter.
Get a list of all window handles and print them on the console.
Start the try block.
Try to switch to the new window using an invalid window handle.
Verify NoSuchWindowException is raised and caught inside the catch block.

Test Scenario — 3 (Handle NoSuchWindowException using Explicit Wait)

Navigate to https://www.lambdatest.com/selenium-playground/window-popup-modal-demo
Click Follow on Twitter.
Add Explicit Wait using Expected Conditions to wait until the number of windows is 2.
Fetch a list of all window handles and store them in a variable.
Start a loop to switch to each window using the window handle one by one.
Switch to the new window using the window handle.
Check if this is the required window by verifying its title.
If it is a match, break the loop. If not, repeat Steps 6 and 7 till the required window is found.
Click on the Login button on the new window.

This blog uses the Eclipse IDE for demonstration purposes, but feel free to use any IDE of your preference. The implementation process remains identical until the creation of a Maven project, regardless of the IDE you choose.

As we are working with Selenium web automation, we would start by adding Selenium dependency along with TestNG, which will be used for test execution to the pom.xml of the project.

After the project is created and dependencies are added, the final pom.xml would be like the one below.

 <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>NoSuchWindowException</groupId>
       <artifactId>NoSuchWindowException</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <build>
           <sourceDirectory>src</sourceDirectory>
           <plugins>
               <plugin>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <version>3.8.1</version>
                   <configuration>
                       <release>19</release>
                   </configuration>
               </plugin>
           </plugins>
       </build>
       <dependencies>
           <dependency>
               <groupId>org.seleniumhq.selenium</groupId>
               <artifactId>selenium-java</artifactId>
               <version>4.8.3</version>
           </dependency>
           <dependency>
               <groupId>org.testng</groupId>
               <artifactId>testng</artifactId>
               <version>7.7.1</version>
               <scope>test</scope>
           </dependency>
       </dependencies>
    </project>

Next, add a new Java test file TestNoSuchWindowException.java under src.test package. Once added the project structure would look like this.

We will add our test cases to this to see how to prevent NoSuchWindowException from occurring in our Selenium automation scripts.

In this blog, we will harness the power of a Selenium cloud grid like LambdaTest to perform Selenium Java testing. LambdaTest is a digital experience testing cloud that exponentially increases your browser coverage by running your Java automation testing scripts with Selenium on a cloud of 3000+ desktop and mobile environments.

A complete Manual testing tutorial covering all aspects of Manual testing, including strategies and best practices.

After adding all the WebDriver configurations and test case examples to demonstrate the fix for NoSuchWindowException, the completed file should look like the below:

 package test;


    import java.net.*;
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.Set;


    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.testng.annotations.*;
    import org.openqa.selenium.By;
    import org.openqa.selenium.NoSuchWindowException;
    import org.openqa.selenium.safari.`Options;
    import org.openqa.selenium.support.ui.*;


    public class TestNoSuchWindowException {


       public RemoteWebDriver driver = null;


       String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME");
       String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" : System.getenv("LT_ACCESS_KEY");


       @BeforeTest
       public void setup()
       {
           try {
               SafariOptions safariOptions = new SafariOptions();
               safariOptions.setPlatformName("MacOS Big sur");
               safariOptions.setBrowserVersion("14.0");

               HashMap<String, Object> ltOptions = new HashMap<String, Object>();
               ltOptions.put("build", "NoSuchWindowException in Selenium");
               ltOptions.put("name", "Handling NoSuchWindowException");
               ltOptions.put("w3c", true);
               safariOptions.setCapability("LT:Options", ltOptions);

               driver = new RemoteWebDriver(
                       new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), safariOptions);
           } catch (MalformedURLException e) {
               e.printStackTrace();
           }
            driver.get("https://www.lambdatest.com/selenium-playground/window-popup-modal-demo");
       }


       @AfterTest
       public void tearDown() {
           driver.quit();
       }


       @Test
       public void testNoSuchWindowException()
       {  
           System.out.println("Clicking on Follow button");
           driver.findElement(By.xpath("//*[@title='Follow @Lambdatesting on Twitter']")).click();

           Set<String> handles = driver.getWindowHandles();
           for(String handle : handles)
           {
               System.out.println("Valid handle value : " + handle);
               //adding -updated to valid handle value to demonstrate exception
               //due to invalid handle value
               driver.switchTo().window(handle + "-updated");
           }
       }


       @Test
       public void testNoSuchWindowException_fix()
       {  
           System.out.println("Clicking on Follow button");
           driver.findElement(By.xpath("//*[@title='Follow @Lambdatesting on Twitter']")).click();

           WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
           wait.until(ExpectedConditions.numberOfWindowsToBe(2));
           System.out.println("Verified total windows are 2");

           System.out.println("Fetching window handles of all windows");
           Set<String> handles = driver.getWindowHandles();


           System.out.println("Switching to each window one by one to verify if it is required one");
           for(String handle : handles)
           {
               System.out.println("Switching to window with handle : " + handle);
               driver.switchTo().window(handle);
               //using window title to reach to required window
               if(driver.getTitle().equals("Profile / Twitter"))
               {
                   System.out.println("Reached required window");
                   break;
               }
           }
           driver.findElement(By.xpath("//*[@data-testid='login']")).click();
           System.out.println("Clicked Login button successfully");
       }

       @Test
       public void testNoSuchWindowException_fix_tryCatch()
       {
           System.out.println("Clicking on Follow button");
           driver.findElement(By.xpath("//*[@title='Follow @Lambdatesting on Twitter']")).click();
           try
           {
               Set<String> handles = driver.getWindowHandles();
               for(String handle : handles)
               {
                   System.out.println("Valid handle value : " + handle);
                   //adding -updated to valid handle value to get exception
                   //due to invalid handle value
                   System.out.println("Invalid handle value used : " + handle + "-updated");
                   driver.switchTo().window(handle + "-updated");
               }
           } catch (NoSuchWindowException ex) {
               System.out.println("We are inside catch block");
               System.out.println("NoSuchWindowException has been caught.");
           }
       }
    }

CodeWalkthrough

Step 1. We start by creating an instance of *RemoteWebDriver* as we will execute the code on the cloud Selenium Grid.

Step 2. Navigate to the LambdaTest Profile section once you create your account to fetch the username and access key. These will be used to make a connection to their cloud grid.

You can also configure the username and access key as environment variables using the following commands and directly fetch them in code.

For macOS and Linux:

export LT_USERNAME=LT_USERNAME
    export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME
    set LT_ACCESS_KEY=LT_ACCESS_KEY

We can also fetch the required browser capabilities to use the LambdaTest platform by navigating to their Automation Capabilities Generator. This helps by offering ready-to-use code for setting up browser capabilities that can be used in execution.

Step 3. Create a base method and name it as setup() and annotate with @BeforeTest annotation in TestNG. This method will be used for driver setup and opening the webpage before each test.

In this blog, we have used Selenium 4, which supports SafariOptions class. In this function, an object of the same is created to define browser properties like browser version, OS version, etc. It also accepts the variables required for LambdaTest execution as a capability.

These variables are used to set values like build, name, or any other browser property, which will help to identify the run on the LambdaTest Dashboard or modify behavior.

Step 4. Finally, an instance of RemoteWebDriver is created to connect to the LambdaTest Cloud grid using the safariOptions, and your Lambdatest username and the access key.

Step 5. Finally, navigate to the sample website under test, which will have a new window open on clicking a button.

Step 6. Add a method as tearDown() and annotate it with @AfterTest annotation. This will be used to close the session after each test case.

Need a great solution for Safari browser testing on Windows? Forget about emulators or simulators — use real online browsers. Try LambdaTest for free!

Test Scenario: NoSuchWindowException in Selenium

Step 1. Add the first test case and name it as testNoSuchWindowException(). In this test, we try to simulate the NoSuchWindowException in Selenium by using an invalid window handle.

Step 2. We start by clicking the Follow button, which will open a new window.

For this, we use the driver.findElement() method in Selenium and use XPath as a web element locator.

Step 3. Next, fetch the list of all window handles using driver.getWindowHandles() and store them in a variable. This traverses through the window handles list and prints valid handle values.

Step 4. Lastly, our attempt to switch to the newly opened window involves passing an invalid window handle. For this, the valid handle value from the previous step is manipulated to demonstrate the exception.

Step 5. On executing this, you can observe that the test case fails with NoSuchWindowException in Selenium as the window handle passed is invalid, and Selenium cannot locate a window using the same.

In the following sections, we will see the implementation of some of the best practices to prevent this NoSuchWindowException in Selenium from happening.

Elevate Your Mobile App Testing Quality: Make the most of your mobile application testing & Test on LambdaTest Cloud for Comprehensive Testing, Bug Detection & More.

Fixing NoSuchWindowException in Selenium using Try-Catch

As discussed in the best practices sections, one of the most used ways to handle NoSuchWindowException in Selenium is using the try-catch block.

Step 1. For this, add another test case to the Java file and name it testNoSuchWindowException_fix_tryCatch().

Step 2. Click the Follow button, which is expected to open a new window.

Step 3. In this approach, code that would lead to an exception on switching to a new window, like the previous scenario, is used.

The only difference is that we place this code inside the try block. This will help to catch the exception and prevent abrupt behavior from the automation script.

Step 4. This is followed by a catch block. This helps to catch the exception if it occurs and perform any subsequent actions. It also helps to terminate the code gracefully in such cases.

Step 5. Executing the above code, you will get the following output. In this, you can see that NoSuchWindowException is raised but is handled gracefully inside the catch block.

But it is very important to note that even if the exception is handled, you cannot perform any action on the new window. This is because the exception was raised, which means either the window handle is incorrect or the window does not exist.

You can always add a retry in such a case to try again the previous action, which should launch the window or check if the handle is correct and try to switch again.

Run your Selenium Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free!

Fixing NoSuchWindowException in Selenium using Window Handles and Waits

Step 1. Next, add a new test case and name it testNoSuchWindowException_fix(). We will use this to demonstrate how using Waits and Window Handles properly helps us to prevent NoSuchWindowException from happening.

Step 2. We start by clicking on the button, which is expected to open a new window.

Step 3. As we click on the button, the expectation here is that now the total number of windows should be 2 like below.

To handle the exception, we use explicit waits in Selenium to wait until the number of windows is equal to 2 and then move forward with the flow.

Step 4: For this, create an object of WebDriverWait class and pass the driver object and the duration for which we want to wait for the maximum time.

Using this object with the until() function, we add an ExpectedConditions to wait for the number of windows to be 2. The driver waits for a maximum of 5 seconds for this condition to happen.

If the number of windows is validated, we move forward else the driver throws an error to show that condition is not fulfilled.

Step 5. Next, fetch the window handle for all the open windows. We will be storing this in a Set.

Step 6. We will traverse through this list of handles and switch to each window one by one until the required window is found.

Step 7. To check if the current window is required or not, we check by matching the title of the required window with the current window. If it’s a match, break the loop and continue. If not, switch to the next window using the handle and continue the same flow.

Step 8. When the required window is found in WebDriver focus, click on the login button, and the success message is printed.

Executing the above test case, we get an output like the one below.

From the output screenshot, you can see that we had successfully verified that 2 windows are present using waits. Then we switch driver focus to the required new window and can successfully click on the Login button without encountering an exception.

Best practices to handle NoSuchWindowException in Selenium

From the demonstration section, it is quite clear that NoSuchWindowException in Selenium can be easily handled in your automation script by following some of the best practices.

Let us have a look at these in a bit more detail.

Using explicit waits
Using valid window handles
Switching to the correct window
Using a try-catch block
Keeping track of window handles

Conclusion

In conclusion, NoSuchWindowException is a common exception in Selenium that can occur when working with multiple windows or tabs. However, with the right knowledge of best practices to handle the same, we can make automation tests run smoothly and reliably. In this blog, we discussed the common reasons that can lead to NoSuchWindowException in Selenium. We also learned the best practices to handle the same and did some hands-on practice on how to add these approaches to your automation scripts. So, now it is for you to get started and, with a little attention to the powers of Selenium, prevent NoSuchWindowException in your scripts.

How To Handle SSL Certificates In Selenium WebDriver?

Vipulgupta9090 — Fri, 28 Apr 2023 08:31:26 +0000

We often access a website on our browser, which works fine. But when you try to access the same while automating it using Selenium WebDriver, the website is not loaded, and the browser shows a security error like “The connection is not secure” or “This connection is Untrusted.”

The reason for this is the missing SSL certificates used to add a layer of security to the website.

While working on internal staging test environments, it is sometimes fine not to have SSL available as the infrastructure is local and is not accessible to the outside world and thus can be bypassed. But in a production environment, any good website cannot do well without these certificates.

While manually accessing a URL, the browser imports all these required SSL certificates and stores them to load the website. But in the case of automation, every script is executed with a new profile; hence, the certificates are missing, leading to an error. SSL certificates must be handled in Selenium WebDriver to load the website correctly.

This blog on how to handle SSL certificates in Selenium will help you to understand more about SSL certificates and their importance in production and testing, their types, and how to handle SSL certificates in Selenium WebDriver on various browsers.

So let’s get started.

What is an SSL Certificate?

SSL or Secure Sockets Layer is a standard security protocol that helps to establish a secure connection between the client (browser) and the server. SSL certificates help to ensure that all the data transmission between a client and server is encrypted using a strong encryption standard like Advanced Encryption Standard (AES), RSA, TLS, etc.

This helps validate the client’s identity to the server and thus keeps hackers at bay from spying on any information exchange. SSL encryption thus facilitates the exchange of sensitive information, like card details, usernames, passwords, etc., between the client and server at both ends and during the data transmission phase using encryptions.

An SSL-secured website URL begins with [https://,](https://,) and you can see a lock symbol or green color address bar if the connection is secure.

In this tutorial, learn what is Regression testing, its importance, types, and how to perform it.

Benefits of using SSL Certificates

Encrypting data for transmission: SSL certificates encrypt data sent between a web server and a user’s browser, thus rendering it unreadable for any hacker. This helps safeguard data when dealing with sensitive information like credit card numbers, login credentials, and personal information.

In this blog section on how to handle SSL certificates in Selenium WebDriver, let’s look at the benefits of using SSL certificates.

Authentication Support
Higher SEO rankings
Building user trust
Compliance Friendly
Protection against phishing attacks

How does the SSL Certificate work?

In this blog section on how to handle SSL certificates in Selenium WebDriver, we’ll focus on the workings of SSL certificates.

SSL establishes a secure encrypted communication channel between the client and the server.

Detailed steps are mentioned below:

The browser tries to make a connection to the server by sending a request to validate if it is secure.
The server then sends a copy of its SSL certificate to the browser to identify itself as secure and trustworthy.
The browser then verifies if the certificate is valid, unexpired, and unrevoked using its Trusted Certificate Authority(CA) list. The browser sends a message to the server if the certificate is valid.
The server then responds with a digitally signed acknowledgment, and a secure SSL encrypted session is established between the server and browser.
The server and the browser can now send encrypted messages to each other.

Get started with this complete Selenium automation testing tutorial. Learn what Selenium is, its architecture, advantages and more for automated cross browser testing:.

Types of SSL Certificates

In this blog section on how to handle SSL certificates in Selenium WebDriver, let’s look at the types of using SSL certificates.

When a website requests an SSL certificate from the Certificate Authority (CA), it gets a zip file containing different types of certificates as follows:

Root Certificate
Intermediary Certificate
Server Certificate

What is an Untrusted SSL Certificate?

Whenever you try to access a website, the authenticity and trust of the website are determined by the SSL certificate. If the certificate fails to validate itself, a secure encrypted connection is not established, and the browser throws an Untrusted Connection exception, resulting in a browser error. This is what you can understand as an Untrusted SSL Certificate.

On loading a website with an untrusted certificate, you can see that on the web URL bar of the browser, it shows it as Not Secure like this.

The type of certificate error you experience depends on your browser. In the demonstration section, we will see how to handle SSL certificates in Selenium WebDriver for different browsers. But before moving to that, let us understand the different types of SSL certificate errors.

It’s crucial to debug websites for Safari before pushing them live. In this article, we look at how to debug websites using Safari Developer tools.

Types of SSL Certificate Errors

SSL certificate error handling can differ slightly across various browsers due to the varying error messages that appear in the case of an untrusted certificate. Before looking into the code to handle these, let us first look at different browser errors.

Chrome — Your connection is not private

Firefox — Warning: Potential Security Risk Ahead

Safari —This Connection Is Not Private

Edge — Your connection isn’t private

You would notice that each browser has a different way of showing the error to the user. But the reason for the error is internally the same for a website server in all cases. A few of the standard error codes and reasons are

ERROR CODE	REASON
ERR_CERT_DATE_INVALID	Expired Certificate
ERR_CERT_REVOKED	Revoked Certificate
ERR_CERT_AUTHORITY_INVALID	Certificate signed by an untrusted source

Test your website or web app online for iOS browser compatibility. Perform seamless cross browser testing on the latest iPhone Simulator. Try for free.

Demonstration: How to handle SSL Certificates in Selenium WebDriver?

So far, we have discussed and understood SSL certificates and the errors we can encounter on different browsers due to invalid certificates. Let us now move to practical implementation to understand better how to handle SSL certificates in Selenium WebDriver.

For demonstration purposes, we will be writing an automation script for the below scenario for all browsers and seeing the results on cloud execution.

For this blog on how to handle SSL certificates in Selenium WebDriver, we are using the LambdaTest Cloud Grid. LambdaTest is a highly scalable, reliable, and easy-to-use digital experience testing platform that provides support for automation testing on over 3000+ browsers and OS to support execution on online Selenium Grid. This would be very useful for us as we want to execute the code on several browsers to handle SSL certificates in Selenium.

Perform browser automation testing on the most powerful cloud infrastructure. Leverage LambdaTest automation testing for faster, reliable and scalable experience on cloud.

Test Scenario

Consider the following two websites:

Having valid SSL certificates: LambdaTest
Having an expired SSL certificate: Expired cert

Set accepting Insecure SSL certificates to True and navigate to both individually.
Set accepting Insecure SSL certificates to False and navigate to both one by one.

Project Setup

For this blog, we will use a Maven project using Java in Eclipse IDE. If you are not a fan of Eclipse, use any IDE of your choice and perform the same steps. It will use Selenium WebDriver and TestNG dependencies to automate WebDriver flows and test execution. It is highly recommended to use the latest stable versions for better results.

Launch Eclipse or the IDE of your choice.
1. Create a new Maven project and name it as HandlingSslCertificates.
2. Inside the src folder, add a test package, and inside it, add three Java files and name them as

BaseClass.java: this will hold the base setup code to configure the browser properties, initiate driver instances.
Test_Accept_InsecureSslCerts.java: this will have test cases for each browser where we accept the insecure SSL certificates.
*Test_Reject_InsecureSslCerts.java: *this will have test cases for each browser where we do not accept insecure SSL certificates.

Update the pom.xml file to have the latest dependencies for TestNG in Selenium. It would be like below:

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>HandlingSslCertificates</groupId>
     <artifactId>HandlingSslCertificates</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <build>
       <sourceDirectory>src</sourceDirectory>
       <plugins>
         <plugin>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.1</version>
           <configuration>
             <release>16</release>
           </configuration>
         </plugin>
       </plugins>
     </build>
     <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-java</artifactId>
           <version>4.1.4</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>7.7.1</version>
           <scope>test</scope>
       </dependency>
     </dependencies>
    </project>

Next, move to BaseClass.java and add the following code to create a WebDriver instance, depending on the web browser we want to use.

 package test;


    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.HashMap;


    import org.openqa.selenium.chrome.ChromeOptions;
    import org.openqa.selenium.edge.EdgeOptions;
    import org.openqa.selenium.firefox.FirefoxOptions;
    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.openqa.selenium.safari.SafariOptions;


    public class BaseClass {


       public RemoteWebDriver driver = null;
       String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME");
       String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>": System.getenv("LT_ACCESS_KEY");


       public void setup(String browserName, boolean acceptInsecureSSL) {


           HashMap<String, Object> ltOptions = new HashMap<String, Object>();


           try {


               switch (browserName) {
               case "chrome":
                   ChromeOptions chromeOptions = new ChromeOptions();
                   chromeOptions.setPlatformName("Windows 10");
                   chromeOptions.setBrowserVersion("110.0");
                   ltOptions.put("build", "SSL certificates Using Selenium WebDriver");
                   ltOptions.put("name", "Handling on Chrome");
                   chromeOptions.setAcceptInsecureCerts(acceptInsecureSSL);
                   chromeOptions.setCapability("LT:Options", ltOptions);
                   driver = new RemoteWebDriver(
                           new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), chromeOptions);
                   break;
               case "firefox":
                   FirefoxOptions firefoxOptions = new FirefoxOptions();
                   firefoxOptions.setPlatformName("Windows 10");
                   firefoxOptions.setBrowserVersion("109.0");
                   ltOptions.put("build", "SSL certificates Using Selenium WebDriver");
                   ltOptions.put("name", "Handling on Firefox");
                   firefoxOptions.setAcceptInsecureCerts(acceptInsecureSSL);
                   firefoxOptions.setCapability("LT:Options", ltOptions);
                   driver = new RemoteWebDriver(
                           new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"),
                           firefoxOptions);
                   break;
               case "edge":
                   EdgeOptions edgeOptions = new EdgeOptions();
                   edgeOptions.setPlatformName("Windows 10");
                   edgeOptions.setBrowserVersion("108.0");
                   ltOptions.put("build", "SSL certificates Using Selenium WebDriver");
                   ltOptions.put("name", "Handling on Edge");
                   edgeOptions.setAcceptInsecureCerts(acceptInsecureSSL);
                   edgeOptions.setCapability("LT:Options", ltOptions);
                   driver = new RemoteWebDriver(
                           new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), edgeOptions);
                   break;
               case "safari":
                   SafariOptions safariOptions = new SafariOptions();
                   safariOptions.setPlatformName("MacOS Ventura");
                   safariOptions.setBrowserVersion("16.0");
                   ltOptions.put("build", "SSL certificates Using Selenium WebDriver");
                   ltOptions.put("name", "Handling on Safari");
                   safariOptions.setAcceptInsecureCerts(acceptInsecureSSL);
                   safariOptions.setCapability("LT:Options", ltOptions);
                   driver = new RemoteWebDriver(
                           new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), safariOptions);
                   break;
               }


           } catch (MalformedURLException e) {
               System.out.println("Invalid grid URL");
           }
       }


    public void navigateToUrls() {
           System.out.println("Navigating to Lambdatest URL");
           driver.get("https://www.lambdatest.com/");
           System.out.println("The page title is : " +driver.getTitle());

           System.out.println("Navigating to BadSSL URL");
           driver.get("https://expired.badssl.com/");
           System.out.println("The page title is : " +driver.getTitle());

           driver.quit();
       }
    }

In the two test files, add the below code to run the following test cases:

Accepting the insecure SSL certificates.
Not accepting insecure SSL certificates.

package test;

    import org.testng.annotations.Test;

    public class Test_Accept_InsecureSslCerts extends BaseClass{

       @Test
       public void testSslCertificatesHandlingChrome()
       {
           setup("chrome", true);
           navigateToUrls();
       }

       @Test
       public void testSslCertificatesHandlingFirefox()
       {
           setup("firefox", true);
           navigateToUrls();
       }

       @Test
       public void testSslCertificatesHandlingEdge()
       {
           setup("edge", true);
           navigateToUrls();
       }

       @Test
       public void testSslCertificatesHandlingSafari()
       {
           setup("safari", true);
           navigateToUrls();
       }
    }

    package test;

    import org.testng.annotations.Test;

    public class Test_Reject_InsecureSslCerts extends BaseClass{

       @Test
       public void testSslCertificatesHandlingChrome()
       {
           setup("chrome", false);
           navigateToUrls();
       }

       @Test
       public void testSslCertificatesHandlingFirefox()
       {
           setup("firefox", false);
           navigateToUrls();
       }

       @Test
       public void testSslCertificatesHandlingEdge()
       {
           setup("edge", false);
           navigateToUrls();
       }

       @Test
       public void testSslCertificatesHandlingSafari()
       {
           setup("safari", false);
           navigateToUrls();
       }
    }

Code Walkthrough: *BaseClass.java*

This Java file is the base test class for creating the web driver instance as per the mentioned browser and to have a common function to navigate to both the URLs as per the defined test scenario above.

Both the functions in this class will be called in each test case on both classes.

Let’s understand both these functions in detail now.

Step 1. The first step is to create an instance of RemoteWebDriver. We are using a Remote WebDriver as this helps to support execution on the cloud Selenium Grid. This provides increased scalability and the required speed for automated test execution and, at the same time, also allows users to perform cross browser testing across several OS and browser combinations.

Step 2. As mentioned in the previous step, since we are using the LambdaTest platform, we need to provide the username and access key for our user to connect with the cloud hub. You can find these details under LambdaTest Profile Section after your account is created.

Once you have your username and access key, these can be configured as environment variables on your system and fetched from there to use in the automation script.

You can configure these environment variables using export or set commands based on the operating system.

For macOS and Linux:

export LT_USERNAME=LT_USERNAME export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME set LT_ACCESS_KEY=LT_ACCESS_KEY

Step 3. Create a method and name it setup(). This method will take two parameters, namely browserName, and acceptInsecureSSL.

browserName — helps to identify which browser we want to execute our code and create a driver instance with the capabilities of that particular browser.
acceptInsecureSSL — a boolean parameter used to set the browser capabilities to identify if we need to accept or reject websites with untrusted SSL certificates. True means allowing all websites irrespective of SSL certificate status, while False means allowing only those websites with a valid SSL certificate.

Step 4. Create a HashMap variable and name it as ltOptions. This will set various properties for the LambdaTest cloud grid execution.

Step 5. This is the most important part of the demonstration, as here we add a switch case to decide which browser capabilities to set, including accepting insecure certificates and creating an instance of Remote WebDriver, depending on that.

This case is specific to the Chrome browser. Similar cases will be created for each browser in the next steps.

We start by creating an object in the ChromeOptions class. This class is used to manipulate various properties of the Chrome driver, which we will use for execution.

Here you can notice the setAcceptInsecureCerts() property. This is the property with which we are most concerned as part of this demonstration for this blog on how to handle SSL certificates in Selenium WebDriver.

This takes a boolean argument that tells the browser driver whether it should allow websites with untrusted SSL certificates to load. True means allowing all websites irrespective of SSL certificate status, while False means allowing only those websites with a valid SSL certificate. This property is common to all browsers and has similar behavior.

We will also use the same object to set some of the properties to display cloud execution results better on the LambdaTest Dashboard.

At the end of each browser case, we write the code to connect with RemoteWebDriver on the LambdaTest platform using the properties defined for the browser, like chromeOptions in this case.

An added advantage of using the LambdaTest platform is that you can directly select the browser and version details, and your capabilities are automatically generated using LambdaTest Capabilities Generator, which is ready to be added to the code directly.

Like the Chrome browser, Firefox, Edge, and Safari cases would look like the below using FirefoxOptions, EdgeOptions, and SafariOptions, respectively.

Step 6. The last step is to add a function navigateToUrls(), a common function used to navigate to URLs for both websites and fetch the page title. This same function is used to close the browser and quit the WebDriver instance at the end of each test case.

Code Walkthrough: **Test_Accept_InsecureSslCerts.java*

In this Java test file, we have written four different test cases, one for each browser, for easy understanding and differentiation.

In each test function, we have two common steps:

Step 1. Call the setup() function of BaseClass.java and pass the browser name on which we want to execute. Along with this, pass the boolean parameter acceptInsecureSSL as true.

Step 2. Call the navigateToUrls() function to navigate to both URLs one by one. In this case, both websites should load, which is #2 of our established test scenarios.

Code Walkthrough: **Test_Reject_InsecureSslCerts.java*

Similar to the previous one, this Java test file has four different test cases, one for each browser.

The only difference is the boolean parameter acceptInsecureSSL is false, which means #3 of our test scenarios.

On running the cases, the LambdaTest website would get loaded but the other one would fail to load and throw an error on each browser as we are not accepting websites with insecure SSL certificates in this case.

Run your Selenium Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

Test Execution

Having developed a basic understanding and writing the automation script to handle SSL certificates in Selenium WebDriver, it is now time to execute the code and see the results of execution locally and on the LambdaTest Dashboard.

The test case would be executed using the TestNG framework. To execute, follow the below-mentioned steps:

Right-click the test case name in Eclipse IDE.
Go to the Run Test and select TestNG Test to begin the execution.

First, we will execute the cases one by one for all browsers from Test_Accept_InsecureSslCerts and observe that all cases pass and both websites are loaded successfully.

You can observe from the above screenshot of local execution that we have titles of both websites, which means both are loaded successfully. Executing on all four browsers would give similar results in this case.

Before moving forward, let us observe the results of this execution on the LambdaTest Dashboard as well.

For this, log in to your account, move to Automation -> Build section, and select your build.

An added advantage of using the LambdaTest grid here is that we can select each test case and verify the configuration passed to the test case is correct, i.e., acceptInsecureCerts = true on all browsers for this execution, from the Input Config section.

Chrome Browser

Firefox Browser

Safari Browser

Edge Browser

Finally, we try to execute the test cases from Test_Reject_InsecureSslCerts on which LambdaTest should get loaded, and BadSSL should raise a Privacy error due to an insecure SSL certificate since on this, we are not accepting insecure SSL certificates.

On local execution, since the website would not get loaded, the title would not be the same and, instead, signify the same on each browser.

For Safari, it would be This Connection Is Not Private for Safari, for Chrome and Edge Privacy error and WebDriverException for Firefox since we are using Remote WebDriver.

You can learn more about them through this blog on common Selenium exceptions.

Similarly, we can check the results on the LambdaTest Dashboard. You would observe that for these executions on each browser, unlike previous cases, the Input config for all cases would have acceptInsecureCerts as false, like below.

Chrome Browser

Firefox Browser

Safari Browser

Edge Browser

Conclusion

With this, we have reached the end of this blog on how to handle SSL certificates in Selenium WebDriver. In this blog, we learned about SSL certificates, how it works, and what an insecure certificate means. On demonstration, we also understood that Selenium provides us with functions to both accept and reject such insecure SSL certificates in our automation on each browser. So, now it is time for you to explore SSL more and implement it in your code.

Happy testing.

A Complete Guide To Exception Tests In TestNG [With Examples]

Vipulgupta9090 — Mon, 24 Apr 2023 08:36:10 +0000

While automating critical applications like banking apps, it’s important to implement error handling and validation checks to ensure that the application is secure and reliable for the bank’s customers. Additionally, clear error messages and notifications should be provided to assist users in troubleshooting the issue.

Unforeseen circumstances or anomalies can occur during software development, and it is crucial to handle them efficiently to maintain program stability. To achieve this, exception handling can be implemented in the code.

Since these are an inherent part of any software, an exception test is a critical and mandatory requirement. By writing exception tests, you can ensure that your application behaves as expected without impacting customers when faced with such exceptional scenarios. This is also critical for ensuring business continuity because it reduces risk and costs and, in some cases, helps to meet compliance and regulatory testing requirements.

TestNG is the framework that is most frequently used to run exception tests.

This blog post will explore some of the common exceptions encountered during automation testing, demonstrate how to handle them by writing exception tests in TestNG, and verify that your code performs as intended.

Do you use a Mac and want to run the test in Internet Explorer? This article explores how to test Internet Explorer for Mac.

What are Exceptions?

Any event that interrupts the normal flow of a program’s execution is called an Exception. These are typically caused by errors or unusual conditions, such as invalid input, a file that cannot be found, or divide-by-zero or element locator/interaction-related issues while working with Selenium.

When an exception occurs, the program will typically halt execution or simply crash or produce incorrect results.

Exception handling allows programs to recover from such errors, provide more informative error messages to users, and ensure that critical resources are correctly released even when an error occurs.

Let us take this example flow to understand how exceptions and exception handling work.

Consider you are working to automate a web page. For this, you would need to use the object of a WebDriver to interact with the page.
As a practice, the following steps would be to perform desired actions on the webpage and then close the browser and terminate the driver instance.
But imagine a scenario where for some reason, the browser gets closed between execution, or you do so manually.
Then, the code tries to continue and interact with some web element that is supposed to be present on the webpage.
Such a scenario would lead to an exception as the browser is already closed. The output, in this case, would show you a SessionNotFound or WebDriver exception as the browser session is terminated.
To handle such exceptions, we can use exception handling and maybe relaunch the browser in such a scenario to continue execution and get desired results.

Commonly encountered Exceptions

Here are a few examples of exceptions that we may encounter when writing automation scripts with Selenium for web automation or when writing code in general.

NullPointerException

When trying to refer to some object or variable that has no reference or a null reference.

ArrayIndexOutOfBoundsException

Occurs while working with lists or arrays when a program tries to access an element that does not exist and is beyond array length.

IllegalArgumentException

When an illegal or corrupt argument is passed to a function.

IOException

Occurs due to issues on input/output flows, like accessing a file or opening/closing it.

NoSuchElementException

Occurs when the element the code is trying to access is not present in the DOM.

ElementNotVisibleException

Occurs when the element is present on DOM but is not actually visible on the webpage for interaction.

ElementNotInteractableException

Occurs when we try to interact with a disabled or inactive web element.

StaleElementReferenceException

Occurs when we try to access some element with an older reference that is no longer valid due to some actions.

TimeoutException

Occurs when the required action takes too long to be completed, like loading a page, waiting for some web element, etc.

NoSuchWindowException

Occurs when working with multiple windows when the required window is not available.

InvalidSelectorException

Occurs when the web element selector is not valid. This can be due to syntax errors or invalid selector values.

WebDriverException

Generic exception when working with WebDriver. This can occur due to WebDriver or browser-related problems in the automation script.

Exception tests in TestNG

An exception test is a test case that confirms a particular exception is raised whenever a certain code block is executed. Exception testing is an important part of software testing, as it helps to validate that the application behaves as expected when faced with exceptional scenarios. It also helps to improve code and product quality by identifying such issues. This, in turn, also increases test coverage and provides better results.

To write such a test, the TestNG testing framework is used.

TestNG is an open-source automation testing framework for Java built on the capabilities of JUnit and NUnit. It helps to write test cases in a well-structured, easy-to-maintain way using TestNG annotations, attributes, and other features.

This tutorial dive deep into web testing to help you understand its life cycle, elements, angles, the role of automation, and more.

expectedExceptions

Using the expectedExceptions attribute of the @test annotation, we can write exception tests in TestNG. This attribute accepts a single exception class or a list of exception classes that are expected to be thrown from the test case. The test will succeed if any of the predefined exceptions are raised. The test will fail if a different exception or no exception is thrown. Using the expectedExceptionsMessageRegExp attribute, we can also confirm the exception message.

For example, a TestNG exception test for the scenario mentioned above would look like this below

@Test(expectedExceptions = ElementNotInteractableException.class)
    public void testButtonNotInteractable() {
     //code to fill transfer details and
     //try to click on submit button
    }

It verifies that an ElementNotInteractableException is thrown when a user tries to click on the transfer button. If no exception or any other exception is thrown, it will fail.

Advantages of using Exception tests in TestNG

There are several advantages of using exception tests in TestNG, a few of them are:

Improved quality

Exception tests help verify that the code behaves as expected when faced with unexpected scenarios and can handle them gracefully. This helps to improve application quality and stability.

Early issue detection

With exception testing, ROI improves significantly as issues can be detected early on. This saves time, money, and effort to fix any such issue if they reach production.

Increased confidence

Having exception tests in place also gives testers more confidence while testing any new changes as it ensures nothing on existing functionality breaks and all unwanted situations are catered to.

Easy to maintain and write cases

TestNG makes writing the cases very easy and well-structured using annotations. We can simply write one by providing the expectedExceptions attribute of the @test annotation.

Better insight into the code

Exception tests provide an understanding of how the application would behave in exceptional scenarios. This can be used to verify assumptions around expected behavior and thus improve overall understanding.

How to write Exception tests in TestNG?

TestNG helps to validate the exceptions thrown by the test using the expectedExceptions attribute within @Test annotation.

expectedExceptions can take a single exception or a list of exceptions to validate from. If the exception raised from the test case is one of those mentioned above, then the test case passes; else, it fails.

Verify exception class

There are two ways to define a single exception to be validated. Both these are just different ways to represent the same thing.

Pass the exception class name directly.

   @Test(expectedExceptions = ElementNotInteractableException.class)

Pass the exception class name within curly brackets.

  @Test(expectedExceptions = {ElementNotInteractableException.class})

There might be scenarios where the same code could lead to different exceptions under different circumstances. In such a case, we can also pass the list of all such expected exceptions by enclosing them within curly brackets.

   @Test(expectedExceptions = {ElementNotInteractableException.class, NoSuchElementException.class})

In this, the test case passes if the raised exception is one amongst the list and fails if it is not present in the list or no exception is thrown at all from the automation code.

Upload your app for testing within seconds using the LambdaTest cloud and perform mobile app testing right away. Find bugs early on, improve performance, quality, user experience and make the most of mobile appl testing on LambdaTest.

Verify exception message

TestNG with @Test annotation also provides support to assert the exception message using the expectedExceptionsMessageRegExp attribute. We can have this message in the code from where the exception is thrown.

Asserting the exception message enables us to confirm that the exception is raised for the correct reasons, which we expected.

To understand this better, consider insufficient funds in the source account part of the bank application example we took in the introduction. In this case, an InsufficientFundsException can be raised for two reasons.

The source has no funds, or
The source has insufficient funds to complete the transfer.

In both cases, the exception raised would be the same, and the exception test would pass. Asserting exception messages enables us to be more specific and helps in verifying the corner cases that the message raised is as expected or not. Thus confirming what exactly leads to failure in this case, the message could specify the same — no funds or insufficient funds, although the exception class remains the same.

 @Test(expectedExceptions = { InsufficientFundsException.class }, expectedExceptionsMessageRegExp = "Source has fewer than requested funds")
    public void testFewerFunds() {}


    @Test(expectedExceptions = { InsufficientFundsException.class }, expectedExceptionsMessageRegExp = "Source has zero funds")
    public void testZeroFunds() {}

We can also verify the exception messages with the help of Regular Expressions using .*., depending upon the position of the regular expression we can use it to make pattern matching such as starts-with, contains, and ends-with while verifying the exception message.

 @Test(expectedExceptions = { InsufficientFundsException.class }, expectedExceptionsMessageRegExp = "Source has .*")

This means the exception message should have the word Source followed by certain other words.

Let us now move forward and see how the implementation of exception tests in TestNG works by taking examples.

Run your Selenium Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free!

Demonstration: Exception tests in TestNG

We will be creating a Maven project. It will use Selenium WebDriver and TestNG dependencies to automate web page flows and test case execution for exception tests, respectively. It is highly recommended to use the latest versions of the dependencies for the best results.

After creating the project and adding said dependencies, the pom.xml should look like this.

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
           <modelVersion>4.0.0</modelVersion>
           <groupId>ExceptionTest</groupId>
           <artifactId>ExceptionTest</artifactId>
           <version>0.0.1-SNAPSHOT</version>
           <build>
                   <sourceDirectory>src</sourceDirectory>
                   <plugins>
                           <plugin>
                                   <artifactId>maven-compiler-plugin</artifactId>
                                   <version>3.8.1</version>
                                   <configuration>
                                           <release>16</release>
                                   </configuration>
                           </plugin>
                   </plugins>
           </build>
           <dependencies>
                   <dependency>
                           <groupId>org.seleniumhq.selenium</groupId>
                           <artifactId>selenium-java</artifactId>
                           <version>4.8.0</version>
                   </dependency>
                   <dependency>
                           <groupId>org.testng</groupId>
                           <artifactId>testng</artifactId>
                           <version>7.7.1</version>
                           <scope>test</scope>
                   </dependency>
           </dependencies>
    </project>

Next, add a Java test file and name it ExceptionTest.java. We will add different test cases to this to understand exception tests with different examples.

In this blog on exception tests in TestNG, we will mostly take examples of exceptions faced during Selenium automation with TestNG. Here, we are using the LambdaTest Cloud Grid to run our tests.

LambdaTest is a digital experience testing cloud, a highly scalable, reliable, and easy-to-use platform that provides support for over 3000+ browsers and OS to perform TestNG testing on Selenium Cloud Grid.

To kick start Selenium automation testing with TestNG, refer to our documentation TestNG with Selenium.

Automate Cypress testing and perform browser automation testing with LambdaTest. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

To stay up-to-date on tutorials related to Selenium testing, Cypress testing, and more, subscribe to the LambdaTest YouTube Channel.

Using the RemoteWebDriver configuration to access a webpage on the cloud platform and after adding different test cases to demonstrate exception testing, the final *ExceptionTest.java *would look like the below.

 package test;


    import java.net.*;
    import java.util.HashMap;
    import java.util.concurrent.TimeUnit;


    import org.openqa.selenium.*;
    import org.openqa.selenium.chrome.ChromeOptions;
    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.testng.annotations.*;


    public class ExceptionTest {


       public RemoteWebDriver driver = null;


       String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME");
       String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" : System.getenv("LT_ACCESS_KEY");


       @BeforeTest
       public void setup() {
           try {
               ChromeOptions chromeOptions = new ChromeOptions();
               chromeOptions.setPlatformName("Windows 10");
               chromeOptions.setBrowserVersion("110.0");


               HashMap<String, Object> ltOptions = new HashMap<String, Object>();
               ltOptions.put("build", "Exception Test in TestNG");
               chromeOptions.setCapability("LT:Options", ltOptions);


               driver = new RemoteWebDriver(
                       new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), chromeOptions);
           } catch (MalformedURLException e) {
               e.printStackTrace();
           }


           driver.get("https://www.lambdatest.com/selenium-playground/");
       }


       @AfterTest
       public void tearDown() {
           driver.quit();
       }


       // This case will pass as same exception is thrown
       // due to invalid web element selector
       @Test(expectedExceptions = TimeoutException.class)
       public void testSingleException_passed() {
           driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.MILLISECONDS);
           driver.get("https://ecommerce-playground.lambdatest.io/");
       }


       // This case will fail as web element selector is valid
       // hence no exception is raised
       @Test(expectedExceptions = TimeoutException.class)
       public void testSingleException_failed() {
           driver.get("https://ecommerce-playground.lambdatest.io/");
       }


       // This case will pass as exception thrown
       // is one of the expected list i.e. NoSuchWindowException
       @Test(expectedExceptions = { NoSuchElementException.class, NoSuchWindowException.class })
       public void testMultipleException_NoSuchWindowException_passed() {
           driver.switchTo().window("new_window");
       }


       // This case will pass as exception thrown
       // is one of the expected list i.e. NoSuchElementException
       @Test(expectedExceptions = { NoSuchElementException.class, NoSuchWindowException.class })
       public void testMultipleException_NoSuchElementException_passed() {
           driver.findElement(By.xpath("//*[@class='st_heading_1']"));
       }


       // This case will fail as exception raised is not on the list
       // i.e. TimeoutException
       @Test(expectedExceptions = { NoSuchElementException.class, NoSuchWindowException.class })
       public void testMultipleException_failed_1() {
           driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.MILLISECONDS);
           driver.get("https://ecommerce-playground.lambdatest.io/");
       }


       // This case will fail as none of the expected exception is raised
       @Test(expectedExceptions = { NoSuchElementException.class, NoSuchWindowException.class })
       public void testMultipleException_failed_2() {
           driver.findElement(By.xpath("//*[@class='st_heading']"));
       }


       // This case will pass as expected exception message is same.
       @Test(expectedExceptions = NoSuchElementException.class, expectedExceptionsMessageRegExp = "(?s).*no such element.*")
       public void testExceptionMessage_passed() {
           driver.findElement(By.xpath("//*[@class='st_heading_1']"));
       }


       // This case will fail as expected exception message is not same.
       @Test(expectedExceptions = NoSuchWindowException.class, expectedExceptionsMessageRegExp = "(?s).*no such element.*")
       public void testExceptionMessage_failed() {
           driver.switchTo().window("new_window");
       }
    }

Let’s start to understand the code step by step now.

Code Walkthrough:

We will first do a walkthrough for the common code used to set up and launch the browser and close it at the end of the test execution. This will be followed by different test case examples to understand what we have learned so far in this blog about exception tests in TestNG.

**Step 1: **Create an instance of RemoteWebDriver. This is required as we will be executing the code on the cloud Selenium Grid.

Step 2: Since we are using the LambdaTest platform, we need to provide the username and access key for our user to connect with the cloud grid. You can find these details under LambdaTest Profile Section after your account is created.

You can configure the username and access key as environment variables on your system and fetch them in the automation script.

To configure these following commands can be used

For macOS and Linux:

 export LT_USERNAME=LT_USERNAME
    export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME
    set LT_ACCESS_KEY=LT_ACCESS_KEY

*Step 3: **Create a method named *setup() and annotate it with @BeforeTest TestNG annotation to be able to execute it before each test case for driver setup and opening the webpage

In this function, we start by creating an object of *ChromeOptions *class, which is used to define browser properties like browser version, OS version, etc.

This is followed by steps to define some variables for LambdaTest execution. These variables are used to set values like build, name, or any other browser property, which will help to identify the run on the dashboard or modify behavior. This is done with the help of a HashMap *variable, which is then passed to *chromeOptions.

An additional benefit of using LambdaTest is that all of these browser properties can be easily retrieved using the LambdaTest Automation Capabilities Generator. You only need to select the required operating system and browser combination and versions, and the rest is done for you by this utility, and you have the code ready to use. This reduces the possibility of error and provides more valid combinations and data.

Next, using all these properties, we create an instance of RemoteWebDriver for connecting to the LambdaTest cloud grid to start execution. Your LambdaTest username and the access key will be used in this step.

Finally, navigate to the required URL.

Step 4: Add a new method as tearDown() and annotate it with @AfterTest annotation. This function will be used to close the browser and quit the driver session after each test case.

This completes the basic code setup. Let’s start to see some working examples now.

Black Box testing? Don’t worry; we will be covering what is Black box testing, merits, demerits, types & techniques.

Exception test for TimeoutException

Add the first test case and name it testSingleException_passed(). In this test case, we will try to simulate TimeoutException by setting the driver timeout to a very low value. As a result, when we try to navigate to a new URL, the driver throws an exception as the page load is not completed. To make the test case pass, the value for the expectedExceptions attribute is set as TimeoutException.class.

As you can see, we have the pageLoadTimeout() to 10 milliseconds and then try to get a new URL. This is expected to throw a *Timeout *exception as the website would not be loaded in this time frame.

Now try to execute the test case and see if it fails or passes.

You can notice that this case is passed since the expected exception matches the one thrown by the code.

To understand this better, add another test case, testSingleException_failed(). This case is exactly similar to the previous one with just one difference: the pageLoadTimeout() is not updated, unlike earlier, and hence the webpage is loaded successfully in the expected time. Hence, no exception is raised from the test case.

Here, you can see we are still expecting a TimeoutException. This should lead to test failure.

From the test execution result above, you can see that the test case failed as expected to get an exception, but none was thrown.

Test your Puppeteer test scripts online. Deploy a quality build faster by running automated checks across over 3000+ browsers and OS combinations with the LambdaTest cloud. Try for free!

Exception test for NoSuchElementException and NoSuchWindowException

In this section, we take examples where multiple exceptions are passed as a list to the expectedExceptions attribute. We will take two passed test case scenarios to understand that the same test case with the same list passes when any of the given exceptions are raised from the code.

Add a test case testMultipleException_NoSuchWindowException_passed(). This test will showcase how we can pass multiple exceptions as a list and test cases getting passed when the thrown exception is one amongst the list.

In this test case, you can see we are expecting to get either NoSuchElementException or NoSuchWindowException when trying to switch the window.

Executing this test would result in success as the window name given is invalid and would make the code throw NoSuchWindowException, which is on the *expectedExceptions *list.

Similarly, we can add another test case as testMultipleException_NoSuchElementException_passed(), keep the expectedExceptions list the same, and just update the code to raise NoSuchElementException due to an invalid web element locator and the test case is passed this time as well.

While working with multiple exception tests in TestNG, the test case could fail due to two reasons related to expected exceptions.

No exception is thrown at all from the test case.
The exception raised is not on the expected list.

Let’s take a look at the implementation of these.

In this test case, the expectedExceptions list is still the same as the previous one, but the code is updated to throw a *Timeout *exception.

Executing this would lead to failure because the thrown exception is not one of the given lists, and the output would look like the one below.

Another reason for failure in this implementation could be no exception thrown at all. For this, we keep the list the same and update the code to fetch a valid web element from the webpage.

Executing this would give results like the one below.

You can see from the highlighted error message that the test case failed as it was expecting an exception from the list, but none was thrown.

Which are the most wanted automation testing tools in 2023 that have climbed the top of the ladder so far? Let’s take a look on top test automation tools.

Exception test with Exception Messages

In this section, we take examples of test cases to understand how exception messages can be asserted in exception tests in TestNG.

In this case, we have added the code which should throw a NoSuchElementException with an exception message containing keywords no such element and the same is set to be verified as the expected message for the exception using the expectedExceptionsMessageRegExp attribute of *@test *annotation. Since this exception message is dynamic depending on the web element locator passed, we use regex to pass the expected message.

On executing the above case, you can see that the test output is passed since the expected and actual exception message is the same.

To demonstrate the failure due to TestNG assertion in the message, we reuse the same test case but update the execution code inside it to make it raise a different exception. A different exception would lead to another message and hence showcase test case failure in this example.

In the above code, we have updated the expected exception to be a valid one as there is no such window with the name new window, but the exception message is not updated. Let’s run it to see the output.

From the output error, it is evident that it failed due to the difference in the expected and actual exception messages.

Execution

Since we are using the LambdaTest cloud grid for the execution, results can be viewed on the LambdaTest Dashboard as well

You can also view details of all the test cases executed by navigating to the Build **section under **Automation.

If you want to test your knowledge around TestNG concepts, its configuration, annotations, and more, you can take TestNG certification by LambdaTest. LambdaTest TestNG certification is an industry-recognized certification that validates an individual’s proficiency in using the TestNG testing framework for automated testing.

Run your Jest automation tests in massive parallel across multiple browser and OS combinations with LambdaTest.

Conclusion

That concludes our blog on exception tests in TestNG. Throughout this post, we have gained knowledge about exception tests in TestNG, their purpose, and how to implement them with practical examples. By applying these concepts in your automation testing with TestNG in Selenium, you can achieve optimal results when encountering unforeseen circumstances. It’s time for you to dive in and start testing some exceptions!

How To Perform Local Website Testing Using Selenium And Java

Vipulgupta9090 — Mon, 06 Mar 2023 06:31:27 +0000

Users expect new features and websites to be seamless and user-friendly when they go live. End-to-end website testing in local infrastructure becomes an unspoken critical requirement for this. However, if this test is performed later or after the entire website or app has been developed, the possibility of bugs and code issues increases. Such issues can do more damage than we can ever think of.

According to a report, 88% of users are less likely to return to the website after a bad user experience. As much as $2.6 Billion is lost each year due to slow-loading websites and images on them if it takes more than an average of 2 seconds. Also, up to 8 out of 10 users stop visiting a website if it is incompatible with their device.

A mere look at these numbers is terrifying due to the cost and effort involved in fixing these at a later stage, in addition to the customer base lost due to bad impressions and first experiences.

In such situations, testing the websites beforehand becomes imperative on such platforms where this cost can be reduced to a minimum.

Cloud testing platforms like LambdaTest help test such websites on various local environments by providing remote access to real browsers and operating systems. This allows you to verify the functionality and compatibility of your website across different configurations without having to set up a complex test infrastructure.

Testing a website, especially in a production environment, can be time-consuming and resource-intensive. This can slow development and make it difficult to detect bugs and issues early on, delaying developer feedback.

Local website testing tests a website on a developer’s machine using automated functional tests. These test scripts can be designed to be integrated with the CI/CD pipeline and executed for each local deployment. This saves time and resources by identifying issues early, shortening the feedback cycle, and thus increasing the ROI on development and testing.

Automated local website testing enables developers to speed up and streamline the testing process. Effective test case management is crucial in this scenario, as it allows for testing on various browser configurations and OS versions to cater to the diverse systems used by end users. A well-designed test automation framework is essential for performing local testing efficiently.

Because we will be discussing website testing in this blog, Selenium is the best choice. Furthermore, because the website will be hosted locally, we will require a platform that allows for local website testing without interfering with the local infrastructure or the developer’s machine.

In this blog on local website testing, we will learn more about local page testing and its advantages in software development and the testing cycle. It follows how we can write an automation test script for a locally hosted website and execute the same in an organized manner so as not to block local infrastructure but still get faster feedback.

So, let us get started.

What is Local Website Testing?

Local website testing allows developers to host and test the website on their computers or local infrastructure. Once the developer is confident, the website can be moved to a live testing server before making it live in production.

This website is a copy that behaves like the real one and provides a place to test it with the least threat. This includes checking cross browser compatibility, user interactions, different links or images on the page, etc.

This configuration is ideally different from a staging or pre-prod test environment where any app or website is usually tested in a testing cycle by the QA team before it is made available on production. This is because in a staging or pre-prod environment, more stable services are running, or features are being tested at a later stage of development and require more regression testing and/or integration testing with external resources. As a result, we don’t want to risk breaking such an environment with early-stage changes that are more prone to bugs. Local hosting and testing websites become extremely important and useful in such cases.

There are a few different ways to set up local website testing. One common method is to use a local development server, such as XAMPP, which can be installed on a computer and configured to run a website. In this blog on local website testing, we will use the same to access the website on localhost.

Need a great solution for cross browser testing on Safari? Forget about emulators or simulators — use real online browsers. Try LambdaTest to test on safari browser online.

Advantages of Local Website Testing

There are several advantages to using local website testing.

Accelerated developer feedback: Local website testing greatly improves the feedback cycle as developers can quickly make changes to the code and check the results. This improves the development, leading to a better user experience and a more refined final product. Overall it highly improves the efficiency and effectiveness of the development process and allows the delivery of a high-quality website in a shorter time by reducing the risk of any major issues after launch.
Speed of Execution: It allows developers to quickly test their changes without waiting for the code to be deployed on testing environments. This saves a lot of time and helps them to iterate faster during the development cycle.
Cost-effective: Testing a website locally is highly cost-effective as it lessens or even eliminates the time required for testing on a live server, saving hosting and associated services costs.
Greater Control and Ease to Debug: A developer has better control over the environmental configurations when performing local website testing. Also, they have access to various debugging tools on their computers, like the developer’s console.
Integration with CI/CD pipeline: Local website testing can be used in conjunction with Continuous Integration and Continuous Development (CI/CD) pipeline to ensure that changes to the website are thoroughly tested before they are deployed.
Great fit for Agile: Local website testing can be a valuable tool in an Agile development environment because it allows developers to test changes to their website and receive feedback quickly.

It adds the advantage of allowing devs and QAs to work in parallel and provide better results.

Configuring Tunnel for Local Website Testing

Having understood the basics and advantages of local website testing, let us now move to the implementation part and see how we can perform it on our local computer.

In this blog, we will use the LambdaTest platform to test the locally hosted website.

LambdaTest cloud Selenium Grid supports testing of the local websites using the LambdaTest tunnel app. This tunnel allows you to test the website on over 3000+ real browser and OS combinations by connecting the local systems to LambdaTest servers via SSH-based integration.

%[https://youtu.be/KcqY1w_-LLE]

Test your native, hybrid, and web apps across all legacy and latest mobile operating systems on the most powerful Android emulator online.

Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorial around automated browser testing, Cypress E2E testing, Mobile App Testing, and more.

This tunnel helps you test plain HTML, CSS, PHP, Python, or similar web files saved on your local system over combinations of operating systems, browsers, and screen resolutions available on LambdaTest. This tunnel follows various protocols, such as Web Socket, HTTPS, SSH(Secure Shell), etc., to help you establish a secure and unique tunnel connection through corporate firewalls between your system and LambdaTest cloud servers.

Before setting up the tunnel and seeing how it works, we must host a local website or webpage. In this blog, we are referring to this CodePen project.

How to host a local website?

To set up and verify it by launching the webpage, follow these steps

Step 1: Open the link mentioned above, export the project, and unzip the downloaded *.zip.

Step 2: Make sure to turn on XAMPP or any other web hosting tool you use. If you are using XAMPP, start the Apache service under Actions.

Step 3: Copy and Paste the content from the unzipped folder in Step 1, inside the XAMPP htdocs folder, to access the website on this URL: http://localhost.

With this, the setup for the local website is done. Next, we move to the Tunnel configuration and see how we can use the same to perform automated testing of the local website.

Now, test your native, hybrid, and web apps across all legacy and latest mobile operating systems on the most powerful online emulator Android.

How to configure the tunnel?

This blog covers configuring the LamdbaTest tunnel connection and testing locally hosted web pages from a macOS (Big Sur) perspective. The configuration remains the same for all previous versions.

LambdaTest also supports tunnel configuration and testing of local websites on Windows and Linux machines.

Step 1: Create your account on the LambdaTest platform and login into the dashboard.

Step 2: Click Configure Tunnel on the top right and select COMMAND LINE. Then, download the binary file by clicking on Download Link. This binary helps establish a secure tunnel connection to the LambdaTest cloud servers.

Step 3: Navigate to your downloads folder and extract the downloaded zip.

Step 4: Copy the command to execute the downloaded binary from the dashboard. The command would look like this. You can mention an optional tunnelName in the command to identify which tunnel you want to execute your test case in case of multiple tunnels.

    LT --user {user's login email} --key {user's access key} --tunnelName {user's tunnel name}

Step 5: Execute the command to start the tunnel and make the connection. On successful tunnel connection, you will see a prompt “You can start testing now”. Please note that the tunnel has been named as LambdaTest.

Step 6: After this, move back to the LambdaTest Dashboard to verify the tunnel before we write automation code for local website testing using Selenium with Java.

Step 7: Navigate to Real Time Testing, select Browser Testing, enter the localhost URL you want to test, and select the tunnel name. You can select the test configuration of your choice from various major browsers & their versions to perform a test session. After selecting the configuration, click on the START button.

Step 8: At this point, you should get navigated to your localhost URL. This shows that the setup is verified, and we can write the automation code.

Are you using Playwright for automation testing? Run your Playwright test scripts instantly on 50+ browser/OS combinations using the LambdaTest cloud. Sign up for free.

Demonstration: Local Website Testing using Selenium and Java

Having completed the tunnel setup, let us now try to implement an automated test script for the same local website using Selenium and Java.

We would execute the script on the Lambda Test Selenium cloud grid through the tunnel we have already configured.

Test scenario for demonstration — navigate to localhost using the tunnel and click on the first toggle button.

A sample test script for local website testing using Selenium with Java would be like the one below.

  package test.java;


    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.HashMap;


    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeOptions;
    import org.openqa.selenium.remote.RemoteWebDriver;
    import org.testng.annotations.AfterTest;
    import org.testng.annotations.BeforeTest;
    import org.testng.annotations.Test;


    public class TestLocalWebsiteUsingTunnel {


       WebDriver driver = null;
       String user_name = System.getenv("LT_USERNAME") == null ? "LT_USERNAME" : System.getenv("LT_USERNAME");
       String access_key = System.getenv("LT_ACCESS_KEY") == null ? "LT_ACCESS_KEY"
               : System.getenv("LT_ACCESS_KEY");


       @BeforeTest
       public void testSetUp() throws Exception {
           ChromeOptions browserOptions = new ChromeOptions();
           browserOptions.setPlatformName("Windows 10");
           browserOptions.setBrowserVersion("108.0");
           HashMap<String, Object> ltOptions = new HashMap<String, Object>();
           ltOptions.put("username", user_name);
           ltOptions.put("accessKey", access_key);
           ltOptions.put("project", "Local Website Testing using Selenium JAVA");
           ltOptions.put("build", "Local Website Testing");
           ltOptions.put("tunnel", true);
           ltOptions.put("selenium_version", "4.0.0");
           ltOptions.put("w3c", true);
           browserOptions.setCapability("LT:Options", ltOptions);


           try {
               driver = new RemoteWebDriver(
                       new URL("https://" + user_name + ":" + access_key + "@hub.LambdaTest.com/wd/hub"), browserOptions);
           } catch (MalformedURLException exc) {
               exc.printStackTrace();
           }
       }


       @Test(description = "Demonstration of Automated Local Website Testing using LambdaTest Tunnel")
       public void testLocalWebsite() throws InterruptedException {
           driver.get("https://localhost");
           driver.findElement(By.cssSelector("[for='cb1']")).click();
       }


       @AfterTest
       public void tearDown() {
           if (driver != null) {
               driver.quit();
           }
       }
    }

Code Walkthrough

Step 1: The first step would be to create an instance of the RemoteWebDriver as we will be executing the code on the Selenium cloud grid.

Step 2: As already mentioned, since we are using LambdaTest cloud grid and tunnel for local website testing, we would need to add credentials of the same in the environment variables.

If you do not have your credentials, navigate to the LambdaTest Dashboard, click on the Profile icon in the top-right corner of your screen, then click on Profile.

You will find your username and access key here.

Step 3: Next, we add a function as testSetUp() to set the initial browser capabilities that will be passed on to the LambdaTest grid to define the browser and OS configurations. This method will be annotated with @BeforeTest annotation in TestNG as we want to execute it before each test case run.

The most important thing to note here is the following code to set the tunnel as true. This code tells the LambdaTest grid that this automation script is part of localhost website testing and that tunnel configuration is to be used for execution.

Step 4: After setting the initial capabilities and tunnel configuration, we add the test case function testLocalWebsite() inside, telling the driver to navigate to localhost and click on the first toggle button.

For this click, we are using the CSS Selector of the web element.

Step 5: After executing every test script, we must close the browser. To perform the same, another function as tearDown() is added and annotated with @AfterTest to execute it after every test execution.

A comprehensive end to end Testing tutorial that covers what E2E Testing is, its importance, benefits, and how to perform it with real-time examples.

Test Execution

So far, we have understood local website testing and how to make relevant configurations to perform the same on the LambdaTest platform using the tunnel. Now, we will execute the test script and see what the test execution looks like on the LambdaTest Dashboard.

Since we have used TestNG annotations, the test script can be executed as TestNG run. Upon execution, you will see results like below on Dashboard.

Navigate to Automation > Build to see the execution results.

To view the details of execution, click on the session name on the right side. You can note that the URL to test navigated is localhost, and Tunnel ID is the same as the tunnelName, i.e., LambdaTest, which we mentioned while starting the tunnel in the configuration section.

A comprehensive UI testing tutorial that covers what UI testing is, its importance, benefits, and how to perform it with real-time examples.

Conclusion

In this blog on how to perform local website testing using Selenium and Java, we have learned about local website testing and why it is so important in the software development world and implemented the same on the LambdaTest platform using an automation test script.
Overall, local website testing is an effective solution for developers who want to ensure that their website is thoroughly tested and free of bugs and issues before it goes to production.

Happy Local Testing!!

A Complete Guide To Selenium Page Load Strategy

Vipulgupta9090 — Fri, 03 Mar 2023 17:07:06 +0000

Webpage automation has been growing extensively, and most of us have worked on it. It is something on which we work almost regularly, automating several scenarios and navigating through many web pages.

But do you ever wonder what goes behind the scenes when the webpage is loaded in Selenium WebDriver? We know of a few WebDriver functions used to navigate to a webpage, like a get() *and *navigate(), but do they define how a page is loaded, or is there some other functionality at play in the backend of things?

The answer to this is YES! It is defined by something called the Page Load Strategy in Selenium WebDriver. The WebDriver uses Page Load Strategy to determine how the webpage will be loaded before you proceed with further interactions; to execute the next actions.

In this blog on Selenium Page Load Strategy, we will take a deeper look at this strategy and try to understand its different types and how they can be implemented in automation code.

So let us get started!

What is Page Load Strategy?

Page Load Strategy defines when the page would be considered loaded for the current session whenever the automation code launches a browser and uses get() or navigate().to() method. By default, Selenium WebDriver uses the standard Page Load Strategy, which is NORMAL. It means waiting until the entire webpage and its components, like CSS, images, frames, etc., are loaded.

If the page takes longer to load due to the components mentioned above (or throttling network conditions) and is not important to your script, you can change it to EAGER or NONE to speed up the execution. This value applies to the entire session, so wisely choose it for your project else it might lead to test flakiness.

The usage of Page Load Strategy has been introduced as a part of Selenium 4 features. Unlike past versions, it removes the dependency on using default page load timeouts.

Need a great solution for Safari for Windows? Forget about emulators or simulators — use real online browsers. Try LambdaTest for free.

How does Page Load Strategy work?

To determine whether the Page load is completed or not, Selenium makes use of the document.readyState property. The document.readyState describes the loading state of the document. A document here refers to any webpage that is loaded in the browser.

The Ready State method of Document is supported by all browsers, making it a reliable option for use with Selenium’s PageLoadStrategy.

Just like we have default PageLoadStrategy, default document.readyState for which Selenium WebDriver waits is Complete.

The readyState property of a browser’s document object represents the current state of the page loading process. The property can have one of the following values:

loading — The page is still loading.
interactive — The page has finished loading, but sub-resources such as images, stylesheets, and frames may still be loading.
complete — The page and all sub-resources have finished loading.

You can use the readyState property to determine when a page has fully loaded and is ready to be manipulated by JavaScript or other means. For example, in Selenium, you can use the readyState property to determine when a page has loaded, and the elements on the page can be interacted with using Selenium commands.

Before moving forward, let’s understand a bit more about the readyState of the document with a short exercise.

Navigate to https://ecommerce-playground.lambdatest.io/.
Once the site is loaded, right-click -> click on Inspect -> open the console and execute the command document.readyState.
As a result of this command, you would see the output as complete, which is the document’s current state. This means that the entire page is loaded with the necessary resources (i.e. images, CSS, etc.).
Next, refresh the page and hit enter again on the above command. You will be able to see the loading state of the document at this moment, like below.

If you cannot see the loading state after 4–5 refreshes, try throttling the Internet conditions by setting Network to slower options. You can learn more about it through this blog on testing websites on different network conditions. We will be making use of the same approach in the demonstration as well.

So this shows how document.readyState works in practice. You can also check the website’s performance under varying network conditions using LT Browser, a mobile-friendly tester tool. LT Browser is a complementary tool offered by LambdaTest, which allows you to test your website’s responsiveness on over 50 different devices, including smartphones, tablets, and laptops. It also offers the ability to create custom resolutions, simulate different network conditions, and generate performance reports using Google Lighthouse.

Let’s move forward to understand these values and how they are mapped with PageLoadStrategy values.

PageLoadStrategy <> document.readyState Mapping

The readyState of the document can be one of the following:

loading: Document load is under progress.
interactive: Document has been loaded and parsed, but the sub-resource like scripts, images, CSS, and frames are still loading. At this point, the DOMContentLoaded event is fired.
complete: Document and all sub-resources have finished loading. This indicates the firing of the load event.

Each PageLoadStrategy is mapped to a particular document.readyState value based on which the WebDriver will complete the navigation method and continue executing the next steps.

PageLoadStrategy	document.readyState	Description
Normal	complete	Used by default by browser and Selenium WebDriver. Waits for all the resources to be downloaded.
Eager	interactive	Resources like images and CSS might still be loading, but DOM is accessible and ready to interact.
None	any	WebDriver is not blocked at all. Execution continues without any wait as soon as the initial page is loaded.

Types of Page Load Strategies in Selenium

There are typically three types of Selenium Page Load Strategies that can be used in web automation.

NORMAL (Default, if not specified)

This Selenium Page Load Strategy makes the WebDriver wait until the page load is complete, i.e., the load event is fired.

The load event is fired when the page has loaded, including the dependent resources such as CSS, JavaScript, iFrames, and images.

It waits for the HTML content to be downloaded and parsed along with all the subresources.

EAGER

With this Selenium Page Load Strategy, the WebDriver only waits until the initial page is loaded and the DOMContentLoaded event is fired.

Unlike the load event, the DOMContentLoaded event is fired as soon as the DOM has been loaded without waiting for additional resources like CSS, JavaScript, iFrames, and images to be loaded.

It waits only for the HTML content to be downloaded and parsed.

NONE

In this Selenium Page Load Strategy, the WebDriver is not blocked and continues with the test execution.

It waits only for the HTML content to be downloaded.

You can learn more about waits through this blog on Waits in Selenium.

Do you use a Mac and want to run the test in Internet Explorer? This article explores how to test Internet Explorer on Mac.

Demonstration: WebDriver setup with different Selenium Page Load Strategies

Now that we have developed a basic understanding of different Selenium Page Load Strategies, let’s look at code examples to understand how it is implemented.

To do the same, we will be writing an automation testing script for the following scenario.

Create an instance of RemoteWebDriver using cloud-based Selenium Grid. For the same, we will be using the LambdaTest platform.
Set WebDriver capabilities to specific PageLoadStrategy.
Next, use the driver to launch the browser and navigate to https://ecommerce-playground.lambdatest.io/.
For this, we will note the time duration in which page load is completed to see how it varies for different Selenium Page Load Strategies under the same conditions. Differences in page load time will help get more clarity on all strategies.

Project Setup

For this Selenium Page Load Strategy blog, the Maven project using Java in Eclipse IDE will be used. If you are not a fan of Eclipse, use any IDE of your choice and perform the same steps. It will use Selenium WebDriver and TestNG dependencies to automate interaction with the page elements and test case execution. It is highly recommended to use the latest stable versions for better results.

Let’s get started now.

Launch Eclipse or the IDE of your choice.
Create a new Maven project and name it PageLoadStrategy.
Inside the src folder, add a test package and inside it a Test class and name it as TestPageLoadStrategy. This class will hold the entire code for this demonstration.

Update the pom.xml file to have the latest dependencies for using TestNG in Selenium, as shown below, before writing the actual test case.

 <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>PageLoadStrategy</groupId>
     <artifactId>PageLoadStrategy</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <build>
       <sourceDirectory>src</sourceDirectory>
       <plugins>
         <plugin>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.1</version>
           <configuration>
             <release>16</release>
           </configuration>
         </plugin>
       </plugins>
     </build>
     <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-java</artifactId>
           <version>4.6.0</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>7.7.0</version>
           <scope>test</scope>
       </dependency>
     </dependencies>
    </project>

Automate Cypress testing and perform browser automation testing with LambdaTest. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free.

Once the pom.xml is updated, add the following code to the test case file, TestPageLoadStrategy.java. This file will contain three tests demonstrating the usage of all three types of Selenium Page Load Strategies.

package test;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.*;
import java.util.HashMap;
import org.openqa.selenium.PageLoadStrategy;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.Test;

public class TestPageLoadStrategy {

   public RemoteWebDriver driver = null;
   String username = "<lambdtest_username>";
   String accessKey = "<lambdtest_accesskey>";

  ChromeOptions chromeOptions = new ChromeOptions();
   HashMap<String, Object> ltOptions = new HashMap<String, Object>();

   private void setup(String buildName) {

       chromeOptions.setPlatformName("Windows 10");
       chromeOptions.setBrowserVersion("108.0");

       ltOptions.put("project", "Page Load Strategy");
       ltOptions.put("selenium_version", "4.0.0");
       ltOptions.put("w3c", true);
       ltOptions.put("networkThrottling", "Regular 2G");
       ltOptions.put("build", buildName);
   }

   private void checkPageLoad() {
       try {
           driver = new RemoteWebDriver(
                   new URL("https://" + username + ":" + accessKey + "@hub.lambdatest.com/wd/hub"), chromeOptions);

           Instant startTime = Instant.now();
           System.out.println("Page load started at : " + startTime.toString());

           System.out.println("Navigating to the URL");
           driver.get("https://ecommerce-playground.lambdatest.io/");

           Instant endTime = Instant.now();
           System.out.println("Page load ended at : " + endTime.toString());

           Duration duration = Duration.between(startTime, endTime);
           System.out.println("Total PageLoad time : " + duration.toMillis() + " milli seconds");
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } finally {
           driver.quit();
       }
   }

   @Test
   public void testNormalStrategy() {
       // To set PageLoadStrategy = Normal
       setup("Page Load Strategy - Normal");

       chromeOptions.setPageLoadStrategy(PageLoadStrategy.NORMAL);
       chromeOptions.setCapability("LT:Options", ltOptions);
       checkPageLoad();
   }

   @Test
   public void testEagerStrategy() {
       // To set PageLoadStrategy = Eager
       setup("Page Load Strategy - Eager");
       chromeOptions.setPageLoadStrategy(PageLoadStrategy.EAGER);
       chromeOptions.setCapability("LT:Options", ltOptions);
       checkPageLoad();
   }

   @Test
   public void testNoneStrategy() {
       // To set PageLoadStrategy = None
       setup("Page Load Strategy - None");
       chromeOptions.setPageLoadStrategy(PageLoadStrategy.NONE);
       chromeOptions.setCapability("LT:Options", ltOptions);
       checkPageLoad();
   }
}

Code Walkthrough: TestPageLoadStrategy.java

This Java file is the main test class for demonstrating the implementation of all strategies using different functions.

Let’s understand each step in detail.

Step 1. The first step would be to create an instance of RemoteWebDriver. This is required to be able to support execution on cloud Selenium Grid.

Using cloud Selenium Grid provides increased scalability and speed for Java automation testing and allows users to perform extensive parallel and cross browser testing across several OS and browser combinations.

For this blog demonstration, we are using the LambdaTest Cloud Grid. LambdaTest is a highly scalable, reliable, and easy-to-use platform that provides support of over 3000+ browsers and OS to support execution on Selenium Cloud Grid.

Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress testing, and more.

Also, Online Selenium Grid to run your browser automation testing scripts on cloud infrastructure containing 3000+ desktop and mobile browser environments. Perform Selenium Testing on a cloud automation testing grid that scales along with your tests.

Step 3. Create an object of the ChromeOptions class. This class is used to manipulate various properties of the Chrome driver, which we will use for execution. This chromeOptions object will be used in each test case to set the PageLoadStrategy and then passed to WebDriver.

Step 4. Create a HashMap variable and name it as ltOptions. This will set various properties for the LambdaTest cloud grid execution.

Step 5. Next is the setup() method, used to set a few basic properties in chromeOptions and ltOptions. These are the common properties of all three PageLoadStrategy cases.

Also, note that we are using the networkThrottling property of LambdaTest to set the network to Regular 2G with 250 Kbps download speed and 50 Kbps upload speed. This will help demonstrate the load time better in all scenarios, as discussed in the previous section.

Using the LambdaTest platform provides this advantage where you can directly select the browser and version details, and your capabilities are automatically generated using LambdaTest Capabilities Generator. You just need to add them to the code.

This method takes one parameter, buildName. This parameter is used to display the build name on the LambdaTest Dashboard.

Step 6. Add a new function, checkPageLoad(). In the try block, we write the code to connect with RemoteWebDriver on the LambdaTest platform using the properties defined in chromeOptions.

After the connection is established, an object of the Instant class of java.time package is created to store and log the start time when we are about to launch the browser and start to navigate. This is followed by a driver called to the browser and the launch of the test website.

As soon as the website is considered loaded depending upon the set PageLoadStrategy, the driver passes the control to the next command, which is again an object of Instant class, to get the current time again, the end time.

By now, the page is loaded as per our requested strategy, and we have the start and end times. The time taken to load a webpage in milliseconds can be determined by finding the difference between two points. The Duration class, which is part of the same package, is used to accomplish this.

You will notice that this load time differs in all our test cases for different strategies.

A catch block is added next for the try block to handle the exception if it occurs. MalformedURLException is to catch the exception in case our RemoteWebDriver URL has invalid syntax. Once everything is done, we finally close the driver instance. To learn more about it, you can go through this blog on the most common exceptions in Selenium.

testNormalStrategy()

This is the test case to demonstrate the Normal strategy.

Firstly, the setup() method defines basic properties for the browser and LambdaTest platform. Next, the value for PageLoadStrategy is set as NORMAL here in the chromeOptions, followed by setting other capabilities.

Finally, the checkPageLoad() method is called to load the webpage and to log the load time, which we will compare for each strategy in the execution section.

testEagerStrategy()

This is the test case to demonstrate the Eager strategy.

All the steps, in this case, are similar to the previous one. The only difference being the value for PageLoadStrategy is set as EAGER here in the chromeOptions, followed by calling of the checkPageLoad() method.

testNoneStrategy()

This is the test case to demonstrate the None strategy.

Value for PageLoadStrategy is set as NONE here in the chromeOptions, and the rest of the steps are similar to previously discussed test cases.

Run your Selenium Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free!

Test Execution

Having understood the working and implementation of all the PageLoadStrategy, let us now execute the code and see the results of execution locally and on the LambdaTest Dashboard.

The test case would be executed using TestNG. To execute, follow the below mentioned steps:

Right-click the test case name in Eclipse IDE.
Go to Run Test, and select TestNG Test to begin the execution.

Let us, execute the cases one by one and see the load time varies for each strategy

NORMAL Strategy

You can notice the TotalPageLoad time, in this case, is 70852 milliseconds as we are using a network with Regular 2G speed. It has been established that the highest value should be among the three cases. As established so far, it should be the highest among all three. We can verify this by running the cases for Eager and None and comparing them.

EAGER Strategy

As expected, the PageLoadTime, i.e., 70231 milliseconds, for the Eager strategy in the same scenario is comparatively less than Normal.

NONE Strategy

You can note here that the PageLoadTime for None strategy is significantly less than the other two as it does not wait for any resources to be downloaded.

Here is a quick summary of the page load times in different strategies

PageLoadStrategy	PageLoadTime (in milliseconds)
Normal	70852
Eager	70231
None	28908

You can also view the execution results by navigating to the LambdaTest Dashboard as shown below for each PageLoadStrategy:

You can navigate to the Builds section under Automation to view details of your automation build.

Build details for PageLoadStrategy.NORMAL:

Build details for PageLoadStrategy.EAGER:

Build details for PageLoadStrategy.NONE:

If you are proficient in the TestNG framework and want to showcase your expertise as a test automation expert, you can obtain the TestNG certification from LambdaTest at no cost.

Now, run your Selenium Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

Conclusion

With this, we have reached the end of this Selenium TestNG tutorial on different Page Load Strategies in Selenium WebDriver. In this, we have learned about further usage and working of these Selenium Page Load Strategies and how we can integrate them in automation script and execute on Selenium Cloud Grid.

I hope now you can implement these in your use cases more efficiently.

Happy Loading!!

How To Automate Using TestNG In Selenium? [TestNG Tutorial]

Vipulgupta9090 — Fri, 09 Sep 2022 08:44:09 +0000

Automation testing is a fast-growing industry, and every tester tends to opt for tools and frameworks that are self-sufficient and offer useful features out of the box. Though there are a number of test automation frameworks like Selenium, Cypress, etc; I still prefer using Selenium.

The reason for choosing Selenium is very simple — Selenium supports the Java programming language.

The features offered by Selenium multiply when it is used in conjunction with Java-based test automation frameworks like TestNG, JUnit, etc. An ideal framework in such a case would be robust enough and complement the advantages of Selenium WebDriver & Java.

Of all the candidates available to serve these needs, the one that stands out is TestNG. TestNG is not only easy to implement and learn but also supports reporting of execution and logs. It makes parallel testing such an easy task! Ask any Selenium TestNG user to validate this claim, a majority of them will answer in affirmation. As per the State of open source testing survey, TestNG is one of the best Java testing frameworks preferred by developers. Selenium is the only test automation framework that is ahead of TestNG. Close to 50% of the organizations prefer the TestNG framework.

TestNG, where NG stands for Next Generation, is a testing framework developed by Cedric Beust. In this Selenium TestNG tutorial, I will deep dive into how to install TestNG and cover the essentials on writing your first automation script with TestNG for Selenium automation testing.

What is TestNG?

TestNG is an open-source advanced testing framework built on the capabilities of JUnit and NUnit. The framework is not only robust but also provides awesome features like TestNG annotations, grouping, parameterizations, etc., that help keep tests well-structured and easy to maintain.

At the time of writing this blog, the latest version of TestNG is 7.5. However, the preferred version is 6.14.3. I will be using the said version for demonstrating the features of TestNG Selenium in this Selenium TestNG tutorial.

The TestNG framework is designed to simplify a broad range of testing needs, from unit testing (testing a class in isolation of the others) to integration testing (testing entire systems made of several classes, several packages and even several external frameworks, such as application servers).

Salient features of TestNG:

Provides HTML Reports in an efficient easy to read format, thus catering to WebDriver’s limitation to generate such reports
Support to Group multiple test cases to be executed together whenever that particular group is invoked
Ability to set Priority among test cases which help to decide which case has to be executed first
Provides the ability to execute only the failed cases with the help of testng-failed.xml
Support for Cross Browser testing, Data Parameterization, and Parallel testing
Easy to understand Annotations, which helps control the sequence of execution in automation script without a static main method
Handles Uncaught Exceptions inherently, thus preventing sudden test termination.

This Cypress test automation tutorial will help you learn the benefits of Cypress automation, and how to install Cypress.

Installation and Setup of TestNG in Selenium

Having understood the features of TestNG, the next would be to know how to set it up on the system before I deep dive into the practical demonstration. In this tutorial on TestNG in Selenium, I will cover the installation process for 2 of the most used IDEs -Eclipse and IntelliJ.

Watch this video to learn how TestNG has become one of the most robust test automation frameworks and all you need to know to get started with TestNG in Selenium.

How to install TestNG in Eclipse

To install TestNG in Eclipse, download and install Eclipse IDE on your system.

Step 1: Launch Eclipse, click on Help, and select Eclipse Marketplace.

Step 2: Inside the Eclipse Marketplace window, go to the Search tab and find TestNG. If it is already installed, you will see the Installed button, and no need to continue with these steps; otherwise, it would say Install. Click Install in such a case.

Step 3: On the consecutive window, make sure the TestNG **checkbox is checked and click **Confirm.

Step 4: It is recommended to restart Eclipse after the installation is completed for changes to take effect correctly.

Step 5: After restarting, verify the installation by right-clicking on any project and checking if the TestNG menu is visible to create a TestNG class or not.

How to install TestNG in IntelliJ

In this section of the blog on TestNG in Selenium, I will cover how to install TestNG in IntelliJ. For IntelliJ, we will run tests on Java where we will download the JAR from the Maven Repositories website and add it.

But before proceeding to add the JAR, make sure you already have IntelliJ installed on the system. If not, you can download IntelliJ by navigating to the JetBrains website.

Step 1: Visit Maven Repositories, search for TestNG and select the latest most used version (i.e. 7.1.0). In this tutorial, I will be using TestNG version 6.14.3. Hence, the POM file that I will be using for demonstration will be having traces of TestNG 6.14.3.

Step 2: Select and download the jar file. We will be adding this jar to IntelliJ.

Step 3: Launch IntelliJ, open the File menu, and select Project Structure.

Step 4: Open the Modules panel, go to the Dependencies tab, click on + sign, and select JARs or directories.

Step 5: Navigate to the path where we have the downloaded jar from previous steps and select it.

Step 6: It would appear on the list of dependencies. Just check it and click the Apply button followed by the OK button.

And with this, we are done with installation on both IntelliJ and Eclipse.

This Playwright automation testing tutorial will guide you through the setup of the Playwright framework, which will enable you to write end-to-end tests for your future projects.

Project Setup in Eclipse

For this TestNG in Selenium tutorial, we would be going ahead with Eclipse IDE. In this section, we will learn how to create a TestNG project in Eclipse. However, if you are more comfortable using IntelliJ, then please go ahead with it. The steps mentioned would be the same irrespective of the IDE used. So let us create the project structure and add a test class to verify if it is being executed as TestNG Run or not.

In this entire tutorial, we will be using the same project structure as discussed above and add a new class file each time we want to practice something by executing and analyzing the output.

Create a Maven project in Eclipse and name it testng_selenium.
Update the pom.xml to have Selenium and TestNG dependencies.

POM, short for Project Object model, is an XML file that makes the basic fundamental unit of Maven. It stores the information about the project like version, description, etc., and also contains configuration details like dependencies, which Maven uses to build the project and make our scripts work.

<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) [https://maven.apache.org/xsd/maven-4.0.0.xsd](https://maven.apache.org/xsd/maven-4.0.0.xsd)">
  <modelVersion>4.0.0</modelVersion>
  <groupId>testng_selenium</groupId>
  <artifactId>testng_selenium</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <release>16</release>
        </configuration>
      </plugin>
    </plugins>
  </build>
   <dependencies>
   <dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>3.141.59</version>
   </dependency>
   <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.14.3</version>
            <scope>test</scope>
        </dependency>
  </dependencies>
</project>

Step 1: Create a package and name it test. This package will contain all our test class files.

Step 2: Inside this package, add a new class VerifySetup, add the following code, and save it.

package test;

import org.testng.annotations.Test;

public class VerifySetup {

[@Test](http://twitter.com/Test)
 public void verifySetup()
 {
  System.out.println("TestNG setup is working fine");
 }
}

Step 3: Now execute this as a TestNG test to verify the setup. For this select the class name, right-click on it, select Run As and then click on TestNG Test.

Upon successful execution, the output should look like the below. This verifies our TestNG setup and the same step can be done to execute more classes that we add in this tutorial.

TestNG Annotations and Attributes

Annotation means a note or a comment in any document that is used to provide it certain meaning. TestNG annotations also serve a similar purpose. These are used to provide meaning to any function in the test script and describe its behavior.

Annotations in TestNG are some predefined keywords that help to control the execution of the automation script in a proper flow. One must note, any test which is not annotated in TestNG is ignored while running tests. So it is mandatory to add required annotations for the test cases. Here is one example to understand this.

package test;

import org.testng.annotations.Test;

public class UnAnnotatedTestExample {

[@Test](http://twitter.com/Test)
 public void testWithAnnotation() 
 {
  System.out.println("This test is annotated");
 }

public void testWithoutAnnotation() 
 {
  System.out.println("This test is not annotated");
 }
}

As you can see, in the above example, we have added two test cases, one with @ Test annotation and one without it. So the expectation here is only the one with annotation is executed and another one is skipped. Let’s execute the class and verify this.

It is clear from the output, that only the case with annotation got executed. One more thing to note here is that the Test run on the output also shows the total number of test cases as 1 since TestNG reads the number of test cases from @ Test annotation and we had only one such case in the file.

TestNG annotations also provide relevant information about the method, class, or test suite they are associated with. These are represented by adding @ prefix. Let us have a look at all these annotations one by one, which we will use in this Selenium TestNG tutorial.

Types of Annotations

TestNG currently supports ten types of annotations.

@ Test

This is the most important annotation as it covers the actual test case logic and executes the automation run. There are some attributes associated with this annotation that helps to serve various use cases. We will learn these attributes in the following sections.

[@Test](http://twitter.com/Test)
public void testAnnotation()
{
//Write your test case logic here.
}

@BeforeTest

This annotation is executed before running any test with the @ Test annotation in a class. One example of using this can be to maximize the browser for test cases in a class.

[@BeforeTest](http://twitter.com/BeforeTest)
public void browserSetup()
{
//Code to maximize the browser
}

@AfterTest

This annotation is executed after all the test cases in a class are executed. One use case of this annotation would be to write the method to compile a test run report after all tests are run.

[@AfterTest](http://twitter.com/AfterTest)
public void compileReport()
{
//code to compile a report
}

@BeforeMethod

This annotation is executed before any and every test method, i.e., before every @ Test annotation method in the class. For example, we have cases to test some dashboard that comes up after login. So instead of writing login steps in each test case, @BeforeMethod annotation can be used to write those steps once in a method to be called before every test case.

[@BeforeMethod](http://twitter.com/BeforeMethod)
public void doLogin()
{
//code to do login
}

@AfterMethod

This annotation is executed after any and every test method, i.e., after every @ Test annotation method in the class. In continuation to the above example, let’s say we need to log out after every test case. In such a scenario, this annotation would help.

[@AfterMethod](http://twitter.com/AfterMethod)
public void doLogout()
{
//code to do logout
}

@BeforeClass

This annotation is executed before the first test method with @ Test annotation in the class is executed. For example, this can be used to navigate to the URL before executing the test.

[@BeforeClass](http://twitter.com/BeforeClass)
public void navigateUrl()
{
//code to navigate to URL
}

@AfterClass

This annotation is executed after the last @ Test method is executed. The method with this annotation can be used to close the driver after the automation run.

[@AfterClass](http://twitter.com/AfterClass)
public void closeDriver()
{
//code to close the driver
}

@BeforeSuite

This annotation marks the entry point of any automation script execution on TestNG in Selenium. Any method with this annotation is executed before any test in all the classes in that suite. This can be used to do generic setup steps for the execution, like initializing WebDriver for execution.

[@BeforeSuite](http://twitter.com/BeforeSuite)
public void initializeDriver()
{
//code to initialize the driver
}

@AfterSuite

This annotation in TestNG is the last to be executed after all test methods of all the classes within the suite have been executed. A method with this annotation is mostly used for cleanup activities like closing the active driver sessions.

[@AfterSuite](http://twitter.com/AfterSuite)
public void cleanUp()
{
//code to close all sessions
}

@BeforeGroups

TestNG provides the capability to group the tests with similar functionalities in a group with the help of the group attribute of @ Test annotation. This helps when we want to execute only a particular type of test case. The method with @BeforeGroup annotation is executed before the first test case for the given group is executed. We can mention the group name inside brackets next to the annotation.

[@BeforeGroups](http://twitter.com/BeforeGroups)("groupName")
public void startGroupExecution()
{
//code to execute before particular group test cases.
}

@AfterGroups

This annotation in TestNG is executed after all the test cases of a given group are executed.

[@AfterGroups](http://twitter.com/AfterGroups)("groupName")
public void stopGroupExecution()
{
//code to execute after particular group test cases.
}

With this, we have understood all the annotations used in TestNG. These annotations are highly usable as:

Very easy to learn as there are no rules on which annotation to use with which method. The tester can use them as per free will and understanding.
Ease of parametrization, which helps in creating groups and other tasks.
Strongly typed, which saves time by highlighting errors while implementing only.
Saves the time and effort to extend classes to define the order of execution, unlike JUnit

Watch this video to learn about the TestNG Annotations and how they help provide better structure and readability to the code.

Hierarchy of Annotations

TestNG annotations have a predefined hierarchy of execution which helps in executing the source code. These are executed in the below order :

[@BeforeSuite](http://twitter.com/BeforeSuite) -> [@BeforeTest](http://twitter.com/BeforeTest) -> [@BeforeClass](http://twitter.com/BeforeClass) -> [@BeforeMethod](http://twitter.com/BeforeMethod) -> [@Test](http://twitter.com/Test) -> [@AfterMethod](http://twitter.com/AfterMethod) -> [@AfterClass](http://twitter.com/AfterClass) -> [@AfterTest](http://twitter.com/AfterTest) -> [@AfterSuite](http://twitter.com/AfterSuite)

Let us have a look at the following code example to demonstrate the hierarchy better.

TestNGAnnotationsHierarchy.java

package test;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;


public class TestNGAnnotationsHierarchy {
 [@Test](http://twitter.com/Test)
 public void testCase1() {
   System.out.println("This is Test Case 1"); 
 }

 [@Test](http://twitter.com/Test)
 public void testCase2() {
   System.out.println("This is Test Case 2"); 
 }

[@BeforeMethod](http://twitter.com/BeforeMethod)
 public void beforeMethod() {
   System.out.println("This will execute before every Test Method");
 }

 [@AfterMethod](http://twitter.com/AfterMethod)
 public void afterMethod() {
   System.out.println("This will execute after every Test Method");
 }

 [@BeforeClass](http://twitter.com/BeforeClass)
 public void beforeClass() {
   System.out.println("This will execute before the Class");
 }

 [@AfterClass](http://twitter.com/AfterClass)
 public void afterClass() {
   System.out.println("This will execute after the Class");
 }

 [@BeforeTest](http://twitter.com/BeforeTest)
 public void beforeTest() {
   System.out.println("This will execute before the First Test");
 }

 [@AfterTest](http://twitter.com/AfterTest)
 public void afterTest() {
   System.out.println("This will execute after the Last Test");
 }

 [@BeforeSuite](http://twitter.com/BeforeSuite)
 public void beforeSuite() {
   System.out.println("This will execute before the Test Suite");
 }

 [@AfterSuite](http://twitter.com/AfterSuite)
 public void afterSuite() {
   System.out.println("This will execute after the Test Suite");
 }
}

Upon execution, this is how the output for this code snippet would be where all the methods get executed as per the hierarchy of the annotations.

Looking at this code example and the output, it is evident that TestNG religiously follows the order of execution of annotations.

One might wonder when you see this example is that since every annotation has a particular sequence defined, then how do the two @ Test methods in this example decide which one to execute when. This is something that is handled using test case priority in Selenium TestNG. The same will be covered in the upcoming sections of the blog.

TestNG Attributes

Just like a method in Java, TestNG annotations have attributes that help in making our tests more defined and provide more information about the test script while performing Selenium automation testing with TestNG. These attributes are:

description: It helps to define the purpose of the test

[@Test](http://twitter.com/Test)(description = "this is the definition of the test")

groups: This attribute helps to group test cases of the same functionality under a common group by giving it a group name. It is very useful when the user wants to execute cases of a particular group or wants to exclude cases of a particular group from execution.

[@Test](http://twitter.com/Test)(groups = "DashboardCases")

dependsOnMethods: The test having this attribute is only executed if the dependent test method passes. If it fails or is not executed, then the test with this attribute is skipped from execution.

[@Test](http://twitter.com/Test)(dependsOnMethods = "LoginFunctionality")

alwaysRun: It ensures that this test method always runs and is not dependent on the result of the methods that it depends upon.

[@Test](http://twitter.com/Test)(alwaysRun = true)

dataProvider: This attribute is used when we want to run a test case on a particular data set (e.g. running the same test case on different browsers). This attribute provides the data to the test case for which it is used with the help of another method annotated with @DataProvider annotation of TestNG.

[@Test](http://twitter.com/Test)(dataProvider = "CrossBrowserTesting")

We will learn more about DataProviders in a further section of this blog.
enabled: This attribute is helpful when we want to skip executing a particular test case. It helps to do so by setting the value to false.

@Test(enabled = false)

timeOut: This attribute is used to define the max execution time for a test case. In other words, the test case should be completed in the given time, which is given in milliseconds, else the test execution would be terminated, and the case would be marked as failed with timeout exception (org.testng.internal.thread.ThreadTimeoutException)

[@Test](http://twitter.com/Test)(timeOut = 5000)

invocationCount: This attribute is used when we want to execute the test case in a loop for a given number of times.

[@Test](http://twitter.com/Test)(invocationCount = 3)

Would execute the test case 3 times
invocationTimeOut: This attribute is used in combination with the invocationCount attribute. This attribute defines the timeframe within which the test should execute for a given number of times.

 [@Test](http://twitter.com/Test)(invocationCount = 3, invocationTimeOut = 20)

Means execute the case 3 times in 20 milliseconds.
expectedExceptions: This attribute helps to handle the exceptions that the test method is expected to throw. If the test method throws the exception that is set on the attribute, then the test case passes, and for any other unhandled exception, the test method fails.

    [@Test](http://twitter.com/Test)(expectedExceptions = {ArithmeticException.class})

priority: This attribute is used to define the order of execution by assigning priorities to the test cases. A test method with lower priority is always executed first.

[@Test](http://twitter.com/Test)(priority=1), [@Test](http://twitter.com/Test)(priority=2)

In this case, the test with priority 1 is executed first, followed by the test with priority 2. Move to the next section to know more about priorities.

Consider the below code example to understand attributes implementation.

package test;

import org.testng.annotations.AfterGroups;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.Test;

public class TestNGAttributesExample {

[@Test](http://twitter.com/Test)(enabled = false, description = "This test will be skipped as enabled is set to false")
 public void disabledTest() {
  System.out.println("This method will be skipped from the test run using the attribute enabled=false");
 }

[@Test](http://twitter.com/Test)(invocationCount = 5, invocationTimeOut = 20, groups = "testngAttributes")
 public void invocationCountTest() {
  System.out.println("This method will be executed by 5 times");
 }

[@Test](http://twitter.com/Test)(timeOut = 500, groups = "testngAttributes")
 public void baseTest() {
  System.out.println("This is base test method");
 }

[@Test](http://twitter.com/Test)(dependsOnMethods = "baseTest", groups = "testngAttributes")
 public void firstDependentTest() {
  System.out.println("This is dependent method 1 and will only execute if baseTest passes");
 }

[@Test](http://twitter.com/Test)(alwaysRun = true, dependsOnMethods = "baseTest", groups = "testngAttributes")
 public void secondDependentTest() {
  System.out.println(
    "This is dependent method 2 and will execute irrespective of baseTest result because of alwaysRun");
 }

[@BeforeGroups](http://twitter.com/BeforeGroups)("testngAttributes")
 public void beforeGroupMethod() {
  System.out.println("This method is executed before testngAttributes group test cases");
 }

[@AfterGroups](http://twitter.com/AfterGroups)("testngAttributes")
 public void afterGroupMethod() {
  System.out.println("This method is executed after testngAttributes group test cases");
 }
}

Running the above code would give the following output:

TestNG Priorities

As mentioned before in this TestNG in Selenium tutorial, test case execution in TestNG is governed by the priority of test cases. But what if no priority is assigned to test cases. Then what decides the order of execution.

If there are multiple test cases, then TestNG executes them in alphabetical order. So for the following code, aTest is executed before bTest.

[@Test](http://twitter.com/Test)
public void aTest()
{}

[@Test](http://twitter.com/Test) 
public void bTest()
{}

Now, let us assume a scenario where we want to execute bTest first. In such scenarios, a priority attribute is used. We can achieve this by assigning lower priority to the test we want to execute first. Priorities in TestNG can be assigned starting from 0, where lower priority cases are executed first.

[@Test](http://twitter.com/Test)(priority = 2)
public void aTest()
{}

[@Test](http://twitter.com/Test)(priority = 1)
public void bTest()
{}

In this case, bTest will be executed before aTest.

The next question that comes up is, what if the same priority is assigned to both test cases.

[@Test](http://twitter.com/Test)(priority = 1)
public void aTest()
{}

[@Test](http://twitter.com/Test)(priority = 1)
public void bTest()
{}

In such a case, TestNG runs the cases in alphabetical order, i.e., aTest will be executed before bTest.

Another scenario could be that the test class file is a combination of test cases with and without priority like below

package test;

import org.testng.annotations.Test;

public class TestNGPrioritiesExample {
 [@Test](http://twitter.com/Test)(priority = 1)
 public void aTest() {
  System.out.println("This is test a.");
 }

[@Test](http://twitter.com/Test)(priority = 2)
 public void bTest() {
  System.out.println("This is test b.");
 }

[@Test](http://twitter.com/Test)
 public void cTest() {
  System.out.println("This is test c.");
 }

[@Test](http://twitter.com/Test)(priority = 1)
 public void dTest() {
  System.out.println("This is test d.");
 }

[@Test](http://twitter.com/Test)
 public void eTest() {
  System.out.println("This is test e.");
 }

}

In such a case, TestNG, by default, assigns a priority = 0 to such cases that do not have the attribute. Those are executed first in alphabetical order, followed by other cases as per priorities logic. So the output for the above code would be

This is all about priorities, and these would be highly beneficial to use in any automation script while working with TestNG in Selenium. To learn more about the test case priority, you can go through our earlier blog on how to set test case priority in TestNG with Selenium.

DataProviders in TestNG

DataProviders in TestNG is a part of the inbuilt TestNG data-driven testing approach and is used to pass different values to the same TestNG test class through @DataProvider annotation.

TestNG DataProvider sample:

[@DataProvider](http://twitter.com/DataProvider)(name = "dataProvider_name")
public Object[][] dataProviderMethod() {
return new Object[][] {<values>};
}

This annotation consists of only one attribute- name and it is always of type String. If the name is not provided then the name of the method becomes the data provider name by default, dataProviderMethod in this case.

DataProvider always returns a 2-D list of objects, on which the test method performs the execution using a data-driven approach on each passed argument.

Let’s take an example of a simple cross browser code where we want to navigate to a website on both Chrome and Firefox browsers.

package test;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class DataProviderExample {

[@DataProvider](http://twitter.com/DataProvider)(name = "browserName")
 public Object[][] browserName() 
 {
  return new Object[][] { { "chrome" }, { "firefox" } };
 }

[@Test](http://twitter.com/Test)(dataProvider = "browserName")
 public void crossBrowserTest(String browser) 
 {
  WebDriver driver = null;

  System.out.println("Launching browser : " + browser);

  switch(browser)
  {
   case "chrome":
    System.setProperty("webdriver.chrome.driver", "<Path_to_your_chrome_driver>");
    driver = new ChromeDriver();
    break;
   case "firefox":
    System.setProperty("webdriver.firefox.driver", "<Path_to_your_firefox_driver>");
    driver = new FirefoxDriver();
    break;
   default:
    System.out.println("Invalid browser name passed");
  }

  driver.navigate().to("[http://www.lambdatest.com/](http://www.lambdatest.com/)");
  System.out.println("Navigated Successfully to the website");
 }

}

In the above code, we have implemented DataProvider having a name as browserName, which passes 2 values chrome and firefox. These values are passed to the test method crossBrowserTest using the parameter value and the test case is executed one by one on both browsers.

This is a classic example of cross-browser testing code implementation where we want to execute the same script on multiple browsers.

Executing the above code would give an output like:

One thing to note here is that instead of having only 1 @ Test annotated test case, the execution shows two test cases are executed. This is because we passed 2 different values to the test case and hence TestNG treats it as 2 separate test cases since the test data is different.

TestNG Assertions

Assertions provide the means to verify if the actual and expected results of the test case execution are a match or not thus deciding the outcome of the test case whether it is a pass or fail. These are widely used to validate the results in any script of TestNG in Selenium.

An example of TestNG Assertions would be to validate the username on the dashboard after a user logs in to a website.

The syntax for TestNG Assert:

Assert.Method(actual, expected, message)

actual: the actual value which is fetched from the test case as a part of the execution.
expected: the expected value with which we want to compare the actual value.
message: string message to be displayed in case of assert failure.

Want to perform browser test automation cloud on the most powerful cloud infrastructure? Leverage LambdaTest automation testing for faster, reliable, and scalable experience on cloud.

Types of TestNG Asserts

Hard Assert: These are the default type of asserts in TestNG. These assert stop the test case execution when any assert fails and subsequent statements are not executed/validated. These are used in cases when subsequent steps in the test cases are not to be executed when a particular step assertion fails.

Soft Assert: These are the opposite of Hard Asserts. In the case of soft assert, the test case execution of subsequent steps continues even if some assert fails in between. These are used when we want to continue the execution and see the results for all steps even if a few fails in between. To use soft asserts, org.testng.asserts.SoftAssert package needs to be included.

The most commonly used TestNG asserts are:

assertTrue
This assertion verifies whether the given condition is true. If false, it will fail the test case.

Assert.assertTrue(condition, message);

assertFalse
This assertion verifies whether the given condition is false. If true, it will fail the test case.

Assert.assertFalse(condition, message);

assertEquals
This assertion verifies if the actual and expected are a match. If they match, it passes the test case otherwise fails.

Assert.assertEquals(actual, expected, message);

assertNotEquals
This assertion verifies if the actual and expected are not a match. If they match, it fails the test case otherwise passes.

Assert.assertNotEquals(actual, expected, message);

TestNG Selenium Demonstration

By now, this TestNG in Selenium tutorial has covered almost all the main features of the TestNG framework that you would need to write your first Java automation script. In the following code example, we will combine all the annotations, attributes, priorities, data providers, and assertions that we have learned so far.

The following test scenario will be executed by this code (To print and verify the sum of 2 numbers)

Create a dataProvider that passes values as firstValue, secondValue, expectedSum.
Navigate to https://www.lambdatest.com/selenium-playground/simple-form-demo.
Run Test 1 with the first set of values, {1, 4, 5}. This test should pass as the expected sum is correct.
Clear the old values from the form.
Run Test 2 with the second set of values, {2, 4, 7}. This test should fail as the expected sum is not correct. We are intentionally passing incorrect expected values to see the differences in output and test reports for passed and failed cases. Always remember that ideally the expected should always be the correct value. This is done just for the tutorial purpose here.
Execute the code and analyze the reports.

In addition to this test case, we will add two more test cases with priority to showcase the usage, along with one of them having invocationCount attribute to show case getting executed multiple times as per priority.

package test;

import java.net.MalformedURLException;
import java.net.URL;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.*;
import org.testng.Assert;
import org.testng.annotations.*;

public class SeleniumTestNGExample {

public RemoteWebDriver driver = null;
 String username = "<lambdatest_username>";
 String accessKey = "<lambdatest_accesskey>";

[@BeforeSuite](http://twitter.com/BeforeSuite)
 public void setUp() {
  DesiredCapabilities capabilities = new DesiredCapabilities();
  capabilities.setCapability("browserName", "Chrome");
  capabilities.setCapability("version", "92.0");
  capabilities.setCapability("platform", "Windows 10");
  capabilities.setCapability("resolution", "1024x768");
  capabilities.setCapability("build", "TestNG Selenium Tutorial");
  capabilities.setCapability("name", "TestNG Selenium JAVA");

try {
   driver = new RemoteWebDriver(
     new URL("https://" + username + ":" + accessKey + "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub"), capabilities);
  } catch (MalformedURLException e) {
   System.out.println("Invalid grid URL");
  }
  System.out.println("The driver setup process is completed using BeforeSuite");
 }

[@BeforeTest](http://twitter.com/BeforeTest)
 public void browserProfile() {
  driver.manage().window().maximize();
  System.out.println("The browser profile is updated using BeforeTest");

}

[@BeforeClass](http://twitter.com/BeforeClass)
 public void navigateToUrl() {
  driver.get("[https://www.lambdatest.com/selenium-playground/simple-form-demo](https://www.lambdatest.com/selenium-playground/simple-form-demo)");
  System.out.println("Navigated to URL using BeforeClass");
 }

[@Test](http://twitter.com/Test)(description = "Test case with priority", priority = 1)
 public void testPriotity()
 {
  System.out.println("This case has priority 1");
 }

 [@Test](http://twitter.com/Test)(description = "Test case with priority and invocation count", priority = 2, invocationCount = 2)
 public void testInvocationCount()
 {
  System.out.println("This case has priority 2 and invocation count");
 }

[@DataProvider](http://twitter.com/DataProvider)(name = "SanityTestData")
 public Object[][] sanityTestDataProvider() {
  String[][] testData = { { "1", "4", "5" }, { "2", "4", "7" } };
  return testData;
 }

[@Test](http://twitter.com/Test)(dataProvider = "SanityTestData", description = "Test case with group and data provider but without priority
", alwaysRun = true, groups = { "sanity" })
 public void testSumOfTwoValues(String firstValue, String secondValue, String expectedSum) {
  // to enter data and submit
  driver.findElement(By.id("sum1")).sendKeys(firstValue);
  driver.findElement(By.id("sum2")).sendKeys(secondValue);
  driver.findElement(By.xpath("//button[text()='Get values']")).click();

// to fetch actual result
  String actualSum = driver.findElement(By.id("addmessage")).getText();

// to assert actual and expected result
  Assert.assertEquals(actualSum, expectedSum,
    "Expected and actual results do not match. Expected : " + expectedSum + " and Actual : " + actualSum);

}

[@AfterMethod](http://twitter.com/AfterMethod)()
 public void clearOldData() {
  driver.findElement(By.id("sum1")).clear();
  driver.findElement(By.id("sum2")).clear();
 }

[@AfterClass](http://twitter.com/AfterClass)
 public void closeDriver() {
  driver.quit();
  System.out.println("Quit the driver using AfterClass");
 }

[@AfterTest](http://twitter.com/AfterTest)
 public void testReporting() {
  System.out.println("Test Report generated using AfterTest");
 }
}

You can see that this code uses a number of annotations, dataProviders, assertions, priorities and attributes which we have learnt and gives an idea of how these can be used together while working with automation scripts on TestNG in Selenium to use the features at full extent.

In this TestNG in Selenium tutorial, I have created an instance of Selenium RemoteWebDriver as the TestNG framework is best utilized with a Cloud Selenium Grid. The reason being, along with the advantages of Selenium Grid like executing multiple cases together across a variety of browsers and OS, a Cloud Grid also offers the speed and scalability which makes executions faster and more reliable with improved debugging and troubleshooting support.

So, in this code example, we will be executing our code on LambdaTest, which is one such Selenium Cloud Grid for performing cross browser testing at scale. It helps to execute testing across 3000+ real online browsers and OS without the hassle of maintaining in-house Selenium Grid. Selenium testing tools like LambdaTest provides interactive reporting dashboards for results analysis, a great variety of logs, and integrations with top CI/CD tools, project management tools, etc.

Next, we add the LambdaTest username and access key from the LambdaTest profile section to be used to run the script.

Code Walkthrough

Inside the setUp() method, browser capabilities are being set, and a remote grid is launched, which is to be used for executing the run.

browserProfile() method will help to execute the step to maximize the browser window once it is launched.

We have used the navigateToUrl() method to open the website on which the test would be executed.

We have added two test cases that will run on local only to showcase the usage of priority and invocationCount usage, namely testPriotity() and testInvocationCount().

sanityTestDataProvider() provides two sets of test data on which the test method would be executed of which one should pass and the other should fail, as already stated above.

testSumOfTwoValues() is the actual test method where we have added the steps to enter the values and fetch the results to be compared using assertion. This method is executed once for each type of test data and helps to decide whether it is a pass or fail by means of assert.

Next to fetch the result of execution, we use the getText() method with the identifier and store it as a String. Post this, we add Assertion to help validate the result.

In this code, we have implemented assertEquals which will compare the values and print a message if there is a mismatch.

clearOldData() function helps to clear the data filled in the input text boxes as a part of previous test execution.

After every execution, it is a good practice to close any driver instances that we have created during the course of execution. The same has been implemented by the closeDriver() method.

In order to signify the completion of the executed test run and provide the tester with a message that the test report is ready to be analyzed, we have used the testReporting() method.

The two most important parts of the sample code are the dataProvider method and the main test method.

The above helps to find the web elements and enter data in the input boxes and then it by clicking the button. To fetch web element locators, we navigate to the page and right-click, and then do Inspect to find the locators as desired by any strategy like id, XPath, CSS, etc.

This Selenium testing tutorial for beginners will help you interact with web elements in Selenium WebDriver.

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

Having understood the sample code, now execute the class as TestNG Test to get output.

In this screenshot, we can see the test case gets executed as per priority, and the one with invocation count as 2 gets executed two times.

You can see that Default test numbers show total Tests run: 3 since we have three @ Test annotated test cases in the class of which 1 has failures and hence Failures: 1.

However, the Default suite section shows the actual number of test cases along with the actual passed and failed number of cases.

*Total tests run: 5 *-> testPriotity() executed 1 time + testInvocationCount() executed 2 times + testSumOfTwoValues() executed once for each data set (total 2 times) -> 1 + 2 + 2 = 5

For the failed test case, the log shows the message we added on the assert to appear in case of failure: Expected and actual results do not match. Expected: 7 and Actual: 6

Also, we can log in to the LambdaTest Dashboard to check the execution results for the automation script we have executed.

You can see more detailed logs and reporting for this run by clicking on the recent test run and navigating to the LambdaTest Automation Logs section, as shown below.

In addition to the Automation Logs and related info with it, the LambdaTest Dashboard now provides users with more detailed views and data about test case execution and associated trends in graphical representation by means of LambdaTest Analytics Dashboard available under the Automation Tab.

Analytics also provides you the ability to analyze the test trends and resource utilization by means of multiple filters like users, OS, browsers, etc.

TestNG Reports Generation in Selenium

The same results can be analyzed in a more formatted way with the help of HTML reports generated by TestNG. To access the same, refresh your project by right-clicking on the project name. This is advised to update the report to the latest run.

Next, navigate to the test-output folder and from it open the index.html file. This is the default format report for the TestNG run.

If you select the test from the Info section, it shows the number of classes executed and the number of failed tests.

Selecting the group section shows the name of the group and test case methods executed as a part of it.

Chronological View shows the order in which all the methods in the class were executed, along with the time taken by each function on each step.

Last, and most important is the Results section, which shows the complete detail of the executed cases with proper exception/asserts failure in case of failed test cases. We can hide/show only passed or only failed test cases as well using this section as per the requirement.

If you are a test automation expert and want to demonstrate your proficiency in the TestNG framework, you can earn this TestNG certification offered by LambdaTest for FREE

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:

Conclusion

With this Selenium TestNG tutorial, we can easily conclude that using TestNG in Selenium makes the tests more structured and easy to maintain. Moreover, with the support of its additional features like reporting, dataProviders, more robust annotations, etc., over its predecessors, TestNG makes the automation testing experience user-friendly. Having said that, it is time for you to get started with your first TestNG in Selenium automation project, and remember to use the annotations wisely as they are to make life easier.

Happy Testing!!

How To Handle Modal Dialog Box In Selenium WebDriver Java

Vipulgupta9090 — Thu, 08 Sep 2022 10:21:07 +0000

Websites nowadays are frequently implementing the usage of pop-ups, alerts, or modal dialog boxes for various use cases like accepting cookies, asking for permissions, entering data, warning alerts, etc. Although there are a few valid use cases for these, unnecessary popups might look annoying and need to be handled.

You must have encountered these in your day-to-day web interactions on different websites like Amazon or Walmart on the first visit prompting for SignUp, on various food websites like McD, Swiggy to provide the location, or a payment gateway modal to complete payment.

With this increased usage, it is now expected of an automation tester that they are aware of their handling via automation. The main reason is that most of these popups, which at times are multiple, appear on the homepage for the website under test and need to be handled/closed till the parent page is accessible to interact with and the actual test flow can begin.

So if you have not got a chance to work on these or automate them so far, this blog is the right one for you. In this blog, we will learn how to handle modal dialog box in Selenium WebDriver Java with practical examples.

This blog would cover handling Bootstrap dialog boxes, pop-up windows/tabs, and alerts. I will be starting with the basics of pop-ups, post which I will demonstrate how to handle modal dialog box in Selenium WebDriver Java. So let’s get started.

How to handle Modal Dialog Box in Selenium WebDriver Java?

In this Selenium Java tutorial, we will learn what is a modal dialog box and demonstrate the handling of a modal dialog box in Selenium Java.

What is a Modal Dialog Box?

A Modal Dialog Box (also referred to as Bootstrap Modal Window) is built in Bootstrap Framework, due to which it gets displayed on top of your current page. Due to this, modal boxes need to be interacted with first before moving to the current webpage.

For starters, The Bootstrap Framework is a very popular, free, and open-source CSS framework that is highly used in web page development, especially for responsive and mobile-first web pages. It contains HTML, CSS, and JavaScript. To learn more about the Bootstrap framework, you can deep dive into CSS Grid vs. Bootstrap comparison.

A modal dialog box written with Bootstrap is formed with three key components, namely,

Trigger element, which triggers the modal window to be shown on the webpage. It can be any link on the webpage or any button, etc.
Modal, which is like a holding area for the actual modal window code that will come up when the trigger element is interacted with.
Modal content, is the actual code and the content with which the window is formed and displayed as per the implementation.

So while automating any modal window, we first fetch the modal using our web driver and then identify the modal content inside it to perform actions.

Do you wish to perform browser automated testing on the most powerful cloud infrastructure. Leverage LambdaTest automation testing now.

Demonstration: Handling Modal Dialog Box in Selenium WebDriver Java

Having developed a basic understanding of the modal dialog box, it’s time to implement it and see how it works in real-time.

Please note that for all the examples in this blog, we will be using this same project setup for all the examples in this blog and keep adding more test class files as we proceed. So do the setup carefully on your machine for implementation purposes.

Step 1. Choose the IDE on which you want to do the setup. In this blog, Eclipse IDE is being used. You can follow the same steps if any other IDE has opted. In case you are using IntelliJ, you can go through the article on building and executing Selenium Projects.

Step 2. Create a Maven Project in Eclipse and name it as Dialog_Boxes_With_Selenium_Java.

Step 3. Update the pom.xml file to have Selenium (as it will be a web automation project using Selenium WebDriver) and TestNG (to create test flow and execute test cases using Annotations) dependencies.

<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) [https://maven.apache.org/xsd/maven-4.0.0.xsd](https://maven.apache.org/xsd/maven-4.0.0.xsd)">
  <modelVersion>4.0.0</modelVersion>
  <groupId>Dialog_Boxes_With_Selenium_Java</groupId>
  <artifactId>Dialog_Boxes_With_Selenium_Java</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <build>
 <sourceDirectory>src</sourceDirectory>
 <plugins>
   <plugin>
     <artifactId>maven-compiler-plugin</artifactId>
     <version>3.8.1</version>
     <configuration>
       <release>16</release>
     </configuration>
   </plugin>
 </plugins>
  </build>
  <dependencies>
     <dependency>
       <groupId>org.seleniumhq.selenium</groupId>
       <artifactId>selenium-java</artifactId>
       <version>3.141.59</version>
     </dependency>
     <dependency>
       <groupId>org.testng</groupId>
       <artifactId>testng</artifactId>
       <version>7.5</version>
       <scope>test</scope>
     </dependency>
  </dependencies>
</project>

Step 4. Now inside the src package, add a package and name it as test. This will contain all the test classes which will be created in this blog.

Step 5. Inside the test package add a Java class file and name it as BaseClass.java. This file will have the basic driver functions like, initialize driver, quit driver, etc.

In this blog on how to handle modal dialog box in Selenium WebDriver Java, we will be using the TestNG testing framework for test execution. Reason being, it is widely supported with Selenium Java testing and provides an easy way to write and manage test automation scripts with the usage of annotations.

package test;

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

import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;

public class BaseClass {

  public RemoteWebDriver driver = null;
  String username = "<lambdatest_username>";
  String accessKey = "<lambdatest_accesskey>";

  [@BeforeMethod](http://twitter.com/BeforeMethod)
  public void setUp() {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "Chrome");
       capabilities.setCapability("version", "92.0");
       capabilities.setCapability("platform", "Windows 10");
       capabilities.setCapability("resolution", "1024x768");
       capabilities.setCapability("build", "DialogBoxes And Pop-ups Selenium JAVA");
       capabilities.setCapability("name", "DialogBoxes And Pop-ups Selenium JAVA");

       try {
            driver = new RemoteWebDriver(
                       new URL("https://" + username + ":" + accessKey + "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub"), capabilities);
       } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
       }
  }

  [@AfterMethod](http://twitter.com/AfterMethod)
  public void closeDriver() {
       driver.quit();
  }
}

}

Code Walkthrough

We have created BaseClass.java as the first file, which will have the code to initiate the browser session for Selenium automation and handle the code for browser setup and closing it after test completion. This will be inherited to our test classes, thus preventing redundancy for such code and providing an abstraction of driver code from every other class user.

Step 1. Inside the BaseClass, we will be adding two functions, one to initialize the driver and create an instance of it and another to close it once the test cases are executed.

We will be executing the code on a Selenium Cloud Grid using an instance of Selenium RemoteWebDriver.

The reason is, along with the advantages of Selenium Grid, like executing multiple cases across various browsers and OS, a Cloud Grid also offers speed and scalability, which makes executions faster and more reliable.

An example of one such Selenium Cloud Grid is LambdaTest, which facilitates cross browser testing across an online browser farm of 3000+ real browsers and operating systems on the cloud. Automation testing tools like LambdaTest provide an interactive reporting dashboard for results analysis along with all the benefits of cloud testing.

Here’s a glimpse of LambdaTest cloud Selenium Grid:

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

public RemoteWebDriver driver = null;

Step 2. Next would be to add the LambdaTest username and access key for your account to be used to run the script. You can find these details in the LambdaTest Profile Section.

String username = "<lambdatest_username>";
String accessKey = "<lambdatest_accesskey>";

Step 3. After that, add the first method in this file as setUp(), which would be used to set initial capabilities for the browser and launch the grid with the given credentials.

You can see we have set some capabilities for the Chrome browser to be used for our test case. As we are using the LambdaTest platform here for remote execution, we can take advantage of its Selenium Desired Capabilities Generator to generate such values for a number of browser and operating systems combinations by selecting them as required.

Step 4. Just like the setUp() method would create the driver instance to be used for executing the script, it is a good practice to quit the current browser instance as soon as the case is completed. To facilitate the same, add the next method as closeDriver() to quit the driver instance. This would have @AfterMethod annotation in TestNG as the method with this annotation will be called after every test method has completed execution.

[@AfterMethod](http://twitter.com/AfterMethod)
public void closeDriver() {
 driver.quit();
}

This completes the setup for our base implementation. Let’s move to the next section to implement and see how modal dialog box automation works.

Do you wanna know which are the most wanted automated testing tools that have climbed the top of the ladder so far? Let’s take a look.

Modal Dialog Box Automation Example

For this blog purpose, we will be automating the following flow:

Navigate to https://www.lambdatest.com/selenium-playground/bootstrap-modal-demo.
Click on Launch Model under Single Modal Example.
Fetch the modal container web element.
Fetch the modal content web elements using the container element.
Verify and interact with the modal dialog window.

package test;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.testng.Assert;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

public class TestModalDialogBox extends BaseClass {

[@Test](http://twitter.com/Test)(description = "test to verify modal dialog box")
 public void verifyModalDialogBox() throws InterruptedException {
  // to navigate to the website
  System.out.println("Navigating to the website");
  driver.get("[https://www.lambdatest.com/selenium-playground/bootstrap-modal-demo](https://www.lambdatest.com/selenium-playground/bootstrap-modal-demo)");

// to click Launch model button - Trigger element
  System.out.println("Clicking launch modal button");
  driver.findElement(By.xpath("//button[[@data](http://twitter.com/data)-target='#myModal']")).click();

// wait to let the modal box be visible
  WebDriverWait wait = new WebDriverWait(driver, 30);
            wait.until(ExpectedConditions.visibilityOfElementLocated(
                                     By.className("modal-dialog")));

// to fetch the web element of the modal container
  System.out.println("Fetching the web element for modal container");
  WebElement modalContainer = driver.findElement(
                       By.className("modal-dialog"));

// to fetch the web elements of the modal content and interact with them
  // code to fetch content of modal body and verify it
  System.out.println("Fetching modal body content and asserting it");
  WebElement modalContentBody = modalContainer.findElement(By.xpath(".//div[[@class](http://twitter.com/class)='modal-body']"));
  Assert.assertEquals(modalContentBody.getText(),
    "This is the place where the content for the modal dialog displays", "Verify modal body message");

// code to click on accept modal button
  System.out.println("Clicking modal accept button");
  WebElement modalAcceptButton = modalContainer
    .findElement(By.xpath(".//button[contains(text(),'Save Changes')]"));
  modalAcceptButton.click();
 }
}

Code Walkthrough

Step 1. First lines of code in the testcase are to navigate to the URL on which we will have our modal dialog box to automate.

driver.get("[https://www.lambdatest.com/selenium-playground/bootstrap-modal-demo](https://www.lambdatest.com/selenium-playground/bootstrap-modal-demo)");

Step 2. After the page has loaded, we click on the button to launch the dialog box. As we learnt, this is the trigger element which makes the dialog box appear.

For this we use the XPath element locator to fetch the element using its tag and attribute key-value.

driver.findElement(By.xpath("//button[[@data](http://twitter.com/data)-target='#myModal']")).click();

Step 3. After clicking the button, we wait for the modal box to be visible. For this, we have used explicit waits, as per which the WebDriver waits for a certain condition to occur before proceeding to execute the further code. To know more about explicit waits, you can go through this article on types of Waits in Selenium.

To use these waits in your test automation script, the following imports are done:

import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

Step 4. After this, an object of WebDriverWait class is instantiated using the WebDriver reference and maximum time to wait for before raising an exception. The time is in seconds.

WebDriverWait wait = new WebDriverWait(driver, 30);

Using this wait object, we implement some “ExpectedConditions” function to be fulfilled. There are certain predefined conditions for it in Selenium, of which we have used visibilityOfElementLocated(), which means to wait until the given WebElement is visible.

wait.until(ExpectedConditions.visibilityOfElementLocated(By.className("modal-dialog")));

Step 5. Once the modal dialog box opens up, we fetch the WebElement of the modal container as we will be interacting with the elements inside the modal dialog box container.

WebElement modalContainer = driver.findElement(By.className("modal-dialog"));

Step 6. Next, we fetch the modal dialog box WebElements to perform actions on their content. One important thing to note here is the way how the WebElement for the model content is fetched.

For this, in place of the driver, the WebElement identifier for the modal container is used, and the identifying XPath for the element starts with “.//,” which signifies that the corresponding element to be found is inside this element, i.e., inside the modal dialog box.

The following code showcases this implementation of how elements would be identified and how we can assert on it or click the button. To learn more about assertions you can go through our earlier blog on How To Use Assertions In TestNG With Selenium.

WebElement modalContentBody = modalContainer.findElement(By.xpath(".//div[[@class](http://twitter.com/class)='modal-body']"));
Assert.assertEquals(modalContentBody.getText(), "This is the place where the content for the modal dialog displays", "Verify modal body message");

// code to click on accept modal button
WebElement modalAcceptButton = modalContainer .findElement (By.xpath (".//button[contains(text(),'Save Changes')]"));
modalAcceptButton.click();

Test Execution

Having understood the code implementation, lets execute the code using TestNG. Once successfully executed, you can see the following output on the IDE.

Since we executed the code on a remote grid using LambdaTest, execution logs are also available on the LambdaTest Dashboard, including video, steps of the automation script, and network and console logs.

You can see your executed test cases under Recent Tests on the Dashboard.

To see the detailed execution for your case, click on the test case, and you can see the details like the following:

You can also navigate to the LambdaTest Analytics Dashboard to see test performance metrics. From the Test Summary section, you will see the total number of tests passed or failed, including completed and pending tests. You can also see the snapshot of consistent tests from the Test Overview section.

How to handle Alerts using Selenium Java?

In this section of the blog on how to handle modal box in Selenium WebDriver Java, we will learn what are alerts and how to handle alerts in Windows using Selenium Java

What are Alerts?

Alerts in web development usually refer to a message or notification that lets the user know about information, namely:

Asking for access permissions.
Highlighting mandatory fields on a form.
Display warning messages or help information.

Unlike modal dialog boxes, Selenium offers some special functions to deal with alerts. This is because it is a very tricky and time-consuming task for testers to automate alerts using regular methods. A few of these predefined methods are

Click Accept Button of the alert Dismiss/Cancel an Alert Box

driver.switchTo().alert().dismiss();
Click Accept on Alert Box

driver.switchTo().alert().accept();
Fetch static data from Alert Box

driver.switchTo().alert().getText();
Send data to input fields on Alert Box

driver.switchTo().alert().sendKeys("Text");

sendKeys() function is used to enter data to the input fields on any web page in Selenium automation. SendKeys in Selenium performs the same action here by entering data to any input field on the alert.

Demonstration: Handling Alerts Window using Selenium Java

For this blog on how to handle modal dialog box in Selenium Java, we will be automating the following flow:

Navigate to https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo.
Click on Click Me button under Java Script Alert Box.
Verify the alert body content as Please Enter Your Name.
Enter some data in the alert input box.
Click OK to accept the alert.

package test;

import org.openqa.selenium.By;
import org.testng.Assert;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

public class TestAlerts extends BaseClass {

[@Test](http://twitter.com/Test)(description = "test to verify alerts")
 public void verifyAlerts() throws InterruptedException {
  // to navigate to the website
  System.out.println("Navigating to the website");
  driver.get("[https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo](https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo)");

// to click the button to get demo alert
  System.out.println("Clicking launch alert button");
  driver.findElement(By.xpath("(//button[contains(text(),'Click Me')])[3]")).click();

// to let the alert be visible
  WebDriverWait wait = new WebDriverWait(driver, 30);
            wait.until(ExpectedConditions.alertIsPresent());

// to fetch the alert body content and verify it
  System.out.println("Fetching the alert body content and asserting it");
  String alertBodyText = driver.switchTo().alert().getText();
  Assert.assertEquals(alertBodyText, "Please enter your name", "Verify alert body content");

// to enter data as required by the alert
  System.out.println("Entering date in the alert input box");
  driver.switchTo().alert().sendKeys("LambdaTest");

// to accept the alert
  System.out.println("Accepting the alert");
  driver.switchTo().alert().accept();
 }
}

Code Walkthrough

Step 1. This code also starts with the first step as navigating to the target page where the actual automation script would be executed.

driver.get("[https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo](https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo)");

Step 2. Once the page is loaded, we click the button to get the alert on which alert functions can be implemented and verified.

driver.findElement(By.xpath("(//button[contains(text(),'Click Me')])[3]")).click();

Step 3. Just like for the modal dialog box, for alert as well, explicit wait is being implemented. Imports and object creation remain same for this case as well with only difference being on ExpectedConditions. For supporting alerts, just like there are predefined functions in Selenium, alertIsPresent() is used in this case.

wait.until(ExpectedConditions.alertIsPresent());

Step 4. After the alert is visible, we start with implementing alert().getText() to fetch the content on the alert and asserting it.

But before we can do so, we need to make sure that the driver instance focus has been switched to the alert from the main window. For this purpose, the switchTo() function is used in Selenium automation testing. This function is used whenever we are working with multiple windows like new tab, alerts, pop ups, etc. in web automation.

Since in this test script, we need to switch to alert in this test script to interact with it, switchTo().alert() is used. We will learn more about how to switch between parent/child windows in the popups section.

String alertBodyText = driver.switchTo().alert().getText();

Step 5. Here we are using the Assert class of TestNG to compare the content using the assertEquals() function. In this function, we will pass the expected content, which is the string and the actual content, which is the body content of the alert that is fetched on the previous step. If both matches, assert is passed; else, it fails with an error that is expected and actual data do not equal.

Assert.assertEquals(alertBodyText, "Please enter your name","Verify alert body content");

Step 6. Next, we verify the alert().sendKeys() function by entering some data in the input field.

driver.switchTo().alert().sendKeys("LambdaTest");

Step 7. The last step of this test scenario is to accept the alert for which the predefined method that Selenium provides is being used.

driver.switchTo().alert().accept();

Depending upon the use case, you can also implement the function to dismiss/cancel the alert. For this following method Selenium method can be used

driver.switchTo().alert().dismiss();

Test Execution

As mentioned for the modal dialog box in the previous section, we can similarly execute the alerts test case from IDE and see the output like below on successful execution on the IDE and the LambdaTest dashboard for the automation cases.

How to handle Popups using Selenium Java?

In this section of the blog on how to handle modal box in Selenium WebDriver Java, we will learn what are popups and how to handle popups using Selenium Java.

What are Popups?

Pop-up refers to a new window or tab that pops up or gets opened as a result of some interaction on the webpage. It can come up in a number of conditions and as per implementation.

In Selenium automation, the driver always focuses on the currently active window and interacts with it. So whenever we are working with pop-ups in Selenium, some additional methods are used to shift the driver’s focus to the newly opened window and then back to the main window.

Get handles of all the windows that are open at that instance.

driver.getWindowHandles();
Get the current window handle on which the driver is focused.

driver.getWindowHandle();
Switch to the main parent window.

driver.switchTo().defaultContent();
Switch to any specific window using its handle.

driver.switchTo().window(handleId);

handleId here refers to the ids of the window which we can fetch using the getWindowHandle() or getWindowHandles() function of the WebDriver.

Check out this blog for most wanted testing tools for automation that have climbed the top of the ladder so far.

Demonstration: Handling Popups using Selenium Java

For this blog purpose, we will be automating the following flow:

Navigate to https://www.lambdatest.com/selenium-playground/window-popup-modal-demo.
Click on Follow On Twitter under Single Window Popup.
Switch to a new popup window.
Assert Follow button on it is present.
Switch back to the main window.
Assert Follow On Twitter is displayed.

package test;

import java.util.Iterator;
import java.util.Set;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.testng.Assert;
import org.testng.annotations.Test;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

public class TestPopups extends BaseClass {

[@Test](http://twitter.com/Test)(description = "test to verify pop ups")
 public void verifyPopups() throws InterruptedException {
  // to navigate to the website
  System.out.println("Navigating to the website");
  driver.get("[https://www.lambdatest.com/selenium-playground/window-popup-modal-demo](https://www.lambdatest.com/selenium-playground/window-popup-modal-demo)");
  driver.manage().window().maximize();

// to fetch and save the handle of current window
  System.out.println("storing the main window handle");
  String mainWindowHandle = driver.getWindowHandle();

// to click the button to get a popup (new tab in this case)
  System.out.println("Clicking launch popup button");
  WebElement followButtonOnMainWindow = driver.findElement(By.xpath("//a[contains([@title](http://twitter.com/title),'Twitter')]"));
  followButtonOnMainWindow.click();

// to get the list of all window handles after the new tab
  // should have length 2 since 1 new tab opens up
  System.out.println("Fetching the list of all window handles and asserting them");
  Set<String> windowHandles = driver.getWindowHandles();
  Assert.assertEquals(windowHandles.size(), 2, "Verify the total number of handles");

// switch to new opened tab
  System.out.println("Switching to the new window handle");
  Iterator<String> itr = windowHandles.iterator();
  while (itr.hasNext()) {
   String childWindowHandle = itr.next();
   // to skip the handle of our main window and switch to new one
   if (!mainWindowHandle.equalsIgnoreCase(childWindowHandle))
    driver.switchTo().window(childWindowHandle);

}

WebDriverWait wait = new WebDriverWait(driver, 30);
            wait.until(ExpectedConditions.visibilityOfElementLocated(
                                     By.xpath("//span[(text()='Follow')]")));
  // to verify that driver focus is shifted to popup window
  System.out.println("Asserting some element on the new popup window to confirm switch");
  WebElement twitterFollowButton = driver.findElement(By.xpath("//span[(text()='Follow')]"));
  Assert.assertTrue(twitterFollowButton.isDisplayed(), "Verify twitter follow button is displayed");

// shift driver back to main window and verify
  System.out.println("Switching back to main window and asserting same");
  driver.switchTo().window(mainWindowHandle);
            wait.until(ExpectedConditions.visibilityOfElementLocated(
                                     By.xpath("//a[contains([@title](http://twitter.com/title),'Twitter')]")));
  Assert.assertTrue(followButtonOnMainWindow.isDisplayed(), "Verify focus is shifted to main window");
 }
}

Code Walkthrough

You can find two special imports in this test class, namely

import java.util.Iterator;
import java.util.Set;

These are done to support the usage of Set type Data Structure and Iterator, the function to traverse through the Set. More details about these are with the corresponding code where these are used.

Step 1. For writing the automation test case for handling pop-ups, after navigating to the required webpage, first, we get and save the handle of the main window. This is done as once there is a new popup window, we need to have some way to differentiate between the handle of the current window and the newly opened window.

String mainWindowHandle = driver.getWindowHandle();

Step 2. After storing this, the next step would be to click on the link text or button, in this case, on the current/main window, to get the new popup window.

WebElement followButtonOnMainWindow = driver.findElement(By.xpath ("//a[contains([@title](http://twitter.com/title),'Twitter')]"));
followButtonOnMainWindow.click();

Step 3. Now, as per the test scenario expectation, we should have two windows on the screen. To verify the same, use the getWindowHandles() method to get identifiers (or window handles) of the respective Windows.

This method returns the list of handles of all the Windows, which to understand are the ids of different Windows that can be used to identify them. This entire list is stored in a Set type of data structure for easy accessibility.

As the number of window handles is stored in the Set type variable, we can use the size() method to fetch the total number of handles in that and assert as per expectation which is 2 here.

Set<String> windowHandles = driver.getWindowHandles();  Assert.assertEquals(windowHandles.size(), 2, "Verify the total number of handles");

Step 4. Next step would be to switch to the new pop up window. For this, we traverse through the list of window handles and compare it with the main window handle value, which we stored in the first step.

For traversal through the Set containing all window handles, we are using Iterator. As the name suggests, it means to visit repeatedly until some point. So here, we keep on iterating the set for the next values till we reach the last value.

Iterator<String> itr = windowHandles.iterator();
while (itr.hasNext()) {
 String childWindowHandle = itr.next();
 // to skip the handle of our main window and switch to new one
 if (!mainWindowHandle.equalsIgnoreCase(childWindowHandle))
  driver.switchTo().window(childWindowHandle);

}

Step 5. Once we get a non-matching value, we switch to the new popped-up window and use the Explicit Wait like discussed before to wait for the new popped-up window using the visibilityOfElementLocated() function and raise an Assert to verify the switch is successful.

// to verify that driver focus is shifted to popup window
WebDriverWait wait = new WebDriverWait(driver, 30);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//span[(text()='Follow')]")));
WebElement twitterFollowButton = driver.findElement(By.xpath ("//span[(text()='Follow')]"));
Assert.assertTrue(twitterFollowButton.isDisplayed(), "Verify twitter follow button is displayed");

Step 6. The last step is to switch back to the main window using its already stored handle and assert some element on it to verify that the driver focus has been shifted again to the main window.

driver.switchTo().window(mainWindowHandle);
Assert.assertTrue(followButtonOnMainWindow.isDisplayed(), "Verify focus is shifted to main window");

Test Execution

In a similar way as discussed above, after execution, we will get the result on IDE as follows:

And we can see the detailed execution logs on LamdaTest Dashboard by navigating to the test details and can see the data like:

If you’re a Java developer looking to improve your skills, the following certification from LambdaTest can help:

This Selenium Java 101 certification is for beginning to intermediate level Java developers who want to refresh their knowledge of the programming language and learn more about the Selenium automation testing.

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

By now you must have got a fair understanding about popups and alerts and how you can handle modal dialog box in Selenium WebDriver Java over a cloud grid like LambdaTest. However, if you want to leverage the best features of the cloud setup with faster execution (as good as the speed of a local setup), you can try HyperExecute — a blazing fast next gen testing cloud, which is upto 70% faster than any traditional Selenium cloud setup.

Conclusion

With this blog on how to handle modal dialog box in Selenium WebDriver Java, we have learned the implementation and working for all of these in detail covering all the aspects and functions that you might encounter and would need while working with these. I hope, by now, you would be confident enough to automate any kind of modal dialog box, alerts, or popups that come up in your automation scripts. So go ahead and get started with Selenium Java automation testing to handle these with ease.

Happy Automating !!