DEV Community: sadhvisingh1

Selenium Waits Tutorial: Guide to Implicit, Explicit, and Fluent Waits

sadhvisingh1 — Mon, 12 Sep 2022 07:58:06 +0000

Selenium waits for page load play an important part in your Selenium scripts. They help to make them less flaky and more reliable. Selenium provides multiple waits to provide adequate wait or pause in your script execution based on certain conditions. Thereby ensuring you don’t end up getting failed scripts as you perform automation testing with Selenium. In this tutorial, we will be explaining the types of Selenium waits and sleep, there real-time examples and a comparison study on them. Let us start by answering a pivotal question “Why should we use Selenium waits?”

Why Do We Need Selenium Waits?

Majority of modern application’s front-end is built on JavaScript or Ajax, using frameworks such as React, Angular, or any other which takes a certain time for the web elements to load on the page, whenever that page is loaded or refreshed. Hence, in case you tend to locate an element in your script which is yet to load on the page, selenium will throw you ‘ElementNotVisibleException’ message.

Below code snippet will help you showcase the same problem as you execute automation testing with Selenium. In this code snippet, I am using an example of easemytrip.com, where post user selects the ‘From’ and ‘To’ destination with a date of journey, the web application takes a certain time to load the required flight details. In this case, without applying wait, the user tends to book the first flight from the list. Now, since the page hasn’t loaded yet, the script failed to find the ‘book now’ button. Resulting in throwing a ‘NoSuchElementException’. Code snippet and console output below:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;

public class NoWaitImplemented {

public static void main(String[] args) throws InterruptedException {

        System.setProperty("webdriver.chrome.driver", ".\\Driver\\chromedriver.exe");

        WebDriver driver=new ChromeDriver();

        driver.manage().window().maximize();


        driver.get("[https://www.easemytrip.com/](https://www.easemytrip.com/)");

        driver.findElement(By.id("FromSector_show")).sendKeys("Delhi", Keys.ENTER);
        driver.findElement(By.id("Editbox13_show")).sendKeys("Mumbai", Keys.ENTER);
        driver.findElement(By.id("ddate")).click();
        driver.findElement(By.id("snd_4_08/08/2019")).click();
        driver.findElement(By.className("src_btn")).click();
        driver.findElement(By.xpath("//button[text()='Book Now']")).click();

}

}

Console Output:

I have made use of XPath for locating web elements using the scripts for automation testing with Selenium.

Selenium wait for a page to load helps in resolving this issue. There are different types of Selenium waits like Implicit wait and Explicit wait, that ensures the elements are loaded into the page before they are discovered by the Selenium script for further actions.

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

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

Types of Selenium Waits For Page Load

When performing automation testing with Selenium, we use the following types of waits as we generate our Selenium script:

Thread.Sleep() method
Implicit Wait
Explicit Wait
Fluent Wait

Let us understand each one of these in-depth.

Thread.Sleep() For Automation Testing with Selenium

Sleep is a static method that belongs to the thread class. This method can be called using the reference of the class name i.e Thread. If you use Thread.sleep while performing automation testing with Selenium, then this method will stop the execution of the script for the specified duration of time, irrespective of whether the element is found or not on the web page. It accepts the time duration in milliseconds. The syntax for the same is:

Thread.sleep(3000);

The sleep function throws InterruptedException so it should be handled using a try-catch block as below:

try{
Thread.sleep(5000);
}
catch(InterruptedException ie){
}

Why Using Thread.Sleep() Is Not A Good Idea?

I will now be highlighting some disadvantages of using the thread.sleep().

Selenium Webdriver waits for the specified time, irrespective of the element is found or not. In case the element is found much before the specified duration, the script will still wait for the time duration to elapse, thereby increasing the execution time of the script.
If the element to be present does not appear after a static time and keep changing, then you will never know an estimated time needed for the sleep function. In case it takes more time than the defined time, the script shall throw an error. Which is why, if you are dealing with dynamic elements using Selenium waits then it is wise to not use Thread.sleep().
Thread.sleep is intended only for the element it is written prior to. In case you have two to fours elements which need to wait for a certain duration to load, you need to specify Thread.sleep as many times in that case. And if you do that! Well, you will find your script filled with Thread.sleep() syntax all over the place.

Owing to the above disadvantages, using Thread.Sleep() in your script creation is considered as a bad practice.

The below code snippet highlights the usage of Thread.Sleep() for automation testing with Selenium. In this example, we are using the same example of easemytrip above, where we will stop the thread execution, once the user clicks on search. The code works smoothly in this case, without throwing any error.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;

public class ThreadWait {

public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

        //setting the driver executable
        System.setProperty("webdriver.chrome.driver", ".\\Driver\\chromedriver.exe");

        //Initiating your chromedriver
        WebDriver driver=new ChromeDriver();

        driver.manage().window().maximize();


        driver.get("[https://www.easemytrip.com/](https://www.easemytrip.com/)");

        driver.findElement(By.id("FromSector_show")).sendKeys("Delhi", Keys.ENTER);
        driver.findElement(By.id("Editbox13_show")).sendKeys("Mumbai", Keys.ENTER);
        driver.findElement(By.id("ddate")).click();
        driver.findElement(By.id("snd_4_08/08/2019")).click();
        driver.findElement(By.className("src_btn")).click();
        Thread.sleep(5000);
        driver.findElement(By.xpath("//button[text()='Book Now']")).click();

}

}

Now, what if I have another page of the same application that takes a certain time to load? In this case, I would not prefer to use, thread.sleep() multiple times in my script.

You may be thinking that if not Thread.sleep(), then which Selenium wait for page load will suffice the testing requirement?

This is where Implicit wait comes to rescue in such cases. Let us checkout Implicit Selenium wait in detail.

Implicit Wait For Automation Testing with Selenium

Selenium has overcome the problems provided by Thread.sleep() and have come up with two Selenium waits for page load. One of which is Implicit wait which allows you to halt the WebDriver for a particular period of time until the WebDriver locates a desired element on the web page.

The key point to note here is, unlike Thread.sleep(), it does not wait for the complete duration of time. In case it finds the element before the duration specified, it moves on to the next line of code execution, thereby reducing the time of script execution. This is why Implicit wait is also referred to as dynamic wait. If it does not find the element in the specified duration, it throws ElementNotVisibleException.

Another interesting thing to note about Implicit wait is that it is applied globally, which makes it a better option than Thread.sleep(). Meaning you only need to write it one time and it gets applicable for all of the web elements specified on a script throughout the WebDriver instance. Convenient isn’t it? The syntax to achieve the same is:

driver.manage().timeouts().implicitlyWait(Time Interval to wait for, TimeUnit.SECONDS);

The default time for Implicit wait is zero and it keeps polling for the required element after every 500 milliseconds. Let’s see the code snippet below, showcasing the use of Implicit wait. In this example, I am using the same easemytrip example. In this case, we are going a step ahead and continuing the booking process, where the page takes more time to load. Here the page load issue exists for two pages, which we are dealing using a single line of code using implicit wait rather than using Thread.sleep() multiple times.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;

import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;

public class ImplicitWait {

public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

        //setting the driver executable
        System.setProperty("webdriver.chrome.driver", ".\\Driver\\chromedriver.exe");

        //Initiating your chromedriver
        WebDriver driver=new ChromeDriver();

        driver.manage().window().maximize();

        driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
        driver.get("[https://www.easemytrip.com/](https://www.easemytrip.com/)");

        driver.findElement(By.id("FromSector_show")).sendKeys("Delhi", Keys.ENTER);
        driver.findElement(By.id("Editbox13_show")).sendKeys("Mumbai", Keys.ENTER);
        driver.findElement(By.id("ddate")).click();
        driver.findElement(By.id("snd_4_08/08/2019")).click();
        driver.findElement(By.className("src_btn")).click();

driver.findElement(By.xpath("//button[text()='Book Now']")).click();

        JavascriptExecutor jse = (JavascriptExecutor)driver;
        jse.executeScript("window.scrollBy(0,750)");

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

        driver.findElement(By.xpath("//span[text()='Continue Booking']")).click();

        WebElement title=driver.findElement(By.id("titleAdult0"));

        Select titleTraveller=new Select(title);

        titleTraveller.selectByVisibleText("MS");
        driver.findElement(By.xpath("//input[[@placeholder](http://twitter.com/placeholder)='Enter First Name']")).sendKeys("Sadhvi");
        driver.findElement(By.xpath("//input[[@placeholder](http://twitter.com/placeholder)='Enter Last Name']")).sendKeys("Singh");

        driver.findElement(By.xpath("//input[[@placeholder](http://twitter.com/placeholder)='Mobile Number']")).sendKeys("9958468819");

        driver.findElement(By.xpath("//div[[@class](http://twitter.com/class)='con1']/span[[@class](http://twitter.com/class)='co1']")).click();

}

}

Now, here we are aware of the fact, that pages shall we loaded in a certain duration, but what if we do not know the element to be visible/clickable at loading time. As in the time of its appearance is dynamic and keeps on changing from time to time. In this case, Explicit wait will help you overcome this problem. Let’s investigate its detail.

Explicit Wait For Automation Testing with Selenium

The Explicit wait is another one of the dynamic Selenium waits. Explicit wait help to stop the execution of the script based on a certain condition for a specified amount of time. Once the time goes overboard, you will get the ElementNotVisibleException. In a scenario where you do not know the amount of time to wait for, this explicit wait comes in handy. Using conditions like elementToBeClickable() or textToBePresentInElement(), one can wait for the specified duration. One can use these predefined methods using the combination of classes WebDriverWait and ExpectedConditions. In order to use this case, import the below packages in your class:

import org.openqa.selenium.support.ui.ExpectedConditions
import org.openqa.selenium.support.ui.WebDriverWait

Post this one needs to create a reference variable for the WebDriverWait class and instantiate it using the WebDriver instance and providing the amount of Selenium wait for page load, one may need. The unit of time is in seconds. One can define it as below:

WebDriverWait wait = new WebDriverWait(driver,30);

In order to use the predefined methods of the ExpectedCondition Class, we will use the wait reference variable as below:

wait.until(ExpectedConditions.visibilityOfElementLocated(Reference of Element to be  located using locator));

Types of Expected Conditions:

Below are the few types of expected conditions commonly used as you perform automation testing with Selenium.

visibilityOfElementLocated()- Verifies if the given element is present or not
alertIsPresent()- Verifies if the alert is present or not.
elementToBeClickable()- Verifies if the given element is present/clickable on the screen
textToBePresentInElement()- Verifies the given element have the required text or not
titlels()- Verify the condition wait for a page that has a given title

There are many more expected conditions available, which you can refer through the Selenium official GitHub page. Like Implicit wait, the explicit wait also keeps polling after every 500 milliseconds.

Below is the code snippet highlighting the usage of an Explicit Selenium wait. In this example, we are using the ‘rentomojo’ application, where a modal appears at a dynamic time on the homepage. Using explicit wait, based on the element visibility, we will wait for the element and close the pop-up. Referenced code:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

public class ExplicitWait {

public static void main(String[] args) {
        // TODO Auto-generated method stub

        //setting the driver executable
                System.setProperty("webdriver.chrome.driver", ".\\Driver\\chromedriver.exe");

                //Initiating your chromedriver
                WebDriver driver=new ChromeDriver();



                driver.manage().window().maximize();

                driver.get("[https://www.rentomojo.com/](https://www.rentomojo.com/)");

                driver.findElement(By.xpath("//span[[@class](http://twitter.com/class)='rm-city__selectorBoxLoca'][contains(text(),'Delhi')]")).click();



                WebDriverWait wait=new WebDriverWait(driver, 120);


                wait.until(ExpectedConditions.visibilityOf(driver.findElement(By.xpath("//div[[@class](http://twitter.com/class)='Campaign__innerWrapper']/button"))));
                driver.findElement(By.xpath("//div[[@class](http://twitter.com/class)='Campaign__innerWrapper']/button")).click();

}

}

Note- When implicit wait and explicit wait are given in conjunction, then they work on cumulative time, rather than on a single wait condition. For example, if the Implicit wait is given for 30 seconds and the Explicit wait is given for 10 seconds, then the explicit element it is looking for will wait for 40 seconds.

The Difference Between Selenium Waits: Explicit Vs Implicit

Now, since you are aware of the usage of implicit and explicit waits, let us investigate the difference between these 2 Selenium waits:

IMPLICIT WAIT	EXPLICIT WAIT
It is by default applied to all the elements in the script.	It is applicable to only a certain element which is specific to a certain condition.
We cannot wait based on a specified condition like element selectable/clickable unlike explicit.	In explicit, we can specify the wait based on a specific condition.
It is usually used when you are sure the element may be visible in a certain time	It is usually used, when you are not aware of the time of the element visibility. It is subjected to dynamic nature.

Fluent Wait For Automation Testing with Selenium

The Fluent wait is similar to explicit wait in terms of its functioning. In Fluent wait, you perform a Selenium wait for an element when you are not aware of the time it may take to be visible or clickable. The few differential factors that Fluent wait offers are:

The polling frequency- In case of Explicit wait, this polling frequency is by default 500 milliseconds. Using Fluent wait, you can change this polling frequency based on your needs, i.e you can tell your script to keep checking on an element after every ‘x’ seconds.
Ignore Exception- During polling, in case you do not find an element, you can ignore any exception like ‘NoSuchElement’ exception etc.

Apart from these differential factors, like Explicit wait or Implicit wait, you can define the amount of time to wait for the element to be visible or actionable. The below syntax or lines of code are used to define Fluent wait in Selenium:

Wait<WebDriver> fluentWait = new FluentWait<WebDriver>(driver)
       .withTimeout(60, SECONDS) // this defines the total amount of time to wait for
       .pollingEvery(2, SECONDS) // this defines the polling frequency
       .ignoring(NoSuchElementException.class); // this defines the exception to ignore 
      WebElement foo = fluentWait.until(new Function<WebDriver, WebElement>() {
     public WebElement apply(WebDriver driver)  //in this method defined your own subjected conditions for which we need to wait for
     {  return driver.findElement(By.id("foo"));
}});

The syntax appears to be complex, but once you start using, it may become handy. Probably this is one of its biggest reason where testers opt to go for explicit wait more than Fluent wait. Also, the major difference between the Explicit wait and the Fluent wait is, that the Explicit Selenium Wait provides predefined conditions, which are applied on elements we need to wait for, whereas, in case of Fluent Selenium wait, you can define your own customized conditions within the apply method.

Test your mobile websites and smartphone apps using our scalable on cloud mobile emulator online

My opinion on Fluent Selenium Wait?

I personally haven’t found any useful implementation of fluent wait in a real-time example, hence would like to refrain myself from the implementation of it, as of now. I am as eager as you, for the launch of Selenium 4. I am hoping that after the launch we may get more insights on the practical advantage of using Fluent wait over the other Selenium waits. So far based on my experience, I happen to lean towards the use of Explicit Selenium wait, owing to its easier implementation of code than Fluent Selenium wait. If you feel otherwise then let me know in the comments below.

Click here to know How To Use IOS Emulators for PC

Role Of Selenium Waits for running automation Cloud Selenium Grid

Majority of testers usually prefer to perform automated website testing using a cloud-based service provider for Selenium testing such as LambdaTest, a cross browser testing tool on cloud. Wondering why?

So what happens if you are running your automation scripts on a cloud-based Selenium Grid such as LambdaTest? How can Selenium waits contribute to an effective test result?

Every cloud-based provider will offer a default time limit before throwing Selenium timeout exception. This is done to prevent over-exploitation of the cloud’s resources. At LamdaTest, you get a default timeout of 90 seconds. Now, if your loading time for web elements is more than 90 seconds then what can you do?

This is where Selenium wait comes into the picture. If your test suite is a complex one, which may face a timeout issue on cloud Selenium Grid then you can use Selenium wait to pause the WebDriver for more than 90 seconds default time limit. Thereby, avoiding a timeout error as you successfully run your automation script.

Click here, Say No To Safari VM! Perform Cross Browser Compatibility Testing On All Safari for windows across Real Browsers And Operating Systems.

The Final Verdict On Selenium Waits!

Selenium Waits helps to make your scripts less flaky and more reliable. Whichever wait you choose to go with, make sure it does the business to help you achieve your purpose behind automation testing with Selenium. Another key thing to note is to ensure not keeping unnecessary Selenium waits in your application. Thread.sleep() may have been an option in the past, but now that we have new Selenium waits up & coming, I would rather recommend you to drive your Selenium automation testing away from Thread.sleep(). So, the next time, you are stuck with the elements or page loading issue, you know where to look for. Happy testing!

Handling Multiple Browser Tabs With Selenium Automation Testing

sadhvisingh1 — Mon, 05 Sep 2022 10:48:33 +0000

Automation testing with Selenium has been a lifeline in grooming budding automation testers into professionals. Selenium being open-source is largely adopted on a global scale. As a result of which you get huge support from the community. There are multiple frameworks for different languages that offer bindings with Selenium. So you have got everything on board for getting started with Selenium. Now, comes the phases where you run your first test script to perform Selenium. The scripts would involve basic test scenarios if you are learning Selenium automation. You may validate:

A simple login form with Selenium automation testing.
Capture screenshots of a web page with Selenium WebDriver.
Web elements using CSS locators in Selenium WebDriver.
Set up a Selenium Grid for parallel execution of test cases.
Generating Selenium test reports.

There could be many more things, one may look to validate as one aims to perform automation testing with Selenium. Today, I am going to help you perform one of the basic and fundamental validations for test automation with Selenium. I will demonstrate how you can handle multiple browser tabs using Selenium automation testing.

If you’re new to Selenium and wondering what it is then we recommend checking out our guide — What is Selenium?

Getting Started With A Practical Scenario

Sometimes you may come across a complex scenario where you may have to open a new tab or window and perform desired actions on the opened tab/window. Handling multiple tabs or windows may seem complex at the start but once you know how to handle them, it becomes really easy. Let’s take into account a scenario.

Assuming, you open the homepage of Airbnb and wish to open the details of a homestay in another tab, perform some actions on the opened tab and then switch back to the previous tab. Then how do you do so?

You may find multiple solutions on the web regarding this. Few people use sendkeys method ‘Control + t’ to open a tab, post locating the body of the homepage. This approach most of the time does not work owing to sendKeys issue with the browser behavior. Hence, the best approach to open tab is using a Robot class or using JavascriptExecutor. Robot class ensure your tab is opened using the ‘Control + t’ command, while through javascript executor you can simply open the tab using windows.open. Post opening the tab you can switch to the tab using either Action Class approach or using Selenium WebDriver interface methods getWindowHandle & getWindowHandles. I will be showcasing both the approaches in this article.

The below test steps need to be addressed in order to open a tab in Airbnb.

Open Airbnb URL.
Search for ‘Goa’ location.
Store URL of any stay.
Open a new tab
Switch to the new tab and launch the desired stored URL.

In order to open a new tab, the following Robot class code can be used:

Robot r = new Robot();        
        r.keyPress(KeyEvent.VK_CONTROL);
        r.keyPress(KeyEvent.VK_T);
        r.keyRelease(KeyEvent.VK_CONTROL);
        r.keyRelease(KeyEvent.VK_T);

The above code helps to open a tab using ‘control + t’ command of the keyboard. This can be performed using sendKeys but its credibility towards working or not seems sporadic owing to the behavior of the browser with which it is used. You can use sendKeys command as below to replicate the above behavior.

driver.findElement(By.cssSelector(“body”)).sendKeys(Keys.CONTROL+ “t”);

Handling Tabs In Selenium Using The Window Handler Method

Now, all we need to do is switch to this opened tab using Window Handler methods. Code snippet below for your reference:

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.interactions.Actions;

public class HandlingMultipleTabs {

public static void main(String[] args) throws InterruptedException, AWTException {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);

        //Navigating to airbnb
        driver.get("[https://www.airbnb.co.in/](https://www.airbnb.co.in/)");

        driver.manage().window().maximize();

        String currentHandle= driver.getWindowHandle();

        //locating the location, looking for homestays
        driver.findElement(By.id("Koan-magic-carpet-koan-search-bar__input")).sendKeys("Goa", Keys.ENTER);

        //Clicking on search button
        driver.findElement(By.xpath("//button[[@type](http://twitter.com/type)='submit']")).click();
        String urlToClick=driver.findElement(By.xpath("//div[text()='Luxury Three Bedroom Apartment with Pool & Jacuzzi']/ancestor::a")).getAttribute("href");

        //opening the new tab
        Robot r = new Robot();        
        r.keyPress(KeyEvent.VK_CONTROL);
        r.keyPress(KeyEvent.VK_T);
        r.keyRelease(KeyEvent.VK_CONTROL);
        r.keyRelease(KeyEvent.VK_T);

        //getting all the handles currently available
        Set<String> handles=driver.getWindowHandles();
        for(String actual: handles)
        {

         if(!actual.equalsIgnoreCase(currentHandle))
         {
             //switching to the opened tab
             driver.switchTo().window(actual);

             //opening the URL saved.
             driver.get(urlToClick);
         }
        }



    }
}

Use the below command if you wish to switch back to the original tab.

driver.switchTo().defaultContent();

Now, let’s try to open the tab using JavascriptExecutor and switch to that tab for the same scenario above. Below is the referenced code snippet:

import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class multipltabsonce123 {

public static void main(String[] args) {
        // TODO Auto-generated method stub

System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);

        //Navigating to airbnb
        driver.get("[https://www.airbnb.co.in/](https://www.airbnb.co.in/)");

        driver.manage().window().maximize();

        String currentHandle= driver.getWindowHandle();

        //locating the location, looking for homestays
        driver.findElement(By.id("Koan-magic-carpet-koan-search-bar__input")).sendKeys("Goa", Keys.ENTER);

        //Clicking on search button
        driver.findElement(By.xpath("//button[[@type](http://twitter.com/type)='submit']")).click();
        String urlToClick=driver.findElement(By.xpath("//div[text()='Luxury Three Bedroom Apartment with Pool & Jacuzzi']/ancestor::a")).getAttribute("href");

        //opening the new tab
        ((JavascriptExecutor)driver).executeScript("window.open()");

        //getting all the handles currently avaialbe
        Set<String> handles=driver.getWindowHandles();
        for(String actual: handles)
        {

         if(!actual.equalsIgnoreCase(currentHandle))
         {
             //switching to the opened tab
             driver.switchTo().window(actual);

             //opening the URL saved.
             driver.get(urlToClick);
         }
        }

    }

}

Kudos! You have successfully performed automation testing with Selenium for switching different browser tabs with the help of Windows Handler method. Now, let us go about it in a different manner.

You can also refer to the below video tutorial on how to handle Windows and Frames in selenium.

Test your mobile websites and smartphone apps using our scalable on cloud mobile emulator online here

Handling Tabs In Selenium Using The Action Class

As mentioned above, we can switch to tabs using both Window Handler and Action Class. The below code snippet showcases how to switch to tabs using Action class. Since action class also use inference of sendkeys, it may or may not work subjected to the browser under use.

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.interactions.Actions;

public class HandlingMultipleTabs {

public static void main(String[] args) throws InterruptedException, AWTException {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);

        //Navigating to airbnb
        driver.get("[https://www.airbnb.co.in/](https://www.airbnb.co.in/)");

        driver.manage().window().maximize();

        String currentHandle= driver.getWindowHandle();

        //locating the location, looking for homestays
        driver.findElement(By.id("Koan-magic-carpet-koan-search-bar__input")).sendKeys("Goa", Keys.ENTER);

        //Clicking on search button
        driver.findElement(By.xpath("//button[[@type](http://twitter.com/type)='submit']")).click();
        String urlToClick=driver.findElement(By.xpath("//div[text()='Luxury Three Bedroom Apartment with Pool & Jacuzzi']/ancestor::a")).getAttribute("href");

        //opening the new tab
        Robot r = new Robot();        
        r.keyPress(KeyEvent.VK_CONTROL);
        r.keyPress(KeyEvent.VK_T);
        r.keyRelease(KeyEvent.VK_CONTROL);
        r.keyRelease(KeyEvent.VK_T);



       //switch using actions class
        Actions action= new Actions(driver);
        action.keyDown(Keys.CONTROL).sendKeys(Keys.TAB).build().perform();

        //opening the URL saved.
        driver.get(urlToClick);


    }

}

And that is it! You have handled multiple browser tabs with Selenium automation testing using both Windows Handler method & using the Action Class as well. Now, I will be talking about one of the most common drawbacks of using Selenium. So we know that Selenium WebDriver is a great open-source tool for automating web applications. However, the primary pain point with WebDriver is the sequential execution of test scripts.

As a resolution, ThoughtWorks(Founder of Selenium) came up with Selenium Grid to help users run multiple test cases, simultaneously, in parallel. This drastically brought down the test builds execution.

So we have a way to run multiple test cases in parallel as we perform automation testing with Selenium. But how scalable is it?

Setting up a Selenium Grid of your own would demand a lot of CPU consumption & maintaining it comes as a hassle. The number of tests you wish to perform parallel execution with Selenium, the higher is the demand for computation. So what can you do? How can you perform automation testing with Selenium, at scale?

Are you looking for web testing platforms? You can test your website on 3000+ different OS and browsers here. Get instant access to choice of web browsers, browser versions, OS, and resolutions.

Executing Automation Testing With Selenium On Cloud

A cloud-based Selenium Grid will allow you to run your test cases without the hassle of infrastructure set up. All you would require is an internet connection. We have multiple platforms that help us provide a rich bed of browsers, versions, mobile devices, android versions etc.

Selenium

Let us execute the above-demonstrated test cases on LambdaTest Selenium Grid. I will be showcasing how we can open multiple tabs, on a cloud-based platform and access the required details like video, screenshots, console logs, etc. for LambdaTest.

All you need to do is set up the LambdaTest URL while instantiating the remoteWebDriver. This URL is a combination of username, access key and LambdaTest hub URL. Now, all you need to do is define the platform, browser, version and the add-ons you require. Once this setup process is complete, use the same multiple tab script and run it on the LambdaTest platform. The referenced code snippet below:

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.net.URL;
import java.util.Arrays;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class HandlingMultipleTabs {



public RemoteWebDriver driver=null;
    public String url="[https://www.lambdatest.com/](https://www.lambdatest.com/)";
    public static final String  username= "sadhvisingh24"; // Your LambdaTest Username
    public static final String auth_key = "abcdefghi123456789"; // Your LambdaTest Access Key
    public static final String URL= "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub"; //This is the hub URL for LambdaTest


    [@BeforeClass](http://twitter.com/BeforeClass)
    public void setUp()
    {
        DesiredCapabilities capabilities= new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "73.0");
        capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "MultipleTabs_Lambdatest");
        capabilities.setCapability("name", "MultipleTabs_Lambdatest");
        capabilities.setCapability("network", true); // To enable network logs
        capabilities.setCapability("visual", true); // To enable step by step screenshot
        capabilities.setCapability("video", true); // To enable video recording
        capabilities.setCapability("console", true); // To capture console logs
        try {

         driver = new RemoteWebDriver(new URL("https://" + username + ":" + auth_key + URL), capabilities);

                } 

       catch (Exception e) {

           System.out.println("Invalid grid URL" + e.getMessage());
                }

        System.out.println("The setup process is completed");

    }


    [@Test](http://twitter.com/Test)
    public void handleMultipleTabs() throws InterruptedException, AWTException {
        // TODO Auto-generated method stub

        driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);

        //Navigating to airbnb
        driver.get("[https://www.lambdatest.com](https://www.lambdatest.com)");

        driver.manage().window().maximize();

        String currentHandle= driver.getWindowHandle();

        //locating the blog url
        String urlToClick=driver.findElement(By.xpath("//a[text()='Blog']")).getAttribute("href");


        //opening the new tab
        ((JavascriptExecutor)driver).executeScript("window.open()");

        //getting all the handles currently availabe
        Set<String> handles=driver.getWindowHandles();
        for(String actual: handles)
        {

         if(!actual.equalsIgnoreCase(currentHandle))
         {
             //switching to the opened tab
             driver.switchTo().window(actual);

             //opening the URL saved.
             driver.get(urlToClick);
         }
        }



    }

[@AfterClass](http://twitter.com/AfterClass)
    public void closeDown()
    {
        driver.quit();
    }
}

The above script will help you handle browser tabs in Selenium through an on-cloud Selenium Grid with zero-downtime. You can view the status of these test on the LambdaTest automation dashboard. You can view the video, screenshots, console output, and more as you perform automation testing with Selenium on LambdaTest. The referenced screenshot below:

Console Output of the test:

Try mobile app testing using LambdaTest’s online real device cloud and virtual testing platform of emulators and simulators here. Reduce costs by completely eliminating your in-house device lab.

Conclusion

We demonstrated automation testing with Selenium to handle multiple tabs using both Action Class & Windows Handler method. We came to realize the pain point of running Selenium WebDriver, & Grid, locally. Moving to cloud-based Selenium Grid such as LambdaTest will help you scale effortlessly, so you could reduce your build times significantly & ship products faster.

Let me know in case you have any queries regarding this topic. I will be coming up with more articles around fundamental topics of Selenium automation testing, to help you grow better as a professional automation tester. Stay tuned for more & happy testing! 🙂

Using Selenium Webdriver For Full Page Screenshots

sadhvisingh1 — Fri, 02 Sep 2022 11:52:07 +0000

One of the most performed actions of any webpage tester is taking a screenshot of the webpage. Whenever a tester finds and reports a bug, that bug would not be taken seriously without supporting screenshots or even videos of the issue. This is equally true no matter the type of testing you are doing and that includes selenium automation testing.

In automation testing, especially where a typical test run may involve hundreds of commands and test cases, automated screenshots taken at critical assertions are important for developers and testers in making sure that every test case executed as it should. These proofs are in-turn used for debugging, to find out what went wrong and the reason for failure. For Selenium, these screenshots help to distinguish whether the failures are due to application failure or due to script failure.

Now with that said, when we say screenshot we could mean capturing an image of any part of the screen including the image of an element in question or even a screenshot of the whole page. Therefore in this post, we would be looking at how you can take automated screenshots of web pages for different purposes using Selenium WebDriver automation scripts. You can refer to this WebDriver Tutorial to understand more about what WebDriver is, its features, how it works, and best practices. To start off, there are four major ways of capturing screenshot images using Selenium Webdriver. Such as :

Screenshot of Viewable area
Screenshot of entire screen i.e. capturing screenshot of full webpage
Screenshot of the desired webElement
Cloud based platform supporting screenshots of AUT

You can also refer to the below video tutorial on How To Take Screenshots In Selenium testing.

Click here to know more about Developer Tools for safari

Automated Selenium Test Scripts for Taking Screenshots of Viewable Area

This is the most used approach of taking screenshots of applications under automation and the easiest one as well. Selenium provides an out-of-the-box capability called TakeScreenShot interface that can be used for taking screenshots of the viewable area.

You can check the detail of the interface here.

This interface provides a method known as getScreenshotAs which helps to capture the screenshot and store it in the desired location.

Here’s the syntax to capture the screenshot:

File screenshotFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);

In order to store the taken screenshot into a file, the below statement is used:
FileUtils.copyFile(screenshotFile, new File("path of the file you want to save the screenshot to"));

This is it! Just two statements and you will be able to take the screenshot. Let’s incorporate this step into a code snippet. The below example showcases Airbnb stay details page example where we are taking a screenshot of the viewable screen:

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class ViewableScreenshotExample {

    WebDriver driver;

    [@BeforeTest](http://twitter.com/BeforeTest)
    public void setupUrl()
    {
        System.setProperty("webdriver.chrome.driver", ".\\Driver\\chromedriver.exe");
        driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.manage().window().maximize();
        driver.get("[https://www.airbnb.co.in/s/India/](https://www.airbnb.co.in/s/India/)");


    }

    [@Test](http://twitter.com/Test)
    public void performAction() throws InterruptedException
    {
        //Scroll down the page
        JavascriptExecutor jse = (JavascriptExecutor)driver;
        jse.executeScript("window.scrollBy(0,250)", "");


        //open the stay details page
        driver.findElement(By.xpath("//div[contains(text(), 'Sea Hut Homestay with Aircon')]")).click();
        Thread.sleep(1500);

        //Switch to the required tab
        ArrayList<String> ta = new ArrayList<String> (driver.getWindowHandles());
        int i=ta.size();
        System.out.println(i);
        driver.switchTo().window(ta.get(1));
    }

    [@AfterTest](http://twitter.com/AfterTest)
    public void takeScreenshot()
    {
        //take screenshot of the page
        File src= ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);
        try {
            FileUtils.copyFile(src, new File("path of the file"));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

The code snippet above will take the viewable screen screenshot as below:

This is all good and awesome if you have to take a screenshot of the view that your code is testing. However, if I want to take a screenshot of the entire webpage, the above mentioned code is not enough. But we have a solution.

Capturing Full Webpage Screenshot using Automated Selenium Test Scripts

A need may arise to take screenshots of the entire screen rather than just the viewport of the browsers. Some browsers take a screenshot of the viewable port only whereas others take a screenshot of the entire screen. Earlier versions of Firefox used to take screenshots of the entire screen, unlike chrome and IE. But eventually even the latest versions of Firefox now only takes viewport screenshots. So in order to capture screenshots of the entire screen using selenium web driver scripts, we can make use of AShot().

AShot() is a webdriver screenshot utility to capture entire page screenshot and is natively supported from Selenium 3 onwards. It provides the following features:

Helps capture entire screen and web element
Beautify screenshot
Provides screenshot comparison.

For more details on the utility, you can refer here.

In order to take a screenshot of the entire screen, you need to add the jar into your project. You can download the jar from here http://central.maven.org/maven2/ru/yandex/qatools/ashot/ashot/1.5.3/ashot-1.5.3.jar

Once the jars are added into the project, all you need to do is mention the below lines of code when you intend to take the full-screen screenshot:

Screenshot screenshot=new AShot().shootingStrategy(ShootingStrategies.viewportPasting(1000)).takeScreenshot(driver);
ImageIO.write(screenshot.getImage(),"PNG",new File("path of the file"));

In the code below, the Ashot method shooting strategy is used by setting the viewport to full screen and taking screenshots. This code snippet below goes to Airbnb India Stays and Tours page and takes a screenshot of the full view.

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import javax.imageio.ImageIO;

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

import ru.yandex.qatools.ashot.AShot;
import ru.yandex.qatools.ashot.Screenshot;
import ru.yandex.qatools.ashot.shooting.ShootingStrategies;

public class EntireScreenshot {

public static void main(String[] args) {
        // TODO Auto-generated method stub

    WebDriver driver;


                System.setProperty("webdriver.chrome.driver", ".\\Driver\\chromedriver.exe");
            driver=new ChromeDriver();
            driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
            driver.manage().window().maximize();
            driver.get("[https://www.airbnb.co.in/s/India/](https://www.airbnb.co.in/s/India/)");

//take screenshot of the entire page
            Screenshot screenshot=new AShot().shootingStrategy(ShootingStrategies.viewportPasting(1000)).takeScreenshot(driver);
            try {
                ImageIO.write(screenshot.getImage(),"PNG",new File("path of the file"));
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            driver.quit();

        }

}

As you run this code, note how the code automatically scrolls down the page and takes the screenshot of the entire page. Below is the example of the taken screenshot.

Taking full pages screenshots is great, but you may encounter a use case where you are concerned with the screenshot of the desired webElement only. Your only concern will be to take a screenshot of the desired element and not the whole screen. Also, if you wish to take screenshots of the logo image or other UI specific elements to check its pixilation or UI issues, all you care about is taking the webElement image rather than the whole screen image. Let dig into how to take a screenshot of a web Element.

Say No To Safari VM! Perform Cross Browser Compatibility Testing On All Safari for windows across Real Browsers And Operating Systems here

Taking Screenshot of Desired Web Element Using Selenium WebDriver

Taking screenshot of a desired element is also pretty easy. The main concept is to crop the full screenshot to the desired location of the webElement based on its coordinates and height-width. Here’s a code snippet below highlighting how you can take screenshot of just the logo of Amazon.com website.

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import javax.imageio.ImageIO;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.Point;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.server.handler.FullscreenWindow;

public class LogoScreenShotExample {

public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub



    System.setProperty("webdriver.chrome.driver", ".\\Driver\\chromedriver.exe");
    WebDriver driver=new ChromeDriver();
    driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
    driver.manage().window().maximize();
    driver.get("[https://www.amazon.in/](https://www.amazon.in/)");

    //locating amazon logo
    WebElement logo=driver.findElement(By.id("nav-logo"));

    // Get entire page screenshot
    File screenshot = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);

    BufferedImage  fullScreen = ImageIO.read(screenshot);

    //Find location of the webelement logo on the page
    Point location= logo.getLocation();

    //Find width and height of the located element logo

    int width= logo.getSize().getWidth();
    int height=logo.getSize().getHeight();


    //Now the main point, which is cropping the full image to get only the logo screenshot
    BufferedImage logoImage= fullScreen.getSubimage(location.getX(), location.getY(),
            width, height);

    ImageIO.write(logoImage, "png", screenshot);

    //copy the file to the desired location
    FileUtils.copyFile(screenshot, new File("path of file"));

}

}

Here’s the image was taken by the above code snippet of the webElement:

This is it. Isn’t it cool guys. Just find out what your test scenario wants and take the required screenshot. Nowadays we do not need to take screenshots because of so many upcoming cloud-based platforms providing support to all those screenshots and videos to your automation scripts execution.

This brings me to my last approach of taking a screenshot which eventually means not taking one ? and the tool doing its job. Well, you heard it right. Let’s look into its details

Check out this- 16 Best Android Emulators For Windows & Mac In 2022

Taking Full Page Automated Screenshots On Cloud

Running tests locally is important however if you want to make sure that your website works on all browsers, even those you don’t have access to locally, you would need service like LambdaTest. LambdaTest is a cloud based selenium grid that you can use to run all your automated selenium test scripts online. The best part about LambdaTest grid, however, is that it takes automated screenshots of your webpage after the execution of each selenium command. In addition, LambdaTest platform takes a complete video of the test execution as well. All you need to do is run your scripts on this platform which provides you features like screenshots, videos, network logs, console logs and so on. Few points of consideration or pre-conditions to make your script running on the platform is:

LambdaTest account
LambdaTest Username, access key and URL to connect to
Setting up the required properties to gain access to the features you need.

This is it. Now let’s run our same above-mentioned code of Airbnb Stays detail page without the need of providing the screenshot method since it captures the whole video of the execution. In the below code snippet I will be using LambdaTest username, access key, and LambdaTest Selenium Grid URL to connect to the required browser and perform actions. Notice that changing the above code into LambdaTest compatible code required only to call remote webdriver instead of local chrome webdriver, and passing on a desired-capabilities object to define which browser you need to run tests on.:

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.Platform;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import java.net.URL;

public class LambdatestWithoutScreenShotMethod {

public static final String  username= "sadhvisingh24";
    public static final String auth_key = "123456789";
    public RemoteWebDriver driver;
    public static final String URL= "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";

    [@BeforeTest](http://twitter.com/BeforeTest)
    public void setupUrl()
    {

            DesiredCapabilities capability= new DesiredCapabilities();
            capability.setPlatform(Platform.WIN8);
            capability.setBrowserName("chrome");
            capability.setVersion("75.0");
            capability.setCapability("build", "cross_browser");
            capability.setCapability("name", "cross_browser");
            capability.setCapability("network", true);//to enable network logs
            capability.setCapability("visual", true);//to enable screenshots
            capability.setCapability("video", true);//to enable video
            capability.setCapability("console", true);//to enable console logs

             try {

             driver = new RemoteWebDriver(new URL("https://" + username + ":" + auth_key + URL), capability);

                 } 

           catch (Exception e) {

               System.out.println("Invalid grid URL" + e.getMessage());
                 }

                 try
                {
                  driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS);
                    driver.manage().window().maximize();

driver.get("[https://www.airbnb.co.in/s/India/](https://www.airbnb.co.in/s/India/)");

}
                catch (Exception e) {
             System.out.println(e.getMessage());
                    }
        }   


    [@Test](http://twitter.com/Test)
    public void performAction() throws InterruptedException
    {
        //Scroll down the page
        JavascriptExecutor jse = (JavascriptExecutor)driver;
        jse.executeScript("window.scrollBy(0,250)", "");


        //open the stay details page
        driver.findElement(By.xpath("//div[contains(text(), 'Sea Hut Homestay with Aircon')]")).click();
        Thread.sleep(1500);

        //Switch to the required tab
        ArrayList<String> ta = new ArrayList<String> (driver.getWindowHandles());
        int i=ta.size();
        System.out.println(i);
        driver.switchTo().window(ta.get(1));
    }

    [@AfterTest](http://twitter.com/AfterTest)
    public void closeSetup()
    {
        driver.quit();
    }

}

The referenced screenshot below:

In the screenshot above, LambdaTest provides support of video where you can view the whole execution flow of your web app.

Apart from this LambdaTest also provides a standalone full paged automated screenshot feature, that can help you to take screenshot across browsers of your designated application and even compare them. LambdaTest calls this feature as ‘Screenshot testing’. You can access these screenshots as and when required and even share them with the required stakeholders and mail them as per needs. This feature comes in handy when you got to test your application across multiple browsers and versions and perform cross browser testing. You can take screenshots and compare them for any UI issues. Isn’t it miraculous and just imagine the amount of time you just saved.

Navigate to the LambdaTest ‘Visual UI testing’ menu header and navigate to its sub-header ‘Screenshot’ as below
Once you reach this page, all you need to do is place the URL you intend to test in the URL placeholder. Select the required browser and version you wish to take a screenshot on and just click on the button ‘capture’. Bingo, that’s it.
The images to be captured will be added in the queue. Once it’s completed, you can access those images, as below:

As you saw above, we focused on all possible ways of taking screenshots in detail, so next time when you are stuck on how to take a screenshot, this article will come in handy. You can also refer to my other articles as part of this series. Happy testing.

Find Elements With Link Text & Partial Link Text In Selenium

sadhvisingh1 — Fri, 02 Sep 2022 10:22:59 +0000

CSS locators in Selenium are a fundamental concept that every tester who aims to perform automation testing with Selenium, should be aware of. Proficient use of CSS locators in Selenium can help you perform testing in a more efficient & thorough manner. I have been in the automation testing industry from 7 years now, & I often observe that testers when performing Selenium, tend to forget the purpose of each CSS locator. Freshers have a tough time understanding them & experienced tester often sticks to a couple of selectors for locating elements on a webpage as they execute automation testing with Selenium.

There have been times where I see an experienced automation tester taking a longer route for finding an element as they have a habit of sticking to their favorite locator. It is why I thought I would come up with a tutorial series for CSS Selenium locators to help budding automation testers come up with strategic implementation of these locators. And to those of us who are experienced, it would be a quick and good recap.

This article will represent the practical implementation of link text & partial link text, as we perform automation testing with Selenium. The links on any web application can help in locating an element with either exact match of the text or through a partial match. Using link text & partial link text in Selenium, we will be able to locate both of these matches. This is the last article of my tutorial series on CSS Locator in Selenium.

You can check out other articles around different CSS locator in Selenium that helps in locating elements through various ways:

If you are an advanced or medium Selenium practitioner, then you can chuck on dedicated articles mentioned above. And go for our complete guide to help you illustrate the practical demonstration of CSS locator in Selenium.

With that said, let’s find out how to leverage link text & partial link text in Selenium to locate elements on a web page.

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

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

Android emulator for ios - Test your mobile applications before going live here. All you need is a computer with internet connection.

Using Link Text In Selenium To Locate An Element

In order to access link using link text in Selenium, the below-referenced code is used:
driver.findElement(By.linkText("this is a link text"));

Note: In a scenario where, multiple links having similar text exists, it will automatically select the first one.

Let’s refer the code snippet below to understand the use case. In this case, we are taking Airbnb example, where we are clicking on any one stay of Goa through the link match.

Referenced screenshot of the div element with the link text:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;

public class LinkText {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
    WebDriver driver=new ChromeDriver();
    driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

    driver.manage().window().maximize();

    //Opening the air bnb Goa homestays page
    driver.get("[https://www.airbnb.co.in/s/Goa/all](https://www.airbnb.co.in/s/Goa/all)");

    //locating an element via link text in Selenium now, and clicking on that stay
    driver.findElement(By.linkText("Standard One Bedroom Suite with Pool &amp; Jacuzzi")).click();

driver.quit();
  }

}

We can locate the same element using partial link text in Selenium as well. Let’s check how!

Click here if you want to know How To Use IOS emulator for pc

Using Partial Link Text In Selenium To Locate An Element

Partial link text in Selenium is another way of locating an element via a link. The only difference from the link text in Selenium to partial link text is that it does not look into the exact match of the string value but work on a partial match. So, in case you are looking for a link with a bigger text length, you can get away from using only the partial link text rather than the whole link text in Selenium.

Syntax of locating element by partial link text.

driver.findElement(By.partialLinkText ("link text"));

Referencing the above scenario, below is the code snippet for partial link text of the same stay of Airbnb:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;

public class PartialLinkText {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
    WebDriver driver=new ChromeDriver();
    driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

    driver.manage().window().maximize();

    //Opening the air bnb Goa homestays page
    driver.get("[https://www.airbnb.co.in/s/Goa/all](https://www.airbnb.co.in/s/Goa/all)");

    //locating an element via link text now and clicking on that stay
    driver.findElement(By.partialLinkText("Pool &amp; Jacuzzi")).click();

driver.quit();
  }

}

Test your mobile websites and smartphone apps using our scalable on cloud mobile emulator online

How To Select The Right Link Text When You Have Multiple Match Results?

The only thing to remember and to be cautious of while using partial link text in Selenium is when partial link text ends up matching with multiple link text on the page. In this case, make sure, you are clicking on the desired one.

Let’s consider another scenario as we perform automation testing with Selenium, where you end up matching multiple link text and wish to target only the designated one. For the same homestays of Goa, I am trying to locate the element with partial text as ‘pool’ in it. So, the strategy would be to find out home many stays have a pool in them and click on the required stay, post that. The reference code snippet below represents how we can pick the right target out of multiple match results using the partial link text in Selenium.

import java.util.List;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;

public class LinkText {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
    WebDriver driver=new ChromeDriver();
    driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

    driver.manage().window().maximize();

    //Opening the air bnb Goa homestays page
    driver.get("[https://www.airbnb.co.in/s/Goa/all](https://www.airbnb.co.in/s/Goa/all)");

    //locating an element via link text now and clicking on that stay
    List&lt;WebElement&gt; poolNumber=driver.findElements(By.partialLinkText("Pool"));

    //find the number of links with the text as pool
    int numberOfStaysWithPool= poolNumber.size();

    System.out.println(numberOfStaysWithPool);

    for(int k=0; k&lt;numberOfStaysWithPool; k++)
    {
      //printing all those links
      System.out.println(poolNumber.get(k).getText());

    }

    //select the luxury three bedroom apartment link
    poolNumber.get(2).click();

driver.quit();
  }

}

In the above code snippet, I have used findElements since I am supposed to receive multiple web elements with partial text as ‘pool’. Now, using an index, I have navigated to one of the links, which I wish to click. Simple, isn’t it?

Note: Both, link text & partial link text are cases sensitive as CSS locator in Selenium.

For example, Assume that a link ‘Register’ is present on a home page and a similar link ‘REGISTER’ is present on the footer of the homepage. In this case, if you are locating with link text ‘REGISTER’, it will automatically select the link in the footer and not the other one.

Link text and partial link text locator in Selenium works only on links of a given web application. If you intend to locate elements other than links you cannot use link text or partial link text locator in Selenium. If you are dealing with links in your application, then this is perhaps the best locator to go with. Happy testing! 🙂

Selenium Java Tutorial – Class Name Locator In Selenium

sadhvisingh1 — Wed, 17 Jul 2019 12:14:45 +0000

CSS Locator in Selenium is one of the most important aspects of writing a script. If you cannot locate an element by using any CSS locator in Selenium, then being proficient at Selenium automation will be a tough task. Selenium provides multiple ways of locating an element.

You can check out other articles around different CSS locator in Selenium that helps in locating elements through various ways:

If you are an advanced or medium Selenium Java practitioner, then you can chuck on dedicated articles mentioned above. I have written a complete guide to help you illustrate the practical demonstration of CSS locator in Selenium.

In this Selenium Java tutorial, I will be referencing on Class name locator in Selenium to demonstrate how to locate an element on a webpage via class name.

Getting Started With Class Name Locator In Selenium With Example

Next, in this Selenium Java tutorial, we will consider the scenario of Airbnb, where we intend to locate the ‘Where’ field in the search form of Airbnb homepage via class name. Below is a screenshot of Airbnb page where we inspect the ‘Where’ field in the form.
image:

In-order to use Class name locator in Selenium we need to use the below syntax:
findElement(By.className("_up0kwni "))

Now, let’s look into the code for finding elements by Class name in locators:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class ClassNameLocator {

public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

        driver.manage().window().maximize();

        //Opening the air bnb home page
        driver.get("[https://www.airbnb.co.in/](https://www.airbnb.co.in/)");

        //Locating location field for the search  form via class name 
        driver.findElement(By.className("_up0kwni")).sendKeys("Goa", Keys.ENTER);

//Locating check-in field for the search  form via class name 
        driver.findElement(By.className("_14fdu48d")).click();

        //Locating the date 12th June for check-in field
        driver.findElement(By.className("_1wh4xpp1")).click();

        //closing the driver
        driver.quit();

}

}

Pretty simple, isn’t it? In the upcoming session of this Java Selenium tutorial we will learn how to handle a common exception for class name Selenium locator.

One Of The Most Common Exceptions For Class Name Locator In Selenium

Another interesting fact and a popular error you may come across while using Class name locator in Selenium would be something like:

I am sure, you may have come across this error. Lets try to incorporate this scenario in the below code snippet for the Facebook sign up page. Below is the DOM structure for facebook ‘first name’ field with class name attribute highlighted below:

Referenced code snippet, trying to access the first name field using the class name locator in Selenium:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class ClassNameLocator {

public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

        driver.manage().window().maximize();

        //Opening the air bnb home page
        driver.get("[https://www.facebook.com/](https://www.facebook.com/)");

        //Locating by firstname via class name 
        driver.findElement(By.className("inputtext _58mg _5dba _2ph-")).sendKeys("Sadhvi");


        //closing the driver
        driver.quit();

}

}

Referenced Console error below:

How to handle this error? Well, Selenium considers this as a compound class, which means more than one classes marked through spaces. So, any class name with spaces in it will be considered two or three or more classes.

In this case, this class name marked as ‘inputtext _58mg _5dba _2ph-‘ contains three spaces thereby making it three different classes. Hence, Selenium mentions the error stating it cannot find multiple classes together. In this case, you can opt to locate element by CSS selector in Selenium or by XPath in Selenium using the class name attribute. The referenced code snippet below:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class ClassNameLocator {

public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

        driver.manage().window().maximize();

        //Opening the facebook home page
        driver.get("[https://www.facebook.com/](https://www.facebook.com/)");

        //Locating by firstname via class name 
        driver.findElement(By.xpath("//input[[@class](http://twitter.com/class)='inputtext _58mg _5dba _2ph-']")).sendKeys("Sadhvi");


        //closing the driver
        driver.quit();

}

}

Test your web and mobile apps on online emulators android here. Ensure your apps are compatible across latest and legacy Android operating systems, devices, and browsers.

How To Locate An Element When We Have Multiple Elements Sharing The Same Class Name?

Now you know when to use the class name and when you cannot use class names. But did you ever imagine the scenario when you have multiple elements sharing the same class name? How do you tackle that situation? This is again something, you can simply achieve by using the findElements keyword. All you need to do is, locate all elements with that class name using the findElements keyword and iterate through the required element class name via index. Having said so, I would rather suggest looking into an alternative method of locating that element rather than this. As its tendency of breaking will be pretty high and may lead to errors.

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

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

Test your web and mobile apps on online Android Emulators here. Ensure your apps are compatible across latest and legacy Android operating systems, devices, and browsers.

Example For Class Name Locator In Selenium For Multiple Elements With A Similar Class Name

Let’s consider the below example, highlighting the scenario above. In this case, we are considering the LinkedIn sign-up page, where all fields share the same class name. In this case, we need to note two important things:

If no, the index is defined, then by default selenium selects the first element it encounters with that class name. In the code snippet below, it locates the first element which is the first name:

import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class ClassNameLocator {

public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

        driver.manage().window().maximize();

        //Opening the linkedin sign up home page
        driver.get("[https://www.linkedin.com/start/join](https://www.linkedin.com/start/join)");

        //Locating by firstname via class name 
        driver.findElement(By.className("cell-body-textinput")).sendKeys("Sadhvi");

        //closing the driver
        driver.quit();

}

}

Note: Take a look at the class name, which in this case is cell-body-textinput, since it is not marked with spaces hence it is considered as a single class.

Locating the different elements with the same class name using index. The referenced snippet below:

import java.util.List;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class ClassNameLocator {

public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", ".\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);

        driver.manage().window().maximize();

        //Opening the air bnb home page
        driver.get("[https://www.linkedin.com/start/join](https://www.linkedin.com/start/join)");

        //Locating by firstname via class name 
        List signUpForm=driver.findElements(By.className("cell-body-textinput"));

        //finding the number of elments with the same class name
        int size=signUpForm.size();

        System.out.print(size);

        //locating the first name locator
        signUpForm.get(0).sendKeys("Sadhvi");

        //locating the last name locator
        signUpForm.get(1).sendKeys("Singh");

//locating the email  locator
        signUpForm.get(2).sendKeys("[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)");

        //locating the password  locator
        signUpForm.get(3).sendKeys("password");

        //closing the driver
        //driver.quit();

}

}

Console output:

Bingo, you are good to go now. This was all about class name locator in Selenium.

Test your web and mobile apps on Android online Emulators here. Ensure your apps are compatible across latest and legacy Android operating systems, devices, and browsers.

What Did We Learn About Class Name Locator In Selenium?

Well, that was all for today’s Selenium Java tutorial for CSS locator in Selenium. I am sure by far you have developed a deep understanding on how to use the Class name locator in Selenium effectively. We came across the most common error across the implementation of Class name locator in Selenium. We also learned how to overcome complicated scenarios where multiple elements are sharing a similar class name. If you are new to Selenium. You can read this tutorial on Selenium Java Introduction. Adios, happy testing! 🙂

Selenium Java Tutorial – How To Test Login Process?

sadhvisingh1 — Mon, 08 Jul 2019 13:41:05 +0000

Automation testing at first may sound like a nightmare especially when you have been into the manual testing business for quite long. Looking at the pace with which the need for automation testing is arising, it has become inevitable for website testers to deep dive into the automation river and starts swimming. To become a pro swimmer it takes time, similar is the case with becoming a successful automation tester. It requires knowledge & deep understanding of numerous automation tools & frameworks. As a beginner in automation testing, you may be looking forward to grabbing your hands on an open-source testing framework. After doing so the question that arises is what next? How do I go about using the open-source tool, framework, or platform, & I am here to help you out in that regard. Today, we will be looking at one of the most renowned open-source automation testing frameworks known as Selenium. In this Selenium Java tutorial, I will demonstrate a Selenium login example with Java to help you automate the login process.

Automating login process using Selenium with Java or any other programming language is the very first baby step towards becoming a successful automation tester. Without further ado, let’s get started.

Some Prerequisites For Selenium Java Tutorial

Before we begin with our Selenium Java tutorial for the login process, we need to be aware of the prerequisites. To begin with, all applications regardless of the domain they may target, 95% of the time have a login functionality flow associated with them. Be it e-commerce, banking, medical, education, etc all request user to login to the application for further usage. As the name suggests “Selenium Java Tutorial”, this tutorial offers a basic level understanding to help beginners getting started with automation testing using Selenium & Java. We will be looking into a Selenium login example with Java(one of the most versatile languages used for multiple techniques and field). In order to kick-start, you need to have a basic understanding of Java. Do not get freaked out from hearing the word Java & Selenium. We will take it to step by step. So how do you start off? First, make sure you have all the prerequisites to start writing your first login script using Java & Selenium. You need to have the following:

Download and Install JDK(Java Development Kit) from here.
Install Eclipse from the official website.
Download the Selenium Java Client version from here.
Driver executable- depending upon the browser you wish to execute your script in, you can choose to download its Selenium executable from here. As you go down the page, various browsers like Chrome, Mozilla, Opera, Edge, etc drivers will be available for download to help you perform Selenium.

That is all. Open eclipse and create your project. Add your Selenium jar in your Java build path and you are good to go. On details on how to setup project and jar file refer the below link:

Basic Steps For A Selenium Test Case

Before we perform automation testing for login validation using Selenium & Java, there are some basic steps that need to be followed for whichever test case you intend to write, be it login, logout, profile, dashboard etc. If you follow them, you will never have incomplete test cases in your automation suite:

Create a Selenium WebDriver instance.
Configure your browser if required(for example maximize browser, disable browser notifications etc.).
Navigate to the required URL (Web page).
Locate the HTML element.
Perform action on the located HTML element.
Verify and validate the action (concluded step).
Take screenshots and generate report using framework for the test cases.

If you are planning to devise an automation testing strategy for your organization but are confused about where to start from? Follow my blog to start automation testing from scratch.

This certification demonstrates your knowledge of Selenium and Java, and your expertise at automating tests for any project.

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

Test your mobile websites and smartphone apps using our scalable on cloud mobile emulator online here

Let’s Automate Selenium Login With Java

The script I will be mentioning in the article below, will be referencing these steps. We will not be considering step seven, as that would require a dedicated article on itself & I plan to do so in my upcoming blogs, so stay tuned! Now, let us look into those steps in detail to help us perform automation testing using Selenium for login with Java:

1. Create A Selenium WebDriver Instance

Webdriver driver=new ChromeDriver();

In order to launch the website in the desired browser, you need to set the system properties to the path of the driver for the required browser. In this Selenium Java tutorial, we will use chromedriver for demonstrating Selenium login example with Java. The syntax for the same will be:
System.setProperty(“webdriver.chrome.driver”, “File path for the Exe”);

2. Configure Your Browser If Required

Based on the needs, we can configure the browser. For example, in this **Selenium Java tutorial** regarding Selenium login with Java, a browser by default, will be minimized mode, we can set up the browser in the maximize mode. Below is the syntax used for the same.
driver.manage().window().maximize();

Other things that you can do for configuring your browser is set up different options like disabling info bars, browser notifications, adding extensions, etc. You can also use the capabilities class to run your script on various browsers thereby helping in cross browser testing.

3. Navigate To The Required URL

Pretty simple, open the browser with the desired URL. All you have to do is write the below syntax and you have your URL open in the desired instantiated browser.
driver.get(“https://www.linkedin.com/login”);

4. Locate The HTML Element

This is the heart of writing a Selenium script. For this to function, you need to have a clear understanding of the different locators used to find the HTML element. You can refer my below articles that talks about the different locators available in selenium and how to locate the element with different examples:

For example, lets try to locate the email and password field of the login form of LinkedIn

Below is the DOM structure for the email input box:

You can locate it via ID locator in Selenium WebDriver as below:
driver.findElement(By.id(“username”));

Since this returns a webelement, you can store it in webelement variable as below
WebElement username=driver.findElement(By.id(“username”));

The same can be achieved for password and login button field which is

driver.findElement(By.id(“password”));

WebElement password=driver.findElement(By.id(“password”));

driver.findElement(By.xpath(“//button[text()=’Sign in’]”));

WebElement login= driver.findElement(By.xpath(“//button[text()=’Sign in’]”));

5. Perform Action On The Located HTML Element

Once located, you need to perform the desired action which in our case is sending text to email and password field and clicking on the login button. To execute this action in Selenium login example with Java, we make use of methods as sendKeys and click provided by Selenium as below:

username.sendKeys(“xyz@gmail.com”);

password.sendKeys(“exampleAboutSelenium123”);

login.click();

And guess what, you just finished writing the most important parts of the script. Now, in this Selenium Java Tutorial, you only need to ensure these actions have successfully logged in the user, which comes to our final step of script creation for using Selenium to login with Java.

6. Verify & Validate The Action

In order to validate the results, all you need to do is use assertion. Assertions are vital for comparing the expected results vs the actual results. Almost similar to your test cases, wherein each test case has an actual and expected behavior to it. If it matches, the test case pass, if not, then the test case fails. Assertions do exactly the same. Assertion class is provided by both JUnit and TestNG framework, you can opt to choose any. The below syntax will help to assert (validate) the outcome from actions by performing Selenium login with Java.

Assert.assertEquals(String actual, String expected);

So, in this case, we will save our actual url post login into a string value which is:
String actualUrl=” https://www.linkedin.com/feed/”;

And expected URL can be found from the below method:

String expectedUrl= driver.getCurrentUrl();

So your final assertion would become as:

Assert.assertEquals(actualUrl, expectedUrl);

Note: In order to use assertion, you need to use the annotations of TestNG or JUnit ‘@test’ for assertions to function. In case, right now you don’t want to get into the hassle of going into the framework keywords, you can simply match the string using an ‘if’ statement and print the results in console accordingly, something like below:

if(actualUrl.equalsIgnoreCase(expectedUrl))
{
System.out.println(“Test passed”)
}
else
{
System.out.println(“Test failed”)
}

Bingo!! You have executed automation testing using Selenium login example with Java.

If you are curious about using annotations then follow our blog on Selenium Java Tutorial On JUnit Annotations In Selenium With Examples.

Below is the collective code of all the statements explained above using assertions.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.Test;

public class LoginUsingSelenium {

[@Test](http://twitter.com/Test)
    public void login() {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path of driver");
        WebDriver driver=new ChromeDriver();
        driver.manage().window().maximize();
        driver.get("[https://www.linkedin.com/login](https://www.linkedin.com/login)");

        WebElement username=driver.findElement(By.id("username"));
        WebElement password=driver.findElement(By.id("password"));
        WebElement login=driver.findElement(By.xpath("//button[text()='Sign in']"));

        username.sendKeys("[example@gmail.com](mailto:example@gmail.com)");
        password.sendKeys("password");
        login.click();

        String actualUrl="[https://www.linkedin.com/feed/](https://www.linkedin.com/feed/)";
        String expectedUrl= driver.getCurrentUrl();

        Assert.assertEquals(expectedUrl,actualUrl);


    }

}

Console Output:

Below is the collective code of all the statements explained above using the if statement:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;

public class LoginUsingSelenium {

public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", " path of driver ");
        WebDriver driver=new ChromeDriver();
        driver.manage().window().maximize();
        driver.get("[https://www.linkedin.com/login](https://www.linkedin.com/login)");

        WebElement username=driver.findElement(By.id("username"));
        WebElement password=driver.findElement(By.id("password"));
        WebElement login=driver.findElement(By.xpath("//button[text()='Sign in']"));

        username.sendKeys("[example@gmail.com](mailto:example@gmail.com)");
        password.sendKeys("password");
        login.click();

        String actualUrl="[https://www.linkedin.com/feed/](https://www.linkedin.com/feed/)";
        String expectedUrl= driver.getCurrentUrl();

        if(actualUrl.equalsIgnoreCase(expectedUrl))
        {
            System.out.println("Test passed");
        }
        else
        {
            System.out.println("Test failed");
        }



    }

}

Console Output:

Test your mobile websites and smartphone apps using our scalable on cloud mobile emulator online here

Moving Selenium Tests On Cloud

Selenium empowers automation testers to fast track their efforts & test cycles. However, other than the benefits of Selenium WebDriver, there comes some cons too. The most prominent ones include the sequential execution of tests which can take a while for larger automated test suites. Keeping that in mind, the Selenium Grid was introduced to help people run Selenium tests in parallel. However, there is a downside to that as well & that is test coverage & CPU consumption. You can only perform browser compatibility testing on browsers that are installed on your local machine. Installing numerous browsers isn’t a feasible consideration.

This is why nowadays it’s all about running your Selenium tests on cloud through multiple browsers in parallel, to execute faster cross browser testing using tools such as LambdaTest.
LambdaTest is a cross browser testing cloud offering a Selenium Grid of 3000+ real browsers & browser versions running on various operating systems. You can integrate with numerous CI/CD tools & extract Selenium test reports without logging into LambdaTest using our RESTful API.

Check out all of the LambdaTest integrations to multiple CI/CD tools, project management tool, IM-based collaboration tool.

We can run the same login script used in previous sections on LambdaTest by defining the platform, browser, and version to run this script. This helps in running your script on multiple browsers, whichever your project/product supports.

In order to run your script for Selenium login with Java, all you have to do is setup the RemoteWebDriver URL through which you will connect to your LambdaTest platform. This URL is a combination of your username, access key, and the LamdaTest hub URL.

Post this using desired capabilities class, you can set the platform like Windows 8 or 10 or Mac, etc. Then define the browser on which you wish to run your tests on and its version. Name of the build and other attributes like video, screenshots, logs, etc can be also provided. You can make use of our Selenium Desired Capabilities Generator for fetching the values based on your desired capabilities. That is it! Now use your same login script as defined above to run your test on the cloud-based platform. Below is the referenced code snippet for it:

import java.net.URL;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class LoginUsingSelenium {

public RemoteWebDriver driver = null;
    public String url = "[https://www.lambdatest.com/](https://www.lambdatest.com/)";
    public static final String  username= "sadhvisingh24";
    public static final String auth_key = "auth key generated";
    public static final String URL = "[@hub](http://twitter.com/hub).lambdatest.com/wd/hub";
    boolean status = false;

[@Test](http://twitter.com/Test)
    public void login () {
        // TODO Auto-generated method stub
        try {

driver.manage().window().maximize();
            driver.get("[https://www.linkedin.com/login](https://www.linkedin.com/login)");

WebElement username = driver.findElement(By.id("username"));
            WebElement password = driver.findElement(By.id("password"));
            WebElement login = driver.findElement(By.xpath("//button[text()='Sign in']"));

username.sendKeys("linkedin username");
            password.sendKeys("fake password");
            login.click();

String actualUrl = "[https://www.linkedin.com/feed/](https://www.linkedin.com/feed/)";
            String expectedUrl = driver.getCurrentUrl();

if (actualUrl.equalsIgnoreCase(expectedUrl)) {
                System.out.println("Test passed");
                status = true; //Lambda status will be reflected as passed
              } else {
                System.out.println("Test failed"); //Lambda status will be reflected as passed

}
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        finally {
            tearDown();
        }

}



[@BeforeClass](http://twitter.com/BeforeClass)
    public void setUp() {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("browserName", "chrome");
        capabilities.setCapability("version", "72.0");
        capabilities.setCapability("platform", "win8"); // If this cap isn't specified, it will just get the any available one
        capabilities.setCapability("build", "TestNG_login_1");
        capabilities.setCapability("name", "TestNG_login_1");
        capabilities.setCapability("network", true); // To enable network logs
        capabilities.setCapability("visual", true); // To enable step by step screenshot
        capabilities.setCapability("video", true); // To enable video recording
        capabilities.setCapability("console", true); // To capture console logs
        try {

driver = new RemoteWebDriver(new URL("https://" + username + ":" + auth_key + URL), capabilities);

} catch (Exception e) {

System.out.println("Invalid grid URL" + e.getMessage());
        }

}
    private void tearDown () {
        if (driver != null) {
            ((JavascriptExecutor) driver).executeScript("lambda-status=" + status); //Lambda status will be reflected as either passed/ failed

driver.quit();

System.out.println("The setup process is completed");

}
    }
}

Start your Test Automation. LambdaTest provides you with the status of your test run and its corresponding video, logs, network details as well as screenshots.

Below is the screenshot of our Selenium script execution on LambdaTest Selenium Grid.

Perform Automated and Live Interactive Cross Browser Testing web on 3000+ Real Browsers and Operating Systems Online

How Was That?

Kudos! You have successfully executed automation testing for login process using Selenium & Java. How did you find this Selenium Java tutorial for login process? Let me know your thoughts in the comment section below. I look forward to your replies. Happy testing! 🙂

Complete Guide For Using XPath In Selenium With Examples

sadhvisingh1 — Fri, 28 Jun 2019 10:36:52 +0000

Identifying element has always been the trickiest part and therefore require an accurate and correct approach. If you are unable to find elements by the easily available approaches like ID, class, name, link or tagname then XPath in Selenium can help rescue you. Locating dynamic elements have always been the pain area while you wish to automate the scripts, the only ray of hope to deal with such fiascos is XPath. In my current article, I will be digging into the steps of locating an element via XPath example in Selenium and its various ways. We will be looking into the below sections:
1. What Is XPath in Selenium?
2. Types Of XPath in Selenium
2.1 Absolute
2.2 Relative
3. Writing Dynamic XPath in Selenium by different ways:
3.1 Basic XPath
3.2 Using ‘OR’ & ‘AND’
3.3 Using Contains()
3.4 Using Starts-With
3.5 Using Text()
3.6 Using Index
3.7 Using Chained XPath
3.8 XPath Axes
3.8.1 Following
3.8.1.1 Following Sibling
3.8.2 Preceding
3.8.2.1 Preceding Sibling
3.8.3 Child
3.8.4 Parent
3.8.5 Descendants
3.8.6 Ancestors

If you wish to look into other approaches of locating an element, you can view the below articles:
1. How to locate element via ID
2. How to locate element via Name
3. How to locate element by Tagname
4. How to locate element by CSS Selectors
5. Different locators in Selenium WebDriver

So, What Is XPath In Selenium?

XPath known as the XML path is a language that helps to query the XML documents. It consists of expression for a path along with certain conditions to locate a particular element.

So let’s see how to write an XPath in Selenium. Below is the DOM structure for LambdaTest Registration Page:

<form method="POST" action="https://accounts.lambdatest.com/register">
<input type="hidden" name="_token" value="W4D7bCygQ4abq2Xa3ckZ2rwG3Wk7f9enPXIIPeuF"> 
<div class="col-sm-12 google-sign-form"><p class="signup-titel" style="text-align: center;">SIGN UP FOR FREE</p></div> <div class="col-sm-12 google-sign-form">
<input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 ">
 <input type="text" placeholder="Full Name*" name="name" value="" class="form-control sign-up-input-2 ">
 <input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 "> 
<input type="password" placeholder="Desired Password*" name="password" class="form-control sign-up-input-2 "> <input type="phone" placeholder="Phone*" name="phone" value="" class="form-control sign-up-input-2 "> <p class="terms-cond"><label for="terms_of_service" class="woo">
<input type="checkbox" name="terms_of_service" id="terms_of_service" value="1" class="form-check-input" style="position: relative; margin-left: 0px;"> &nbsp; I agree to the <a target="_blank" href="https://www.lambdatest.com/terms-of-service">Terms
                                    of Service</a>
                                and <a target="_blank" href="https://www.lambdatest.com/privacy">Privacy Policy</a></label></p> <button type="submit" class=" btn sign-up-btn-2 btn-block">Signup for Free</button></div>
 <div class="col-sm-12 link-sect"><p class="login-in-link test-left">Already have an account? <a href="/login">Login</a></p></div></form>

Referenced screenshot of the page:

In order to visualize the above XML document, I have created the below flowchart.

Here, I will write the XPath in Selenium from the root node which is the form tag in our case, then will locate the Full name field using div 2 child and the attribute value of the full name field. The XPath created in this case will be as below:Below is a code snippet highlighting the XPath written using relative XPath for the register page of LambdaTest.

//form/div[@class=’ col-sm-12 google-sign-form’]/input[@name=’ name’]

In this case, I have referenced one attribute of the children and grandchildren in order to differentiate from the multiple children and grandchildren of each parent. From this we can derive the general syntax of XPath as follows:

//tagname[@attribute name= ‘value’]

Here

// Denotes the current node
Tagname : Define the tagname you are referencing to locate the element.
Attribute Value : The attribute of the define tag through which you wish to narrow down the search.
Value: Represents the value of any chosen attribute.

Nowadays, thorough use of multiple plugins and tools can help one find the XPath in Selenium with relative ease. The reason I don’t encourage people to do so, the XPath provided by these tools sometimes turn out to be brittle. Also, it may lead to people forgetting the basic concepts of creating XPath locators. Using firebug and Chrome Dev Tools one can also copy the required XPath in Selenium.

Types Of XPath In Selenium

There are two types of XPath

Absolute XPath
Relative XPath

Absolute XPath Example In Selenium

In case of absolute XPath in Selenium, the XPath expression is created using the selection from the root node. It starts with a single slash ‘/’ and traverses from the root to the whole DOM to reach to the desired element. The biggest disadvantage of using this as locating an element is, if during the course of development any changes made in the path, may lead to a failed XPath expression. For example:

/html/body/div[1]/section/div/div[2]/div/form/div[2]/input[3]

In the above XPath example in Selenium, if any tag name like section or one of the div’s changes the whole XPath would become invalid leading to script failure.

Relative XPath Example In Selenium

In case of relative XPath in Selenium, the XPath expression is generated from the middle of the DOM structure. It is represented by a double slash ‘//’ denoting the current node. In this case the search will start from the mentioned tagname and string value. It is more compact, easy to use and less prone to been broken. For example:

//input[@name=’email’]

In above XPath example in Selenium, we are searching from the current node with tagname input having attribute as name with value as email.

Below is a code snippet highlighting the XPath written using relative XPath for the register page of LambdaTest.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class RelativeXpathExample {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", " path to chromedriver ");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://accounts.lambdatest.com/register");
        //Relative xpath for organization field
        driver.findElement(By.xpath("//input[@name='organization_name']")).sendKeys("Lambdatest Org");
        //Relative xpath for full name field
        driver.findElement(By.xpath("//input[@name='name']")).sendKeys("Sadhvi Singh");
        driver.close();

    }

}

Writing Complex & Dynamic XPath In Selenium Through Various Methods

Using Basic XPath

This is the common and syntactical approach of writing the XPath in Selenium which is the combination of a tagname and attribute value. Here are few basic XPath examples in Selenium:

Xpath=//input [@name=’password’]
Xpath=//a [@href= ‘https://www.lambdatest.com/’]
Xpath=//*[@id=’email_01’]
Xpath=//input[name=’email’][@placeholder=’Work Email’]

The first two examples in the basic XPath list seems self-explanatory. In it we have used tags as input and anchor tag with their corresponding attribute value. The last two examples are just extended version of using XPath in Selenium. In the third example we have just excluded the HTML tag and represented it with an asterisk(*). In this case, the script will search in the DOM with any HTML tag having an ID attribute with value as ‘email_01’. In case of example 4, we have created the XPath using multiple attributes for the single HTML tag.

Using ‘OR’ & ‘AND’

As mentioned these logical expressions are used on the attributes condition. In case of OR any one of the conditions should be true or both, whereas in the case of AND, both the conditions should be fulfilled. For example, for the below DOM structure, XPath using AND and OR can be written as:

< input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 " >

Xpath= //input[@type= ‘email’ or @name= ‘email’]
Xpath= //input[@type= ‘email’ and @name= ‘email’]

In case of OR if any of the attribute value matches, the element will be located, whereas in case of AND both the attribute value should match and met, then only the element will be located. The above defined ways have been inculcated in the code snippet below, where we are trying to input values on the LambdaTest register page.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathExampleWithAndOR {

    public static void main(String[] args) {
        // TODO Auto-generated method stub


        System.setProperty("webdriver.chrome.driver", " path to chromedriver ");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://accounts.lambdatest.com/register");

        //Finding the organization field via xpath using OR
        driver.findElement(By.xpath("//input[@name='organization_name' or @placeholder='Organization/Company Name']")).sendKeys("Lambdatest");

        //Finding the full name field via xpath using AND
        driver.findElement(By.xpath("//input[@name='name' and @placeholder='Full Name*']")).sendKeys("Lambdatest");

        //Finding the work email field via xpath using OR, where only one of the attribute defined is correct whereas the other incorrect and does not match, still this should work as one of them meets the condition.
        driver.findElement(By.xpath("//input[@name='email' or @id='not present']")).sendKeys("Lambdatest");

        //Finding the password field via xpath using AND, where only one of the attribute defined is correct whereas the other incorrect and does not match,this should NOT work as one of them does not meets the condition.
        driver.findElement(By.xpath("//input[@name='password' and @id='not present']")).sendKeys("Lambdatest");

    }

}

Below is the console error showcasing as the last element not found as conditions were not met.

Please Note: Both ‘and’ and ‘or’ should be case sensitive. In case you tend to use, ‘OR’ or ‘AND’, you will get an error in console stating invalid xpath expression

Using Contains()

This approach in creating XPath in Selenium comes handy when we have part of attribute values that changes dynamically. For example lets say the ID for the login field which is for instance email_01, have the ending number which keeps changing every time the page is loaded. In this case using contains helps us locate element with constant names like in this case ‘email’. Example for creating XPath with contains for the below DOM structure is:

<input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 ">

Xpath=//*[contains (@placeholder, ‘Organization)]
Xpath= //input[contains (@name, ‘organization)]
Xpath=//*[contains(@class, ‘sign-up-input)]

Here in the above XPath example for Selenium we have used, attributes like placeholder, name etc and consider partial values to identify elements using contains keywords. Referenced below code snippet highlighting the usage of above XPath creation, in this we are clicking on the ‘Start testing’ button on LambdaTest homepage. Referenced screenshot:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathContainsExample {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path to chromedriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com");

        //Finding the element 'Start testing' having text as same, here we will locate element using contains through xpath
        driver.findElement(By.xpath("//a[contains(text(), 'TESTING')]")).click();

        driver.close()

    }

}

Using Starts-With()

This is similar to the above contains method, the only difference is the comparison value here starts with an initial string value. This is useful when partly values changes for a given attribute. Like in the above XPath example, the email value changes for the latter values. Here, one can use starts-with approach to identify the element. Below XPath examples for Selenium, highlight the usage of starts-with for the below DOM structure:

<input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 ">

Xpath=//input[starts-with(@placeholder, ‘Organization)]
Xpath= =//input[starts-with(@name, ‘organization)]

Here, in the example above we have used two attributes with the starts-with Keyword. The script will find for the tag name and matches with the attribute value that starts with ‘Organization’. Referenced code snippet highlighting the usage of Starts-With keyword while locating element via XPath in Selenium. We will use the same example as above, the only difference is, we will locate an element using starts-with.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathStartsWithExample {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path to chromeDriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com");

        //Finding the element 'Start testing' having text as same, here we will locate element using contains through xpath
        driver.findElement(By.xpath("//a[starts-with(text(), 'START')]")).click();

        driver.close();

    }

}

Using Text()

This keyword is used to create expressions for XPath in Selenium when we have a text defined in an HTML tag and we wish to identify element via text. This comes really handy when the other attribute values change dynamically with no substantial part of the attribute value that can be used via Starts-with or Contains. Below is an XPath example in Selenium, highlighting the usage of text for the following DOM structure:

<button type="submit" class=" btn sign-up-btn-2 btn-block">Signup for Free</button>

Xpath= //button[text()=’ Signup for Free’]
Xpath=//button[contains(text(),’ Signup’ )]

In the above mentioned examples, we have use the text on the button to identify the element. Here two instances of the examples are used, one where the text is exact matched, whereas the other where the text is matched partially using contains keyword. Referenced snippet below highlighting the usage of the text keyword. In this example, we will be clicking on one of the blogs on theLambdaTest blog page. Referenced screenshot below:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathWithTextExample {

    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub


        System.setProperty("webdriver.chrome.driver", "path to the chromedriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com/blog");


        //Finding the blog with text as 'complete guide on TestNG annotations' element
        driver.findElement(By.xpath("//a[text()='Complete Guide On TestNG Annotations For Selenium WebDriver']")).click();

        driver.close();



    }

}

Using Index

This approach comes in use when you wish to specify a given tag name in terms of index value you wish to locate too. For instance, consider a DOM having multiple input tags for each different field value and you wish to input text into the 4th field. In this case you can use the index to switch to the given tag name. For example:

For the given DOM structure, I wish to locate the second input tag field:

<div class="col-sm-12 google-sign-form"><input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 "> <input type="text" placeholder="Full Name*" name="name" value="" class="form-control sign-up-input-2 "> <input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 ">

Xpath= //div[@class= ’ col-sm-12 google-sign-form’]/input[2]

In the above example, the locator with ‘Full name’ as a field will be selected. The first input tag will be ignored whereas the other tag will be considered owing to the index mentioned. This type of approach comes in handy when dealing with data in tables. For example, when you have multiple rows, you can reference the desired row using an index. Reference code snippet using an index for a tabular form of data for the registration page of LambdaTest, where through the form class we are navigating to the ‘full name’ field using index.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathWithIndex {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "C:\\Users\\ss251550\\eclipse-workspace_automate\\Automate_Active_MQ_Process\\ChromeDriver\\chromedriver.exe");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://accounts.lambdatest.com/register");
        driver.manage().window().maximize();

        //finding the element through index using the reference of the form field containing the fields in it.
        driver.findElement(By.xpath("//div[@class='col-sm-12 google-sign-form']/input[2]")).sendKeys("sadhvi singh");

        driver.close();


    }

}

Using Chained XPath In Selenium

As the name signifies, we can use multiple XPath expressions and chained them. For example, in the below DOM structure referencing the LambdaTest homepage links:

<ul class="nav navbar-nav navbar-right">
<li><a href="https://www.lambdatest.com/feature">Live</a></li>
<li><a href="https://www.lambdatest.com/selenium-automation">Automation</a></li> <li><a href="https://www.lambdatest.com/blog">Blog</a></li>
 <li><a href="https://www.lambdatest.com/pricing">Pricing</a></li>
  <li><a href="https://www.lambdatest.com/support/">Support</a></li>
  <li class="sign-in"><a href="https://accounts.lambdatest.com/login">Login</a></li>
 <li class="login"><a href="https://accounts.lambdatest.com/register">Free Sign Up</a>
</li>
</ul>

Here, we will try to navigate to the ‘Login link’. The syntax to achieve it is.

Xpath=//ul[@class=’nav navbar-nav navbar-right’]//li[@class=’sign-in’]

In the above XPath example in Selenium, I have located the parent class for the link tags and then navigated to the child using chaining for the ‘login’ link. The above example has been achieved using the below code snippet.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathUsingChaining {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path of chromeDriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com/");
        driver.manage().window().maximize();

        //locating the 'login' link using xpath chaining and clicking on it.
        driver.findElement(By.xpath("//ul[@class='nav navbar-nav navbar-right']//li[@class='sign-in']")).click();

        //Verifying the current URL on which we post clicking on it.
        String currentURL= driver.getCurrentUrl();
        System.out.println(currentURL);

        driver.close();

    }

}

Console Output

RUN YOUR SELENIUM SCRIPTS ON CLOUD GRID

2000+ Browsers AND OS

FREE SIGNUP

XPath axes

XPath axes comes in handy when the exact element tagname or its attribute value are dynamic and cannot be used to locate an element. In this case locating element after traversing through child/sibling or parent will be easy approach. Some of the widely used XPath axes are:

Following: This XPath axes helps to locate element following the current node. Mentioned below is the DOM structure of the LambdaTest Registration Page.

<div class="col-sm-12 google-sign-form">
                              <input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 "> 
                             <input type="text" placeholder="Full Name*" name="name" value="" class="form-control sign-up-input-2 ">
                            <input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 ">
                           <input type="password" placeholder="Desired Password*" name="password" class="form-control sign-up-input-2 ">
                           <input type="phone" placeholder="Phone*" name="phone" value="" class="form-control sign-up-input-2 "> 
                            <p class="terms-cond">
                          <label for="terms_of_service" class="woo">
                         <input type="checkbox" name="terms_of_service" id="terms_of_service" value="1" class="form-check-input" style="position: relative; margin-left: 0px;"> &nbsp; I agree to the 
                         <a target="_blank" href="https://www.lambdatest.com/terms-of-service">Terms
                                    of Service</a>
                                and 
                      <a target="_blank" href="https://www.lambdatest.com/privacy">Privacy Policy</a>
</label>
</p> 
<button type="submit" class=" btn sign-up-btn-2 btn-block">Signup for Free</button>
</div>

Referenced screenshot highlighting the two input elements, wherein we will try to locate the element ‘Full name’ field through the element ‘Organization’ field

Xpath=//input[@name=’ organization_name’]//following::input[1]
Xpath= //input[@name=’ organization_name’]//following::input

In the above-mentioned examples, the first one will select the input following the organization element, whereas in the second example, it will select all elements following the organization element having input tag. These are useful when we intent to locate element in a table or when we do not have any whereabouts of the following element from the current node. Mentioned below code snippet displays the elements located via following. In this example, we will use the Lambatest homepage, where we will traverse through the menu header options using the single header class. Referenced screenshot below:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathUsingFollowing {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", " path of chromedriver ");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com/");
        driver.manage().window().maximize();

        //Locate element with the link blog using following axes
        driver.findElement(By.xpath("//ul[@class='nav navbar-nav navbar-right']//following::li[3]")).click();

        driver.close();

    }

}

2.Following sibling: This is one concept that people tend to get confused with. All you get to clear yourself with this concept, is siblings. In case of following all nodes under the current node are the targeted ones irrespective they are under(children) the context node or not but follows below the context node. In case of following siblings, all following nodes of the context node, that shares the same parent, are applicable. In this case all siblings are referred to as children of the parent node. So if you are referencing one of the children and wish to navigate to other children of the same parent that follows it, following sibling does the business.

For example, using the LambdaTest homepage links, in the DOM structure below, one of the children has been referenced, and from it, we will navigate to its siblings.

<ul class="nav navbar-nav navbar-right">
<li><a href="https://www.lambdatest.com/feature">Live</a></li>
<li><a href="https://www.lambdatest.com/selenium-automation">Automation</a></li> <li><a href="https://www.lambdatest.com/blog">Blog</a></li>
 <li><a href="https://www.lambdatest.com/pricing">Pricing</a></li>
  <li><a href="https://www.lambdatest.com/support/">Support</a></li>
  <li class="sign-in"><a href="https://accounts.lambdatest.com/login">Login</a></li>
 <li class="login"><a href="https://accounts.lambdatest.com/register">Free Sign Up</a>
</li>
</ul>

In this case, the parent is,its children are the different li, here we will locate the sign in link and from their locate the login using following sibling

Xpath= //li[@class=’sign-in’]//following-sibling::li

Below is a code snippet incorporating the XPath example in Selenium.

package ChromeDriver;

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathWithFollowingSibling {

    public static void main(String[] args) {
        // TODO Auto-generated method stub'


        System.setProperty("webdriver.chrome.driver", "path of chromeDriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com/");
        driver.manage().window().maximize();

        //locating the 'sign-up' link using xpath following sibling and clicking on it.
        driver.findElement(By.xpath("//li[@class='sign-in']//following-sibling::li")).click();

        //Verifying the current URL on which we post clicking on it.
        String currentURL= driver.getCurrentUrl();
        System.out.println(currentURL);

        driver.close();


    }

}

Console Output

3.Preceding: This method helps in locating element before the current node, as in the preceding element from the current node with XPath in Selenium. Below is a demonstration of the DOM structure.

<input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 ">
<input type="text" placeholder="Full Name*" name="name" value="" class="form-control sign-up-input-2 ">
<input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 ">

Referenced screenshot below:

Xpath=//input[@name=’password’]//preceding::input[1]
Xpath=//input[@name=’password’]//preceding::input

In the above-mentioned example, the first one will locate element with the field as email whereas the other one will locate all elements before the current node i.e. password field. This is also useful in locating elements that cannot be located by any means and can be traversed through. For example, in the case of cross browser testing, sometimes few elements cannot be recognized on IE browsers, legacy browser versions. In this case traversing to these elements using precedence or following could be helpful. Referenced example below with code snippet, highlighting how using the blog link on the LambdaTest homepage, we will circulate through theAutomation tab.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathUsingPreceeding {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path of chromedriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com/");
        driver.manage().window().maximize();

        //Fnding the automation link using the blog link
        driver.findElement(By.xpath("//a[text()='Blog']//preceding::li[1]")).click();

        driver.close();

    }

}

4.Preceding-Sibling: This is a concept similar to following sibling, the only difference in functionality is that of preceding. So, in this case, you can switch among the siblings, but in this, you will switch from the context node been a child and move to the preceding node, you wish to locate. Both the child will share the same parent. Using the same example as mentioned in the following sibling, we will now move from the sign-up link to the login link using preceding-sibling. The syntax for the same is

Xpath= //li[@class=’login’]//preceding-sibling::li[1]

Note: In case you do not specify the index of the sibling you wish to navigate it may choose to select any. For specific selection, you need to mention the index. In case of a single sibling from the context node, you need not specify the index. Below is the code snippet for the same XPath example in Selenium.

package ChromeDriver;

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathWithPrecedingSibling {

    public static void main(String[] args) {
        // TODO Auto-generated method stub'


        System.setProperty("webdriver.chrome.driver", "path of chromedriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.lambdatest.com/");
        driver.manage().window().maximize();

        //locating the 'login' link using xpath preceding sibling and clicking on it.
        driver.findElement(By.xpath("//li[@class='login']//preceding-sibling::li[1]")).click();

        //Verifying the current URL on which we post clicking on it.
        String currentURL= driver.getCurrentUrl();
        System.out.println(currentURL);

        driver.close();

    }

}

Console Output

5.Child: As the name specified this approach is used when we intent to locate all child elements of the current node. A basic use case of this approach could be when we wish to circulate through all the data in a table through the rows, in this case we can find all the child of a particular table. For example, using the below referenced DOM structure, we can create an XPath in Selenium as follows:

<div class="col-sm-12 google-sign-form"><input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 "> <input type="text" placeholder="Full Name*" name="name" value="" class="form-control sign-up-input-2 "> <input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 "> <input type="password" placeholder="Desired Password*" name="password" class="form-control sign-up-input-2 "> <input type="phone" placeholder="Phone*" name="phone" value="" class="form-control sign-up-input-2 "> <p class="terms-cond"><label for="terms_of_service" class="woo"><input type="checkbox" name="terms_of_service" id="terms_of_service" value="1" class="form-check-input" style="position: relative; margin-left: 0px;"> &nbsp; I agree to the <a target="_blank" href="https://www.lambdatest.com/terms-of-service">Terms
                                    of Service</a>
                                and <a target="_blank" href="https://www.lambdatest.com/privacy">Privacy Policy</a></label></p> <button type="submit" class=" btn sign-up-btn-2 btn-block">Signup for Free</button></div>

Referenced screenshot of the same.

Xpath= //div[@class=’ col-sm-12 google-sign-form’]/child::input
Xpath= //div[@class=’ col-sm-12 google-sign-form’]/child::input[1]

In the above-mentioned example, the first will locate all the input fields of the div for which are organization field, name field, email field, password field and phone number field, where as the other is used to locate element with the organization field only.

Below is the code snippet highlighting the use of child axes on the same. We are using the same register example of LambdaTest register page.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathUsingChild {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path of chrome driver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://accounts.lambdatest.com/register");
        driver.manage().window().maximize();

        //Finding the work email filed using the child locator xpath axes
        driver.findElement(By.xpath("//div[@class='col-sm-12 google-sign-form']/child::input[3]")).sendKeys("sadhvi singh");;

        driver.close();

    }

}

6.Parent: This method is used to select the parent node of the current node. For example, for the below referenced DOM structure, the parent node is located through XPath.

<div class="col-sm-12 google-sign-form"><input type="text" placeholder="Organization/Company Name" name="organization_name" value="" class="form-control sign-up-input-2 "> <input type="text" placeholder="Full Name*" name="name" value="" class="form-control sign-up-input-2 "> <input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 "> <input type="password" placeholder="Desired Password*" name="password" class="form-control sign-up-input-2 "> <input type="phone" placeholder="Phone*" name="phone" value="" class="form-control sign-up-input-2 "> <p class="terms-cond"><label for="terms_of_service" class="woo"><input type="checkbox" name="terms_of_service" id="terms_of_service" value="1" class="form-check-input" style="position: relative; margin-left: 0px;"> &nbsp; I agree to the <a target="_blank" href="https://www.lambdatest.com/terms-of-service">Terms
                                    of Service</a>
                                and <a target="_blank" href="https://www.lambdatest.com/privacy">Privacy Policy</a></label></p> < button type="submit" class=" btn sign-up-btn-2 btn-block">Signup for Free< /button ></div>

Referenced screenshot:

Xpath= //input[@name=’email’]//parent::div

In the above example, the parent element is located through its child element. From the email field we are traversing to its parent node. Please note in case of child XPath, only the immediate children of the current node are considered and not the grandchildren. In case if the current node is the root node, then its parent will be empty and hence it will have no parent aces. Below is the code snippet for the same:

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathUsingParent {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path of chromedriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
               driver.get("https://accounts.lambdatest.com/register");
               driver.manage().window().maximize();

        //Finding the parent form usnig the password field as the current node.
        WebElement parentDiv=driver.findElement(By.xpath("//input[@name='password']//parent::div"));
        System.out.print(parentDiv.getAttribute("class"));

        driver.close();

    }

}

Console Output

7.Descendants: This approach is used to locate element via XPath for all the children and sub children of the current node. For the below DOM structure, the descendants for XPath in Selenium are located as:

<div class="col-lg-3 col-md-4 col-sm-6 sign-form"><a href="https://www.lambdatest.com"><img height="38" src="/images/logo.svg" class="img-responsive mb-4 mx-auto d-block"></a> <h1 class="title text-center font-weight-light">Hello! Welcome back</h1> <input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg"> <input type="password" name="password" placeholder="Password" class="form-control mt-3 form-control-lg"> <button type="submit" class="btn btn-primary btn-lg btn-block mt-3">LOGIN</button> <div class="form-group form-check mt-2"><input type="checkbox" name="remember" id="remember" class="form-check-input"> <label for="remember" class="form-check-label">Remember Me</label></div> <div class="row mt-2"><div class="col pr-2 text-pass"><a href="https://accounts.lambdatest.com/password/reset">Forgot Password?</a></div> <div class="col pl-2 text-pass text-right">No account? <a href="/register">Sign up</a></div></div></div>

Referenced Screenshot:

Xpath= //div[@class=’ col-lg-3 col-md-4 col-sm-6 sign-form’]//descendant:: input

In the example above all the elements like email field, password field and button will be selected. One can also select one of the mentioned fields using index. Below is a code snippet highlighting the use of it.

import java.util.List;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathUsingDescendants {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path of chromedriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://accounts.lambdatest.com/login");
        driver.manage().window().maximize();

        //Finding the remember me grandchildren of the login form with field value as remember me.
        WebElement rememberMe=driver.findElement(By.xpath("//div[@class='col-lg-3 col-md-4 col-sm-6 sign-form']//descendant::label"));
        rememberMe.click();
        System.out.print(rememberMe.getText());

        driver.close();


    }

}

Console Output

8.Ancestors: In this method the context node, parent or its grandparents are selected via the Ancestors axes. For example, for the below DOM structure the ancestor will be defined as:

 <form method="POST" action="https://accounts.lambdatest.com/login"><input type="hidden" name="_token" value="W4D7bCygQ4abq2Xa3ckZ2rwG3Wk7f9enPXIIPeuF"> <div class="row justify-content-sm-center"><div class="col-lg-3 col-md-4 col-sm-6 sign-form"><a href="https://www.lambdatest.com"><img height="38" src="/images/logo.svg" class="img-responsive mb-4 mx-auto d-block"></a> <h1 class="title text-center font-weight-light">Hello! Welcome back</h1> <input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg"> <input type="password" name="password" placeholder="Password" class="form-control mt-3 form-control-lg"> <button type="submit" class="btn btn-primary btn-lg btn-block mt-3">LOGIN</button> <div class="form-group form-check mt-2"><input type="checkbox" name="remember" id="remember" class="form-check-input"> <label for="remember" class="form-check-label">Remember Me</label></div> <div class="row mt-2"><div class="col pr-2 text-pass"><a href="https://accounts.lambdatest.com/password/reset">Forgot Password?</a></div> <div class="col pl-2 text-pass text-right">No account? <a href="/register">Sign up</a></div></div></div></div></form>

Referenced screenshot:

Xpath= //input[@name=’email]//ancestor::div[1]
Xpath= //input[@name=’email]//ancestor::form

In the example above, the first one will point to the parent node of the login fields where the other will point to its grandparent node which is the tag form in this case. Below code snippet highlighting the use of the same.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class XpathUsingAncestor {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.setProperty("webdriver.chrome.driver", "path of chromedriver");
        WebDriver driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://accounts.lambdatest.com/login");
        driver.manage().window().maximize();

        //Finding the parent div using the password field of the login page.
        WebElement parentDiv=driver.findElement(By.xpath("//input[@name='password']//ancestor::div[1]"));
        System.out.println(parentDiv.getAttribute("class"));

        WebElement parentForm=driver.findElement(By.xpath("//input[@name='password']//ancestor::form"));
        System.out.println(parentForm.getAttribute("action"));


        driver.close();


    }

}

Console Output

Conclusion

XPath in Selenium helps an individual find out solutions in locating elements when the standard processes do not work. When to use which is important when it comes to different complexities of the DOM structure and the functional needs. As defined earlier in my article, cross browser testing could be one of the areas where you can explore the creation of XPath in Selenium, due to different browser behaviors towards DOM element. Make sure whichever method you opt in case of XPath are less prone to failure and make the scripts more robust, neater and easier to maintain. Cheers!

Origanally Published: LambdaTest

Find Elements With Link Text & Partial Link Text In Selenium

Selenium Java Tutorial – Class Name Locator In Selenium

Complete Guide On TestNG Annotations For Selenium WebDriver

sadhvisingh1 — Wed, 01 May 2019 10:15:02 +0000

TestNG is a testing framework created by Cédric Beust and helps to cater a lot of our testing needs. It is widely used in Selenium. Wondering on what NG stands for? Well, it refers to ‘Next Generation’. TestNG is similar to Junit but is more powerful to it when it comes to controlling the execution flow of your program. As the nature of framework, we tend to make our tests more structured and provides better validation points through the use of TestNG Annotations.

Some of the noteworthy features of TestNG are:

Powerful and wide variety of TestNG annotations to support your test cases.
Helps to perform parallel testing, dependent method testing.
Flexibility of running your tests through multiple sets of data through TestNG.xml file or via data-provider concept.
Test cases can be grouped and prioritized as per need basis.
Provides access to HTML reports and can be customized through various plugins.
Test logs can be generated across tests.
Can be easily integrated with eclipse, Maven, Jenkins etc.

A basic process flow of a TestNG programs involves the following steps:

So, before jumping onto the annotations in TestNG for Selenium automation, it would be better to refer the prerequisites are required to setup TestNG.

Prerequisites

Java Development Kit
Setup Eclipse or any other IDE.
Install TestNG in Eclipse or any other IDE.

Note: Annotations can be used only with Java version 1.5 or higher.

If you are new to TestNG framework then follow our guide to run your first automation script with TestNG.

If you’re new to Selenium and wondering what it is then we recommend checking out our guide — What is Selenium?

Check out this, How To Debug Websites Using Developer Tools for Safari

So, What Is An Annotation?

An annotation is a tag that provides additional information about the class or method. It is represented by **‘@’ **prefix. TestNG use these annotations to help in making a robust framework. Let us have a look at these annotations of TestNG for Selenium.

@test

The most important TestNG annotations framework where the main business logic resides. All functionalities to be automated are kept inside the @test annotation method. It has various attributes based on which the method can be reformed and executed.

Example of a code snippet below validating the url :

[@Test](http://twitter.com/Test)
    public void testCurrentUrl() throws InterruptedException
    {
        driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/header/aside/ul/li[4]/a")).click();

        String currentUrl= driver.getCurrentUrl();
        assertEquals(current_url, "[https://automation.lambdatest.com/timeline/?viewType=build&page=1](https://automation.lambdatest.com/timeline/?viewType=build&page=1)", "url did not matched");
    }

@BeforeTest

This annotation is run before your first @test TestNG Annotations method in your class. You can use this annotation in TestNG for Selenium to setup your browser profile preferences, for example auto opening your browser in maximize mode, setting up your own customized profile for your browser etc.

Below is the code snippet for BeforeTest method ensuring the browser opens in maximize mode:

[@BeforeTest](http://twitter.com/BeforeTest)
    public void profileSetup()
    {
        driver.manage().window().maximize();


    }

@AfterTest

This TestNG Annotations runs after all your test methods belonging to your class have run. This is a useful annotation which comes handy in terms of reporting your automation results to your stakeholders. You can use this annotation to generate report of your tests and share it to your stakeholders via email.

Example of the code snippet below:

[@AfterTest](http://twitter.com/AfterTest)
    public void reportReady()
    {
        System.out.println("Report is ready to be shared, with screenshots of tests");
    }

@BeforeMethod

This annotation in TestNG runs before every @test annotated method. You can use it to check out for the database connections before executing your tests or lets say different functionality been tested in your @test annotated method which requires user login in a certain class. In this case also you can put your login code in the @BeforeMethod annotation method.

Below code snippet is an example, displaying login functionality of the LambdaTest platform:

[@BeforeMethod](http://twitter.com/BeforeMethod)
    public void checkLogin()
    {
          driver.get("[https://accounts.lambdatest.com/login](https://accounts.lambdatest.com/login)");
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='email']")).sendKeys("[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)");
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='password']")).sendKeys("XXXXX");
          driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/section/form/div/div/button")).click();

    }

@AfterMethod

This annotation runs after every @test annotated method. This annotation can be used to take screenshots of every test method ran against test runs .

Below code snippet indicating screenshot taken in the @AfterTest TestNG Annotations for Selenium:

[@AfterMethod](http://twitter.com/AfterMethod)
    public void screenShot() throws IOException
    {
        TakesScreenshot scr= ((TakesScreenshot)driver);
        File file1= scr.getScreenshotAs(OutputType.FILE);

       FileUtils.copyFile(file1, new File("C:\\Users\\navyug\\workspace\\QAPractise\\test-output\\test1.PNG"));

    }

@BeforeClass

This annotation runs before the first test method in the current class.This annotation can be used to setup your browser properties, initialize your driver, opening your browser with the desired URL etc.

Below is the code snippet for BeforeClass:

[@BeforeClass](http://twitter.com/BeforeClass)
    public void appSetup()
    {
        driver.get(url);

    }

@AfterClass

This TestNG Annotations runs after the last test method in the current class. This annotation in TestNG can be used to perform clean up activities during your tests like closing your driver etc

Below is the example of code snippet showing closing activities performed:

[@AfterClass](http://twitter.com/AfterClass)
    public void closeUp()
    {
        driver.close();
    }

@BeforeSuite

A suite can consist of multiple classes, this TestNG Annotations runs before all the tests methods of all the classes. This annotation marks the entry point of execution. @BeforeSuite annotation in TestNG can be used to perform the needed and generic functions like setting up and starting Selenium drivers or remote web drivers etc.

Example of @BeforeSuite annotation in TestNG, code snippet showcasing setting up of driver:

[@BeforeSuite](http://twitter.com/BeforeSuite)
    public void setUp()
    {
    System.setProperty("webdriver.chrome.driver", "path to chrome driver");
    driver=new ChromeDriver();
    }

Explore what WebDriver is, its features, how it works, best practices, and more in this WebDriver Tutorial.

@AfterSuite

This TestNG Annotations runs post all the test methods of all the classes have run. This annotation can be used to clean up the processes before completing off your tests when you have multiple classes in functioning, for example closing the drivers etc.

Below is the code snippet for @AfterSuite annotation in TestNG for Selenium:

[@AfterSuite](http://twitter.com/AfterSuite)
    public void cleanUp()
    {

        System.out.println("All close up activities completed");
    }

@BeforeGroups

TestNG helps testers create a bunch of tests into groups through the attribute group used in the @test TestNG Annotations. For example, if you wish all similar functionalities related to user management to be clubbed together, you can mark all tests like Dashboard, profile, transactions etc. into a single group as ‘user_management’. This @BeforeGroups annotation in TestNG helps to run the defined test first before the specified group. This annotation can be used if the group focuses on a single functionality like stated in the above example. The BeforeGroup annotation can contain the login feature which is required to run before any other methods like user dashboard, user profile etc.

Example of the Code snippet for @BeforeGroups annotation in TestNG for Selenium:

[@BeforeGroups](http://twitter.com/BeforeGroups)("urlValidation")
    public void setUpSecurity() {
        System.out.println("url validation test starting");
    }

@AfterGroups

This TestNG Annotations runs after all the test methods of the specified group are executed.
Example of Code snippet for @AfterGroups annotation in TestNG for Selenium:

[@AfterGroups](http://twitter.com/AfterGroups)("urlValidation")
    public void tearDownSecurity() {
        System.out.println("url validation test finished");
    }

The below code displays an example of all annotations used along with TestNG report respectively:

import static org.testng.Assert.assertEquals;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterGroups;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class AnnotationsTestNG {

public WebDriver driver;
        public String url="[https://www.lambdatest.com/](https://www.lambdatest.com/)";

    [@BeforeSuite](http://twitter.com/BeforeSuite)
    public void setUp()
    {   
        System.setProperty("webdriver.chrome.driver", "C:\\Users\\navyug\\workspace\\QAPractise\\src\\ChromeDriver\\chromedriver.exe");
        driver=new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);
        System.out.println("The setup process is completed");
    }

    [@BeforeTest](http://twitter.com/BeforeTest)
    public void profileSetup()
    {
        driver.manage().window().maximize();
        System.out.println("The profile setup process is completed");

    }

    [@BeforeClass](http://twitter.com/BeforeClass)
    public void appSetup()
    {
        driver.get(url);
        System.out.println("The app setup process is completed");
    }

    [@BeforeMethod](http://twitter.com/BeforeMethod)
    public void checkLogin()
    {
          driver.get("[https://accounts.lambdatest.com/login](https://accounts.lambdatest.com/login)");
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='email']")).sendKeys("[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)");
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='password']")).sendKeys("activa9049");
          driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/section/form/div/div/button")).click();
          System.out.println("The login process on lamdatest is completed");
    }

    [@Test](http://twitter.com/Test)(groups="urlValidation")
    public void testCurrentUrl() throws InterruptedException
    {
        driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/header/aside/ul/li[4]/a")).click();
        Thread.sleep(6000);
        String currentUrl= driver.getCurrentUrl();
        assertEquals(currentUrl, "[https://automation.lambdatest.com/timeline/?viewType=build&page=1](https://automation.lambdatest.com/timeline/?viewType=build&page=1)", "url did not matched");
        System.out.println("The url validation test is completed");
    }

    [@AfterMethod](http://twitter.com/AfterMethod)
    public void screenShot() throws IOException
    {
        TakesScreenshot scr= ((TakesScreenshot)driver);
        File file1= scr.getScreenshotAs(OutputType.FILE);

        FileUtils.copyFile(file1, new File("C:\\Users\\navyug\\workspace\\QAPractise\\test-output\\test1.PNG"));
        System.out.println("Screenshot of the test is taken");
    }

    [@AfterClass](http://twitter.com/AfterClass)
    public void closeUp()
    {
        driver.close();
        System.out.println("The close_up process is completed");
    }

    [@AfterTest](http://twitter.com/AfterTest)
    public void reportReady()
    {
        System.out.println("Report is ready to be shared, with screenshots of tests");
    }

    [@AfterSuite](http://twitter.com/AfterSuite)
    public void cleanUp()
    {

        System.out.println("All close up activities completed");
    }

    [@BeforeGroups](http://twitter.com/BeforeGroups)("urlValidation")
    public void setUpSecurity() {
        System.out.println("url validation test starting");
    }

    [@AfterGroups](http://twitter.com/AfterGroups)("urlValidation")
    public void tearDownSecurity() {
        System.out.println("url validation test finished");
    }



}

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:

Check out this, How To Debug Websites Using Dev Tools in Safari

TestNG Report:

Console Output:

Watch this video to learn how to set up and use TestNG with Selenium to automate your testing process. We will also introduce the TestNG Priority method, which allows you to write easy-to-read and maintainable tests.

Execution Sequence Of Annotations In TestNG For Selenium

All TestNG Annotations described above are executed on runtime in the following order:

BeforeSuite
BeforeTest
BeforeClass
BeforeGroups
BeforeMethod
Test
AfterMethod
AfterGroups
AfterClass
AfterTest
AfterSuite

Here is an image of the basic workflow of these annotations:

Attributes Used With TestNG Annotations

These test annotations in TestNG have multiple attributes that can be used for our test method. The attributes further help in defining our tests and help in providing clarity in terms of execution flow of the different test’s method used in the TestNG class. Listing them below:

Description: It defines the test method. One can define what a method does via the description. For example, @test(description=”this test validates the login functionality”).
alwaysRun: this attribute when used with a test method ensures it always run irrespective of the fact even if the parameters on which the method depends fails. When the value is set to true this method will always execute. For example, @test(alwaysRun= true).
dataProvider: This attribute is set to provide data from the dataProvider annotated test to the test provided with this attribute. For example, let’s say you intent to run your tests on multiple cross browsers, where a dataProvider annotated test is written which contains multiple inputs of browsers and their corresponding versions. In this case the test containing this attribute will use those inputs of data to run you tests on multiple browsers. Syntax for the same is, @test(dataProvider=”cross browser testing”).
dependsOnMethods: This attribute provides details to the execution flow, wherein the test is executed only if its dependent method mentioned in the attribute is executed. In case the test on which the method depends on is failed or not executed, the test is skipped from the execution. For example, @test(dependsOnmethod=”Login”).
groups: This attribute helps to groups your test methods focusing onto a single functionality into one group. For example, @test(groups=”Payment_Module”). This attribute also helps in the longer run when one can choose to ignore few groups during the execution cycle and chose over the other groups. All one need to do is mention the included groups in the TestNG.xml file within the include tag whereas the excluded groups can be defined using the exclude tag in the xml file.
dependsOnGroups: this attribute performs the above two attributes functions in collation i.e. it defines the test method with the attribute ‘dependsOn’ the defined groups. Once that group of tests are run, only post that this annotated method would execute. For example, @test(dependsOnMethods = "Payment_Module" ).
priority: This attribute helps us to defined priority of the test’s methods. When TestNG executes the @test annotated method, it may do so in random order. In a scenario where you wish that your @test annotated method runs in a desired sequence you can use the priority attribute. The default priority of all test methods is 0. Priorities in ascending order are scheduled first for execution for example, @test(priority=1), @test(priority=2), in this case test with priority equal to one will be executed first then the test with priority as 2.
enabled: This attribute comes into picture, when you have an intent to ignore a particular test method and don’t want to execute it. All you need to do is set this attribute to false. For example, @test(enabled= false).
timeout: This attribute helps to define the time a particular test should take to execute, in case it exceeds the time defined by the attribute, the test method would terminate and will fail with an exception marked as org.testng.internal.thread.ThreadTimeoutException. For example, @test(timeOut= 500). Please note the time specified is in milliseconds.
InvocationCount: This attribute works exactly like the loop. Based on the attribute set across the test method, it would execute that method those number of times. For example, @test(invocationCount = 5), this would execute the test 5 times.
InvocationTimeOut: this attribute is used in unison with the above invocationCount attribute. Based on the set value of this attribute along with the invocationCount, this ensures the test runs the number of times specified as per the invocationCount in the defined time set by the invocationTimeOut attribute. For example, @test(invocationCount =5,invocationTimeOut = 20 ).
**expectedExceptions: **this attribute helps to handle the exception the test method is expected to throw. In case the one defined in the attribute is set and thrown by the test method it is passed else any other exception not stated in the attribute and thrown by the test method, would make the test method fail. For example, @test(expectedExceptions = {ArithmeticException.class }).

The above defined are the attributes used with the annotations in TestNG for Selenium. Below is the code snippet showcasing the use of the above attributes:

import static org.testng.Assert.assertEquals;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterGroups;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class AnnotationsTest {

public WebDriver driver;
    public String url="[https://www.lambdatest.com/](https://www.lambdatest.com/)";

    [@BeforeSuite](http://twitter.com/BeforeSuite)
    public void setUp()
    {
        System.setProperty("webdriver.chrome.driver", "C:\\Users\\navyug\\workspace\\QAPractise\\src\\ChromeDriver\\chromedriver.exe");
        driver=new ChromeDriver();
        System.out.println("The setup process is completed");
    }

    [@BeforeTest](http://twitter.com/BeforeTest)
    public void profileSetup()
    {
        driver.manage().window().maximize();
        System.out.println("The profile setup process is completed");

    }

    [@BeforeClass](http://twitter.com/BeforeClass)
    public void appSetup()
    {
        driver.get(url);
        System.out.println("The app setup process is completed");
    }


    [@Test](http://twitter.com/Test)(priority=2)
    public void checkLogin()
    {
          driver.get("[https://accounts.lambdatest.com/login](https://accounts.lambdatest.com/login)");
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='email']")).sendKeys("[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)");
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='password']")).sendKeys("xxxxx");
          driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/section/form/div/div/button")).click();
          System.out.println("The login process on lamdatest is completed");
    }

    [@Test](http://twitter.com/Test)(priority=0 ,description= "this test validates the sign-up test")
    public void signUp() throws InterruptedException
    {
        WebElement link= driver.findElement(By.xpath("//a[text()='Free Sign Up']"));
        link.click();
        WebElement organization=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='organization_name']"));
        organization.sendKeys("LambdaTest");
        WebElement firstName=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='name']"));
        firstName.sendKeys("Test");
        WebElement email=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='email']"));
        email.sendKeys("[User622@gmail.com](mailto:User622@gmail.com)");
        WebElement password=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='password']"));
        password.sendKeys("TestUser123");
        WebElement phoneNumber=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='phone']"));
        phoneNumber.sendKeys("9412262090");
        WebElement termsOfService=driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='terms_of_service']"));
        termsOfService.click();
        WebElement button=driver.findElement(By.xpath("//button[text()='Signup']"));
        button.click();




    }

    [@Test](http://twitter.com/Test)(priority=3, alwaysRun= true, dependsOnMethods="check_login", description="this test validates the URL post logging in" , groups="url_validation")
    public void testCurrentUrl() throws InterruptedException
    {
        driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/header/aside/ul/li[4]/a")).click();
        String currentUrl= driver.getCurrentUrl();
        assertEquals(current_url, "[https://automation.lambdatest.com/timeline/?viewType=build&page=1](https://automation.lambdatest.com/timeline/?viewType=build&page=1)", "url did not matched");
        System.out.println("The url validation test is completed");
    }

    [@Test](http://twitter.com/Test)(priority=1, description = "this test validates the logout functionality" ,timeOut= 25000)
    public void logout() throws InterruptedException
    {
        Thread.sleep(6500);
         driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='userName']")).click();
         driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='navbarSupportedContent']/ul[2]/li/div/a[5]")).click();   
    }

    [@Test](http://twitter.com/Test)(enabled=false)
    public void skipMethod()
    {
        System.out.println("this method will be skipped from the test run using the attribute enabled=false");
    }

    [@Test](http://twitter.com/Test)(priority=6,invocationCount =5,invocationTimeOut = 20)
    public void invocationcountShowCaseMethod()
    {
        System.out.println("this method will be executed by 5 times");
    }



    [@AfterMethod](http://twitter.com/AfterMethod)()
    public void screenshot() throws IOException
    {
        TakesScreenshot scr= ((TakesScreenshot)driver);
        File file1= scr.getScreenshotAs(OutputType.FILE);

       FileUtils.copyFile(file1, new File("C:\\Users\\navyug\\workspace\\QAPractise\\test-output\\test1.PNG"));
       System.out.println("Screenshot of the test is taken");
    }

    [@AfterClass](http://twitter.com/AfterClass)
    public void closeUp()
    {
        driver.close();
        System.out.println("The close_up process is completed");
    }

    [@AfterTest](http://twitter.com/AfterTest)
    public void reportReady()
    {
        System.out.println("Report is ready to be shared, with screenshots of tests");
    }

    [@AfterSuite](http://twitter.com/AfterSuite)
    public void cleanUp()
    {

        System.out.println("All close up activities completed");
    }

    [@BeforeGroups](http://twitter.com/BeforeGroups)("urlValidation")
    public void setUpSecurity() {
        System.out.println("url validation test starting");
    }

    [@AfterGroups](http://twitter.com/AfterGroups)("urlValidation")
    public void tearDownSecurity() {
        System.out.println("url validation test finished");
    }



}

Console Output:

TestNG Report:

Watch this video to learn about the TestNG Annotations and how they help provide better structure and readability to the code.

Annotations In TestNG For Desired Purpose

There are more annotations than the ones defined above, which are used for desired purpose only.

@DataProvider

This annotated method is used for supplying data to the test method in which the dataProvider attribute is defined. This annotated method helps in creating a data driven framework where multiple sets of input values can be given which returns a 2D array or object. @DataProvider annotation in TestNG comes with two attributes.

name- this attribute is used to provide name to the dataprovider. If not set it defaults to the name of the method provided.
parallel-this is one attribute that helps in running your tests in parallel with different variation of data. This attribute is one of the reasons to make TestNG more powerful to Junit. Its default value is false.

Below is the code snippet indicating the use of @DataProvider annotation with name and parallel attribute set to it.

[@DataProvider](http://twitter.com/DataProvider)(name="SetEnvironment", parallel=true)
public Object[][] getData(){

Object[][] browserProperty = new Object[][]{

{Platform.WIN8, "chrome", "70.0"},
{Platform.WIN8, "chrome", "71.0"}
};
return browserProperty;

}

@Factory

This annotation helps to run multiple test classes through a single test class. It basically defines and create tests dynamically.

The below code snippet indicates the use of @Factory annotation that helps calls the test method class.

package ChromeDriver;

import org.testng.annotations.Test;

public class FactorySimplyTest1 {

[@Test](http://twitter.com/Test)
    public void testMethod1() {
        System.out.println("This is to test for method 1 for Factor Annotation");

}}

package ChromeDriver;

import org.testng.annotations.Test;

public class FactorySimpleTest2 {

[@Test](http://twitter.com/Test)
    public void testMethod2() {
        System.out.println("This is to test for method 2 for Factor Annotation");


}
}

package ChromeDriver;

import org.testng.annotations.Factory;
import org.testng.annotations.Test;

public class FactoryAnnotation {

[@Factory](http://twitter.com/Factory)()
    [@Test](http://twitter.com/Test)
    public Object[] getTestFactoryMethod() {
        Object[] factoryTest = new Object[2];
        factoryTest[0] = new FactorySimplyTest1();
        factoryTest[1] = new FactorySimpleTest2();
        return factoryTest;
    }

}

Console Output:

@Parameters

This annotation helps you pass parameters to your tests directly via the testNG.xml file. Usually this is preferred when you have limited data sets to try on your tests. In case of complicated and large data sets @dataProvider annotation is preferred or excel.

The below code snippet showcase the same:

[@Parameters](http://twitter.com/Parameters)({ "username", "password"})
    [@Test](http://twitter.com/Test)()
    public void checkLogin(String username, String password)
    {
          driver.get("[https://accounts.lambdatest.com/login](https://accounts.lambdatest.com/login)");
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='email']")).sendKeys(username);
          driver.findElement(By.xpath("//input[[@name](http://twitter.com/name)='password']")).sendKeys(password);
          driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/section/form/div/div/button")).click();
          System.out.println("The login process on lamdatest is completed");
    }

The parameter values are defined in the TestNG.xml file as below:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">

<suite name="Suite">

  <test thread-count="5" name="Annotations">

    &lt;parameter name="username"  value="[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)" /&gt;
    &lt;parameter name="password"  value="XXXXX" /&gt;

    &lt;classes&gt;
        &lt;class name="Parameter_annotation"/&gt;
    &lt;/classes&gt;



</test> <!-- Annotations -->

</suite> <!-- Suite -->

@Listener

This annotation helps in logging and reporting. We have multiple listeners like:

IExecutionListener
IAnnotationTransformer
ISuiteListener
ITestListener

But to go in depth with these listeners and their uses would be a talk for another blog. I will be writing one soon, so stay tuned.

Check out this, How To Test Internet Explorer on Mac

That Was All!

The key point to note while working with all these annotations and attributes is your system should have java 1.5 version or higher as these annotations are not supported for all lower versions of java and you may tend to receive error for them.

All the above mentioned TestNG Annotations and attributes of TestNG helps to provide better structuring and readability to the code. It helps provide detailed reports that makes status reporting part even easier and useful. Use of these annotations in TestNG for Selenium completely depend on your business requirements. Hence, choosing the right ones for the right use is important. Try out these annotations in TestNG on LambdaTest Selenium Grid now!

Locating Elements by TagName In Selenium

sadhvisingh1 — Mon, 29 Apr 2019 09:11:21 +0000

Selenium locators are your key when dealing with locating elements on a web page. From the list of locators like ID, Name, Class, tag name, XPath, CSS selector etc, one can choose any of these as per needs and locate the web element on a web page. Since ID’s, name, XPath or CSS selectors are more frequently used as compared to tag name or linktext, people majorly have less idea or no working experience of the latter locators. In this article, I will be detailing out the usage and real-time examples of How to Get Element by Tag Name locators In Selenium.

So, what is a tag name locator in Selenium?

A tag name is a part of a DOM structure where every element on a page is been defined via tag like input tag, button tag or anchor tag etc. Each tag has multiple attributes like ID, name, value class etc. As far as other locators in Selenium are concerned, we used these attributes values of the tag to locate elements. In the case of tag name Selenium locator, we will simply use the tag name to identify an element.

Below is the DOM structure of LambdaTest login page where I have highlighted the tag names:

Email Field: < input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

Password Field: < input type="password" name="password" placeholder="Password" class="form-control mt-3 form-control-lg" >

Forgot Password Link: < button type="submit" class="btn btn-primary btn-lg btn-block mt-3">LOGIN< /button >

Now the question that arises in one’s mind is, when do I use this tag name locator in Selenium? Well, in a scenario where you do not have attribute values like ID, class or name and you tend to locate an element, you may have to rely on using the tag name locator in Selenium. For example, in case you wish to retrieve data from a table, you may use < td > tag or < tr > tag to retrieve data.

Similarly, in a scenario where you wish to verify the number of links and validating whether they are working or not, you can choose to locate all such links through the anchor tag.

Please note: In a simple basic scenario where an element is located just via tag, it may lead to a lot of values being identified and may cause issues. In this case, Selenium will select or locate the first tag that matches the one provided from your end. So, refrain yourself from using tag name locator in Selenium if you intend to locate a single element.

The command to identify an element via tag name in Selenium is:

driver.findElement(By.tagName("input"));

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

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

Test your mobile websites and smartphone apps using our scalable on cloud mobile emulator online.

Real Time Scenarios Highlighting How to Get Element by Tag Name In Selenium

Scenario 1

A basic example, where we are locating the image avatar on ‘my profile’ section of LambdaTest:

Reference is the DOM structure of the avatar:

< img src="https://www.gravatar.com/avatar/daf7dc69b0d19124ed3f9bab946051f6.jpg?s=200&d=mm&r=g" alt="sadhvi" class="img-thumbnail" >

Let’s look into the code snippet now:

package Chromedriver;

    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.chrome.ChromeDriver;

    public class Locator_By_Tagname {

        public static void main(String[] args) throws InterruptedException {
            // TODO Auto-generated method stub

            //Setting up chrome using chromedriver by setting its property
                    System.setProperty("webdriver.chrome.driver", " Path of chromeDriver "); 

                    //Opening browser
                    WebDriver driver= new ChromeDriver() ;

                    //Opening window tab in maximize mode
                    driver.manage().window().maximize();

                    //Opening application
                    driver.get("[https://accounts.lambdatest.com/login](https://accounts.lambdatest.com/login)");

                    //Locating the email field element via Name tag and storing it in the webelement
                    WebElement email_field=driver.findElement(By.name("email"));

                    //Entering text into the email field
                    email_field.sendKeys("[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)");

                    //Locating the password field element via Name tag and storing it in the webelement
                    WebElement password_field=driver.findElement(By.name("password"));

                    //Entering text into the password field
                    password_field.sendKeys("New1life");

                    //Clicking on the login button to login to the application
                    WebElement login_button=driver.findElement(By.xpath("//button[text()='LOGIN']"));

                    //Clicking on the 'login' button
                    login_button.click();

                   //Clicking on the Settings option
                    driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/header/aside/ul/li[8]/a")).click();

                    //Waiting for the profile option to appear
                    Thread.sleep(3500);

                    //*[[@id](http://twitter.com/id)="app"]/header/aside/ul/li[8]/ul/li[1]/a
                    //Clicking on the profile link
                    driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/header/aside/ul/li[8]/ul/li[1]/a")).click();

                    //Locating the element via img tag for the profile picture and storing it in the webelement
                    WebElement image= driver.findElement(By.tagName("img"));

                    //Printing text of Image alt attribute which is sadhvi
                    System.out.println(image.getAttribute("alt"));

        }

    }

Scenario 2

In this example, we will be verifying the number of links on the LambdaTest homepage and printing those link-texts:

package Chromedriver;


    import java.util.List;


    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.chrome.ChromeDriver;

    public class Tagname_linktest {

        public static void main(String[] args) {
          // TODO Auto-generated method stub


            //Setting up chrome using chromedriver by setting its property
                    System.setProperty("webdriver.chrome.driver", " Path of chromeDriver "); 

                    //Opening browser
                    WebDriver driver= new ChromeDriver() ;

                    //Opening window tab in maximize mode
                    driver.manage().window().maximize();

                    //Opening application
                    driver.get("[https://www.lambdatest.com](https://www.lambdatest.com)");

                    //storing the number of links in list
                    List<WebElement> links= driver.findElements(By.tagName("a"));

                    //storing the size of the links
                    int i= links.size();

                    //Printing the size of the string
                    System.out.println(i);

                    for(int j=0; j<i; j++)
                    {
                        //Printing the links
                        System.out.println(links.get(j).getText());
                    }

                    //Closing the browser
                    driver.close();



        }

    }

Below is a screenshot of the console:

IOS emulators for PC- Looking to perform Android and iOS app testing on Real Device Cloud, check out this

Scenario 3

In this example, I will showcase when one wants to identify the number of rows in a table as during runtime this information can be dynamic and hence, we need to evaluate beforehand on the number of rows and then retrieve or validate the information.

Below is the DOM structure of the table:

< tbody class="yui3-datatable-data" >< tr id="yui_patched_v3_18_1_1_1554473988939_130" data-yui3-record="model_1" class="yui3-datatable-even" >

< tr id="yui_patched_v3_18_1_1_1554473988939_130" data-yui3-record="model_1" class="yui3-datatable-even">< td class="yui3-datatable-col-name yui3-datatable-cell ">John A. Smith< /td >

1236 Some Street San Francisco CA< /td >< /tr >

//……further rows continue//

Now let’s look into its code snippet:

package Chromedriver;

    import java.util.List;

    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.chrome.ChromeDriver;

    public class Tagname_Row_data {

        public static void main(String[] args) {
            // TODO Auto-generated method stub


            //Setting up chrome using chromedriver by setting its property
            System.setProperty("webdriver.chrome.driver", "Path of chromeDriver"); 

            //Opening browser
            WebDriver driver= new ChromeDriver() ;

            //Opening window tab in maximize mode
            driver.manage().window().maximize();

            //Opening application
            driver.get("[https://alloyui.com/examples/datatable](https://alloyui.com/examples/datatable)");

            //locating the number of rows of the table
            List<WebElement> rows= driver.findElements(By.tagName("tr"));

            //Printing the size of the rows
            System.out.print(rows.size());

            //Closing the driver
            driver.close();




        }

    }

Snapshot of Console output:

Android Emulator For IOS- Test your mobile applications before going live. All you need is a computer with internet connection

Conclusion

As you can see, how I have used the tag name locator in Selenium on different scenarios. You can also use the tag name locator in combination with attribute value using XPath or CSS selectors. When it comes to other scenarios of locating elements, I may not suggest you using the tag name locator in Selenium but of-course scenarios mentioned above can really come in handy. Usage of tag name locator in Selenium may be limited, however, if you wish to be a proficient automation tester, then understanding how to use tag name locator and when to use it becomes very critical.

Making The Move With ID Locator In Selenium WebDriver

sadhvisingh1 — Fri, 26 Apr 2019 11:36:49 +0000

If you are beginning with Selenium, you may be unsure about what to do and how to do it? In my opinion, I find locators to be the best step to start brushing or learning Selenium. Locators are the foundation of building your Selenium Script. With the use of locators, one can locate the element on the web page. Not just locating an element is important but making sure it’s fast and accurate is equally important. One such locator is the ID locator in Selenium WebDriver that does this business.

Check out what WebDriver is, its features, how it works, best practices, and more in this WebDriver tutorial.

When To Opt For ID Locator In Selenium WebDriver?

Using ID Locator in Selenium WebDriver is the fastest and the most reliable among all the locators. ID’s are supposed to be unique to each element, making the ID locator as a dependable choice. Since browsers do not make it mandatory for ID to be unique thereby making developers take leverage of it and may lead to ID’s either not present as part of an attribute or autogenerated, or not unique to a page. Due to the mentioned issues, it may require switching to other locators.

You can check out other articles around different CSS locator in Selenium that helps in locating elements through various ways:

Using ID Locator in Selenium WebDriver

Here I will be sighting an example of LambdaTest login page example for ‘Remember me’ functionality. Below is the screenshot of the same.

Referencing the below DOM structure for ‘Remember me’ element:

<input type="checkbox" name="remember" id="remember" class="form-check-input">

As you can see, the above tag has multiple attributes, one of which is the ID locator.

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

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

Hey! Test your web and mobile apps on Android online Emulator. Ensure your apps are compatible across latest and legacy Android operating systems, devices, and browsers.

Syntax For ID Locator In Selenium WebDriver

In order to use the ID Selenium locator to find an element via ID we use the below syntax:

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

Now, let’s try to incorporate this into a real-time example. In this example, I will be using the facebook login page, to login using ID locators for interacting with the WebElement object.

Below is the DOM structure for email, password and log in field of the facebook login page:

<input type="email" class="inputtext" name="email" id="email" value="[sadhvisingh9049@gmail.com](mailto:sadhvisingh9049@gmail.com)" data-testid="royal_email">



<input type="password" class="inputtext" name="pass" id="pass" data-testid="royal_pass">



<input value="Log In" aria-label="Log In" data-testid="royal_login_button" type="submit" id="u_0_8">

Referenced is the screenshot highlighting the same:

Delving Into Code For ID Locator In Selenium WebDriver

The below code will help you relate with the demonstration of ID locator in Selenium WebDriver in a better way. Let’s dig into it:

package Chromedriver;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class Locator_By_ID {

public static void main(String[] args) {
        // TODO Auto-generated method stub

//Setting up chrome using chromedriver by setting its property
        System.setProperty("webdriver.chrome.driver", "Pth of chrome driver"); 

        //Opening browser
        WebDriver driver= new ChromeDriver() ;

        //Opening window tab in maximize mode
        driver.manage().window().maximize();

        //Opening application
        driver.get("[https://www.facebook.com](https://www.facebook.com)");

        //Locating the email field element via ID tag and storing it in the webelement
        WebElement email_field=driver.findElement(By.id("email"));

        //Entering text into the email field
        email_field.sendKeys("[sadhvisinghXXXX@gmail.com](mailto:sadhvisinghXXXX@gmail.com)");

        //Locating the password field element via ID tag and storing it in the webelement
        WebElement password_field=driver.findElement(By.id("pass"));

        //Entering text into the password field
        password_field.sendKeys("xxxxxxxxx");

        //Locating the login button to login to the application
        WebElement login_button=driver.findElement(By.id("u_0_2"));

        //Clicking on the 'login' button
        login_button.click();

}

}

Referenced is the screenshot highlighting the same:

Hey! Test your web and mobile apps on online Android Emulator. Ensure your apps are compatible across latest and legacy Android operating systems, devices, and browsers.

Delving Into Code For ID Locator In Selenium WebDriver

The below code will help you relate with the demonstration of ID locator in Selenium WebDriver in a better way. Let’s dig into it:

package Chromedriver;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class Locator_By_ID {

public static void main(String[] args) {
        // TODO Auto-generated method stub

//Setting up chrome using chromedriver by setting its property
        System.setProperty("webdriver.chrome.driver", "Pth of chrome driver"); 

        //Opening browser
        WebDriver driver= new ChromeDriver() ;

        //Opening window tab in maximize mode
        driver.manage().window().maximize();

        //Opening application
        driver.get("[https://www.facebook.com](https://www.facebook.com)");

        //Locating the email field element via ID tag and storing it in the webelement
        WebElement email_field=driver.findElement(By.id("email"));

        //Entering text into the email field
        email_field.sendKeys("[sadhvisinghXXXX@gmail.com](mailto:sadhvisinghXXXX@gmail.com)");

        //Locating the password field element via ID tag and storing it in the webelement
        WebElement password_field=driver.findElement(By.id("pass"));

        //Entering text into the password field
        password_field.sendKeys("xxxxxxxxx");

        //Locating the login button to login to the application
        WebElement login_button=driver.findElement(By.id("u_0_2"));

        //Clicking on the 'login' button
        login_button.click();

}

}

Another Example For Demonstrating The ID Locator

Let’s cater to another similar example for ID where we are making a booking through Airbnb:

Below is the DOM structure for the same:

Location field:

<input type="text" class="_up0kwni" aria-autocomplete="list" aria-describedby="Koan-magic-carpet-koan-search-bar__description" aria-expanded="false" autocomplete="off" autocorrect="off" spellcheck="false" id="Koan-magic-carpet-koan-search-bar__input" name="query" placeholder="Anywhere" role="combobox" value="Delhi">

Check-in:

<input type="text" class="_14fdu48d" data-veloute="checkin_input" id="checkin_input" name="checkin" placeholder="dd-mm-yyyy" value="Wed, 10th Apr" readonly="" <="" pre="">

<b>Checkout:</b>







<pre> <input type="text" class="_14fdu48d" data-veloute="checkout_input" id="checkout_input" name="checkout" placeholder="dd-mm-yyyy" value="Sun, 14th Apr" readonly="">

Search Button:

<button type="submit" class="_z5x9aua" aria-busy="false"><span class="_ftj2sg4">Search</span></button>

Now let’s dig into the code snippet:

package Chromedriver;

import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class ID_Location {

public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

//Setting up chrome using chromedriver by setting its property
        System.setProperty("webdriver.chrome.driver", "path of chromedriver"); 

        //Opening browser
        WebDriver driver= new ChromeDriver() ;

        //Opening window tab in maximize mode
        driver.manage().window().maximize();

        //Opening application
        driver.get("[https://www.airbnb.co.in/](https://www.airbnb.co.in/)");

        //Locate element via ID for Location field and store it in Webelement
        WebElement Location= driver.findElement(By.id("Koan-magic-carpet-koan-search-bar__input"));

        //Input value in Location field
        Location.sendKeys("Delhi", Keys.ENTER);

        //Locate element via ID for Check-in field and store it in Webelement
                WebElement Check_in= driver.findElement(By.id("checkin_input"));

                //Click on Check_in field to select the date
                Check_in.click();

                //Select the desired date
                driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='MagicCarpetSearchBar']/div[2]/div/div/div/div[2]/div/div/div/div/div/div[2]/div[2]/div/div[2]/div/table/tbody/tr[2]/td[3]")).click();

              //Locate element via ID for Check-out field and store it in Webelement
                WebElement Check_out= driver.findElement(By.id("checkout_input"));

                //Click on Check_out field to select the date
                Check_out.click();

                //Wait for date selection
                Thread.sleep(3500);

                //Select the desired date
                driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='MagicCarpetSearchBar']/div[2]/div/div/div/div[3]/div/div/div/div/div/div[2]/div[2]/div/div[2]/div/table/tbody/tr[2]/td[4]")).click();

                //Locating the submit button and clicking on it
                driver.findElement(By.tagName("button")).click();

                //close the driver
                driver.close();



    }

}

Hey! Test your web and mobile apps on online Emulator Android. Ensure your apps are compatible across latest and legacy Android operating systems, devices, and browsers.

It’s A Wrap!

ID’s are the most reliable and easiest way to locate an element owing to its uniqueness. So if you are starting with Selenium WebDriver, ID’s can be your best friend. But make sure you to hit on the right track while locating them, and be aware of duplicate IDs or auto-generated ones. Happy testing! 🙂

How To Use Name Locator In Selenium Automation Scripts?

sadhvisingh1 — Wed, 10 Apr 2019 14:42:50 +0000

Locators in Selenium play an important role in the life of an automation engineer. Depending on how skilled you are in locating an element is directly proportional to the stability and efficiency of your automation testing with Selenium. There are multiple ways of utilizing locators in Selenium to find an element on a page but deciding the right one, does the business. In this article, I will be referencing on how to use by.name locator in Selenium automation scripts.

If you’re new to Selenium and wondering what it is then we recommend checking out our guide — What is Selenium?

Understanding The DOM(Document Object Model)

The Document Object Model(DOM) defines the structure of a webpage which constitutes of various tag elements and their corresponding attributes. For example, below shows the LambdaTest login page:

In the screenshot above, we are trying to locate the ‘email’ field. The DOM structure of the email field is displayed below:

< input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg" >

The attributes for the above DOM structure are:

Type
Name
Value
Placeholder
Required
Autofocus
Class

Hey! For selenium testing tool, click here. Test on Selenium Grid Cloud of 3000+ Desktop & Mobile Browsers.

Understanding The By.name Locator In Selenium

By.name Selenium locator is used to identify the elements of a webpage. This attribute can be mentioned as part of multiple tags like < input >, < button >, < select > etc. Unlike ID, this may or may not be unique to a page. A webpage may contain multiple tags with the same By.name attribute value. In such a case, if your intent is to select your desired element, the By.name locator in Selenium may not be the correct choice.

A key point to note is when you tend to select an element with a desired name attribute value, it will select the first element it encounters. You may come across another scenario, where you wish to select elements with the same name attribute value, in this case, the By.name locator in Selenium may work using the findElements syntax. I will show both scenarios example in the code as we go ahead in the article.

In order to locate element via the By.name locator in Selenium, we use the below command:

driver.findElement(By.name(“Element NAME”));

Let’s dig into the code snippet to understand the usage of the By.namelocator.

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

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

How to choose the right automation testing tool? Check out this blog to select the right tools for automation testing.

Test Scenario 1 For By.nameLocator In Selenium

In the below code example, we are logging on to the LambdaTest platform. Here we will locate the ‘email’ and ‘password’ field using the By.name attribute.

package Chromedriver;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class Name_Locator {

public static void main(String[] args) {

        //Setting up chrome using chromedriver by setting its property
        System.setProperty("webdriver.chrome.driver", "C:\\Users\\navyug\\workspace\\Lambdatest\\src\\Chromedriver\\chromedriver.exe"); 

        //Opening browser
        WebDriver driver= new ChromeDriver() ;

        //Opening window tab in maximize mode
        driver.manage().window().maximize();

        //Opening application
        driver.get("[https://accounts.lambdatest.com/login](https://accounts.lambdatest.com/login)");

        //Locating the email field element via Name tag and storing it in the webelement
        WebElement email_field=driver.findElement(By.name("email"));

        //Entering text into the email field
        email_field.sendKeys("[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)");

        //Locating the password field element via Name tag and storing it in the webelement
        WebElement password_field=driver.findElement(By.name("password"));

        //Entering text into the password field
        password_field.sendKeys("LoremIpsum");

        //Clicking on the login button to login to the application
        WebElement login_button=driver.findElement(By.xpath("//button[text()='LOGIN']"));

        //Clicking on the 'login' button
        login_button.click();

        //Closing the window
        driver.close();
        }
}

Hey! Perform live-interactive cross browser testing on Safari for windows here.

Test Scenario 2 For By.name Locator In Selenium

In the below code example, post-logging in, under the automation section of the menu bar, we have a page where two web elements containing radio button have the same By.name attribute value as radio. We intend to switch between these two buttons. Below is the DOM structure for both those elements:

&lt; div class="TimelineTab_viewRadioButton__18Zf3"&gt;
&lt; label &gt;<input type="radio" name="radio" value="build_view"><span class="TimelineTab_labelText__2DZ00 TimelineTab_font14__2K4jw">Build View</span>
<!-- label-->&lt; label&gt;&lt; input type="radio" name="radio" value="test_view"&gt;
<span class="TimelineTab_labelText__2DZ00 TimelineTab_font14__2K4jw">Test View<!-- span--><!-- label -->&lt; /div &gt;</span>

The code snippet below:

package Chromedriver;

import java.util.List;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class Multiple_Name_Values {

public static void main(String[] args) {

//Setting up chrome using chromedriver by setting its property
                System.setProperty("webdriver.chrome.driver", "C:\\Users\\navyug\\workspace\\Lambdatest\\src\\Chromedriver\\chromedriver.exe"); 

                //Opening browser
                WebDriver driver= new ChromeDriver() ;

                //Opening window tab in maximize mode
                driver.manage().window().maximize();

                //Maintaining an implicit wait for the entire application in case of throttling network or DOM not loaded
                driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);
                //Opening application
                driver.get("[https://accounts.lambdatest.com/login](https://accounts.lambdatest.com/login)");

                //Locating the email field element via Name tag and storing it in the webelement
                WebElement email_field=driver.findElement(By.name("email"));

                //Entering text into the email field
                email_field.sendKeys("[sadhvisingh24@gmail.com](mailto:sadhvisingh24@gmail.com)");

                //Locating the password field element via Name tag and storing it in the webelement
                WebElement password_field=driver.findElement(By.name("password"));

                //Entering text into the password field
                password_field.sendKeys("LoremIpsum");

                //Clicking on the login button to login to the application
                WebElement login_button=driver.findElement(By.xpath("//button[text()='LOGIN']"));

                //Clicking on the 'login' button
                login_button.click();

                //Click on the Automation menu link on the sidebar
                driver.findElement(By.xpath("//*[[@id](http://twitter.com/id)='app']/header/aside/ul/li[4]/a/span")).click();

//Finding all the webelement on the page with name attribute value as radio
                List<webelement> radio_button=driver.findElements(By.name("radio"));

                //Click on the test view of the element
                radio_button.get(1).findElement(By.xpath("//span")).click();

                //Closing the driver
                driver.close();
    }
}
</webelement>

As you can see in the above two examples, we have used the By.name locator in different ways. One was via findElement and the other was via findElements command. In one, our target was to locate a single element while in the other we located multiple elements with the same By.name and attempted to switch to one of those elements. So as per defined need and business, we can use the By.name locator. By.name locators are easy to use and maintain, the trick lies in identifying their right usage.

You can also read my previous article where I have explained the demonstration of all the locators in Selenium WebDriver. I will also be writing down a series of dedicated articles to demonstrate thorough usage of each locator of Selenium in detail. Stay tuned! 🙂

Locators In Selenium WebDriver With Examples

sadhvisingh1 — Fri, 05 Apr 2019 10:44:34 +0000

Locators in Selenium are one of the most powerful commands. Its ideally the building block of the Selenium automation scripts. It helps locate the GUI elements through which multiple user actions can be performed. These are one of the important parameters for scripting, and if they end up to be incorrect or brittle, they may lead to script failure. A good scripting base foundation requires elements to be located appropriately. For this, we have multiple locators in Selenium WebDriver. Below is the list of these locators of Selenium WebDriver :

ID
Name
Linktext
Partial Linktext
Tag Name
Class Name
DOM Locator
CSS Selector
Xpath

Using the above locators in Selenium WebDriver you can locate elements through “findElement/findElements” syntax. I will be demonstrating that for each locator of Selenium, in detail below. However, before we dig in to locate these elements through the above ways, let’s see how to find elements in DOM(Document object model).

Steps To Find Element In DOM:

Open the target application and click on F12 or right click and select inspect.

A console window would open known Developer tools.

A section name as ‘Element’ would be default opened. This is where we locate elements through. To the left most, you can observe a mouse icon. As you hover on it, it would state ’select an element in the page to inspect it’. Click on it and navigate to the element you wish to locate to. As you click on the element you want to locate, the DOM would be highlighted for that element, something like below:

This is it, the selected row in the DOM is the context from where you need to fetch your values from, in the example above, the highlighted DOM value is:

 <a href="https://accounts.lambdatest.com/register" target="_blank">Free Sign Up</a>

Now you can choose the tagname i.e ‘a’ and text i.e ‘Free Sign Up’ to locate your element.

The above technique will be used throughout my article for demonstrating the CSS locators in Selenium WebDriver . Now, we look on how to find locators in Selenium WebDriver.

ID Locator In Selenium

This is the most common way of locating elements considering that they are unique to each element in the DOM(Document Object Model). Based on the World Wide Web Consortium(W3C) ID’s should be unique to elements and hence are considered as the fastest and safest method to locate element. But unfortunately, developers may or may not follow this rule as browsers do allow bypassing this rule. Specifically, in the case of a table or list the ID’s may populate incrementally or dynamically depending upon the data, which leads to locating such elements through other means.

Below is an example of Makemytrip showcasing how ‘login’ field is been located via ID:

Below is the DOM structure of it:

<div class="inputM make_relative"> <input id="ch_login_email" type="text" required=""> <span class="inputM__highlight"></span> <span class="inputM__bar"></span> <label>Email/Mobile number</label> <div class="ch-error-msg ch-clearfix" id="ch_login_email_error" style="display:none"> <p class="o-i-error-icon"></p> <span class="ch-flL"> <span class="o-i-error-symbol"></span> </span> <span class="ch-flL ch-error-innertxt"></span> </div> </div>The syntax for locating via

Syntax for locating Username is= driver.findElement(By.id("ch_login_email"))

In case no such value matches with id, NoSuchElementException will be raised.

Name Locator In Selenium

An element can be defined via multiple attributes, one such is Name. Name locator in Selenium WebDriver can also be used to locate elements like ID locator. They may or may not be unique on a page, having multiple elements. In case there are elements with the same name, then the locator selects the first element with that name on the page.

In case no such name matches with the defined attribute value, NoSuchElementException will be raised

Below is a screenshot of the DOM for Lambdatest, where the ID locator name on sign up page for email field is highlighted.

Below is the DOM structure of it:

<input type="email" placeholder="Work Email*" name="email" value="" class="form-control sign-up-input-2 ">

Below is the syntax for locating the email field via name

Syntax for locating Email is =driver.findElement(By.name("email"));

Link Text Locator In Selenium

Elements can be located via link text as in hyperlinks. In a scenario where there are multiple links of the same text, the first link would be selected. Link texts are prefixed with the anchor text and this locator can only be used for anchor tag.

Below is an example of lambdatest homepage showcasing selection of the blog link on the header. The DOM below shows the highlighted element:

Below is the DOM structure of the same:

<a href="https://www.lambdatest.com/blog" target="_blank">Blog</a>

The syntax for selecting the linktext=driver.findElement(By.linkText("Blog"));

Usually this locator is used to check for navigation flow.

Partial Link Text Locator In Selenium

Locating element via Partial Link Text works similar to normal Link Text locator. The reason of using the Partial Link Text locator in Selenium WebDriver over the Link Text Locator is only due to the reason when you have a long linktext and you intent to use only partial text to perform further actions on it. Sometimes the intent of using this can also be to locate multiple links on a page with a common partial text.

Below is a snapshot of the LambdaTest DOM highlighting the element with the link name as ‘start testing’, here we are locating the link with partial text as ‘testing’.

Below is the DOM structure of it:

<a href="https://accounts.lambdatest.com/register" target="_blank">START TESTING <i class="fa fa-arrow-circle-right" aria-hidden="true"></i></a>

The syntax for locating via partial link text is: driver.findElement(By.PartialLinkText("Testing"));

Tag Name Locator In Selenium

As the name specifies, this css locator in Selenium WebDriver is used to identify elements with Tag names like div tag, a tag etc. A common example of this usage could be locating all links on your homepage and verifying whether they are functional or broken.

The below syntax for locating all links on Lambdatest home:

driver.findElements(By.tagName(a));

Class Name Locator In Selenium

Class Name locator helps in locating element defined through the class attribute. Below is an example of Lambdatest login DOM snapshot where login field is located via class name.

Below is the DOM structure:

<input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

Syntax of locating element via class name:

driver.findElement(By.className("form-control mt-3 form-control-lg "));

DOM Locator In Selenium

In document object model(DOM) we locate element in terms of DOM model. As explained above we can identify element via ID and name through methods of the DOM like ‘getElementById’ and ‘getElementsByName’. The method getElementById will locate only one element at a time, whereas the other method is used to provide an array of elements located by that name. In order to access any specified element in case of an array of elements, we can use index.

The syntax used to access id and name through DOM is:

document.getElementById (“id”)

document.getElementsByNames (“name”)[index]

Below is the DOM structure of LambdaTest login page, where the intent is to locate the ‘remember me’ checkbox:

<input type="checkbox" name="remember" id="remember" class="form-check-input">

Example to access element via DOM ID is:

document.getElementById (“remember”)

document.getElementsByNames (“remember”)[0]

CSS Selector Locator In Selenium CSS Selector Locator In Selenium

Cascading style sheets are used to style your webpages and hence becomes one of the ways to locate your elements. If you are unable to access an element without ID or name, then CSS selector becomes one of the most obvious choices as compared to xpath.

Since multiple debates go around the corner for both of them, their usages for me depends on the complexity of the scenario, though majorly people prefer using CSS selector since those are faster as compared to xpath.

CSS Selectors can be located through various formats available:

Tag and ID
Tag and Class
Tag and Attribute
Tag, Class and Attribute
Matches (Starts with, Ends with, Contains)
Child elements

Tag and ID

To locate element via Tag and ID we use three components

Syntax: css=(Html tag )(#) (value of the ID attribute)

Html tag: It is used to provide the tag we wish to locate, example input tag.
# : This hash sign is used to represent the ID attribute. Keep in mind, when you wish to locate an element via ID through CSS selector then it required to have a hash sign on the same. For other attributes we need not use the hash sign.
Value of the ID attribute: This represents the value of the ID we are using the locate the element.

Below is the DOM part indicating the login field of Makemytrip.com

 <div class="inputM make_relative">
 <input id="ch_login_email" type="text" required=""> <span class="inputM__highlight"></span> <span class="inputM__bar"></span> <label>Email/Mobile number</label> <div class="ch-error-msg ch-clearfix" id="ch_login_email_error" style="display:none"> <p class="o-i-error-icon"></p> <span class="ch-flL"> <span class="o-i-error-symbol"></span> </span> <span class="ch-flL ch-error-innertxt"></span> </div> </div>

In order to locate element via CSS selector, the following command can be written as:

driver.findElement(By.cssSelector("input# ch_login_email "))

Tag and Class

This locator works like ID, only difference is in its format. We use dot while denoting the class attribute value rather than hash in case of class.

Syntax:

css=(HTML tag)(.)(Value of Class attribute)

The below DOM snapshot and code highlights the class attribute to be accessed:

<input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

driver.findElement(By.cssSelector("form-control mt-3 form-control-lg"))

Tag and Attribute

As the name specifies the element can be locate via tag name and its corresponding attribute defined with value. In case if multiple elements have the same tag and attribute, the first one will be selected.

Syntax:

css=(HTML Page)[Attribute=Value]

Using the below DOM structure, the following code will be used to locate the web element:

 <input type="phone" placeholder="Phone*" name="phone" value="" class="form-control sign-up-input-2 ">

driver.findElement(By.cssSelector("input[name= ‘phone’]"))

Tag, class and attribute

This locator is used in combination with class name and other attribute value.

Syntax:

css=(HTML tag>)(. )(Class attribute value)([attribute=Value of attribute])

Using the below DOM structure, to locate elements:

<button type="submit" class=" btn sign-up-btn-2 btn-block">Signup</button>

Syntax to locate element via class :

driver. findElement(By.cssSelector(“button. btn sign-up-btn-2 btn-block [type = submit]”))

Note: This combination can also be implied on ID. The only difference is to use hash rather than dot when using ID attribute and defining its ID value in place of class value.

Locating Elements via Matches

Selenium CSS selector,helps in matching multiple strings through the use of multiple patterns like ^, $, *. Below are quick details on the same:

Starts-With

This helps in locating element when we try to match elements with string that starts with a designated value

Syntax:

css=(HTML tag)([attribute^=start of the string])

Referencing below DOM structure to locate element:

<input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

driver.findElement(By.cssSelector("input[name^='em']"))

Ends-With

This helps in locating element when we try to match elements with string that ends with a designated value.

Syntax:

css=(HTML tag)([attribute$=end of the string])

Referencing below DOM structure to locate element:

<input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

driver.findElement(By.cssSelector("input[name$=’ail’]"))

Contains

This helps in locating element when we try to match elements with string that contains a designated value.

Syntax:

css=(HTML tag)([attribute*=partial string])

Using the same login DOM structure to locate element:

<input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

driver.findElement(By.cssSelector("input[class*=’control’]"))

Child Elements

With the use of child elements, we can locate elements inside other elements. This is helpful when trying to access data of a table or list of details etc.

Below is the DOM structure where I intent to access text written with ‘Screenshot’:

<ul class="overview-list">
<li class="automation">
 <span>Automation Test</span></li>
 <li class="realtime">
 <span>Realtime Test</span></li>
 <li class="screenshot">
 <span>Screenshot Test</span></li> 
<li class="responsive">
 <span>Responsive Test</span></li></ul>

In order to locate element, the following syntax would be used:

Css= tagname.class name li:nth-of-child(index of the referenced child which in our case is 3)

driver.findElement(By.cssSelector(“ul. overview-list li:nth-of-child(3)”);

Similarly in order to access responsive we can use, last-child reference as below:

Css= ul. overview-list li:last-child

driver.findElement(By.cssSelector(“ul. overview-list li:last-child”);

Note: Do check our blog on CSS Selectors in Selenium Automation Scripts to help you understand this CSS locator in Selenium WebDriver better.

XPath Locator In Selenium

Xpath helps in locating elements on the web page using XML expressions. The basic syntax used for using XPath as a CSS locator in Selenium WebDriver is:

Xpath: //tagname[@attribute=’value’]

Here tagname signifies the tag in the DOM structure you are targeting to, for example an input tag or anchor tag etc. Attributes are defined via prefix ‘@’ and their corresponding value. Different attributes like name, id, class etc can be used here. There are multiple ways through which xpath can be defined:

Standard Xpath
Using Contains
Using Xpath with AND & OR
Using starts-with
Using text in Xpath

Let’s take a quick look into their details:

Standard Xpath

This is like the one defined above in syntax.

A quick example is for the below DOM structure of LambdaTest I am referencing to:

<input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

Syntax of xpath is: //input[@name= ’email’]In order to locate element, it can be written as follows:

driver.findElement(By.xpath(“//input[@name= ’email’]”))

Contains

This works similar to CSS selector ‘contains’ symbol. It can be used when any element value changes dynamically and partially. For example, if value of login changes with the login text appended has been constant, then contains would be helpful in locating elements. Below is the referenced syntax of it:

Xpath: //tagname[contains(@attribute, ‘partial value of attribute’)]

Using the below DOM structure to locate the login field with class name:

 <input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

driver.findElement(By.xpath(“//input[contains(@class, ‘form-control’)]”))

Xpath using ‘AND’ & ‘OR’

These are used when we want to locate an element via two condition sets. In case of ‘AND’ both the conditions should be true and for ‘OR’ either of the two should be true.

Syntax using OR :

Xpath=//input[@id='login_1' OR @name='login’] Syntax using AND :

Xpath=//input[@id='login_1' AND @name='login’]

The below example highlights the login field DOM structure of Lamdatest using both the above ‘AND’ and ‘OR’ expressions:

 <input type="email" name="email" value="" placeholder="Email" required="required" autofocus="autofocus" class="form-control mt-3 form-control-lg">

driver.findElement(By.xpath(“//input[@type='email' OR @name='email’]))

driver.findElement(By.xpath(“//input[@type='email' AND @name='email’]))

Starts-with

This is again like the functionality of CSS selector. It helps in locating element that starts with a specified attribute value. Syntax used is:

Xpath=//tagname[starts-with(@attribute,'starting name of the attribute value')]

Using the below DOM structure to locate the password field of signup form of Lambdatest:

<input type="password" placeholder="Desired Password*" name="password" class="form-control sign-up-input-2 " aria-autocomplete="list">

driver.findElement(By.xpath(“//input[starts-with(@name,'pass')]”))

Text

It helps to locate element via xpath using exact text match. Sometimes we have tags containing text, which we wish to locate element through. Locating element through text can help us achieve this.

Syntax:

Xpath=//div[text()='Logged In']

Below is an example of Lambdatest DOM structure of sign-up page, where I am trying to locate the sign-up text on that page.

 <p class="signup-titel">SIGN UP</p>

Using above DOM structure, following is the use case of text:

driver.findElement(By.xpath(“//p[@text()=’ SIGN UP’]”))

Both CSS selector and Xpath are measured equally in terms of CSS locators in Selenium WebDriver. They both are useful with respect to complex scenarios. Choosing which one among the two is completely upon you and the scenario you opt to automate. The only key thing to remember is easy maintainability of your locators, this makes half of your job easier.

Best Practices For Using Locators In Selenium WebDriver

Keeping in mind which locator to choose is as important as ensuring you know all the locators. Certain best practices and rules have been laid down to ensure you make efficient use of locators in Selenium WebDriver. Listing few below:

Do not locate elements that depends on information which may change as they may make your locators easy to break and less maintainable.

This is one of the key rules that one needs to keep in mind while writing better automation code using locators in Selenium WebDriver. If locator is dependent on a single entity like for instance class, name, id etc which if changed may need to be repaired but in case of complex locators like By.XPath(“//div[@class=”class-form_6180″]/div[5]/h3”), it may lead to frequent breakage if any of the div’s changes or the class name etc. Try to make your locators in Selenium WebDriver precise and dependent on single entity than multiple. Only in case you do not have any option left, move to complex locators, but make sure the dependent elements have less likelihood of changing.

Ensure your locator In Selenium matches only the required information to be selected and not multiple other information present along with it.

This is contextual and depends upon your scenario. In case you wish to locate single element ensure it matches uniquely to only one element. It should never be the case, where there are multiple elements identified via locator and you opt to choose for the second or third selection. This can be a point of your script breakage, since if the page design changes or the assumed count on which the selected element appears changes, your locator will tend to break. So always make sure, your locator locates the exact match.

Secondly, if you are trying to look out for multiple matches (using ‘findElements’), ensure it matches all the desired elements you are looking out for.

While using locators in Selenium, do not locate elements that depend on auto-generated values.

When new to this business this is something we get into. Usually ID’s are auto generated and while locating them and using them in scripts could be problematic. Every time the script or page containing those ID’s are run they tend to change and make your scripts fail. The easiest solution to figure out whether they are auto generated or not is watching them through minimum 2 runs and identifying them through the prefix/post fixed number associated with it. In case they are changed or incremented, you can conclude those are auto generated and you look out for other ways to locate those elements.

While choosing locators of Selenium, do not use XPath or CSS Selector provided by the Dev Tools.

Yes, you read that right! Copying xpath or css selector from developer tools is something we believe is the easiest task to do, but believe me these are one of the problems that appears in the longer run, causing problems in the stability and readability of your scripts. Your browser providing you these values does not look out for meaningful XPath or CSS locators and give you complex ones, with multiple dependent factors, which I mentioned above may lead to frequent breakages. So even though this may look tempting and easier to do activity try refraining yourself from it.

These are some of the factors one should keep in mind while writing locators in Selenium WebDriver. The technique or strategy you use to locate elements can be any but make sure the above rules are fulfilled which helps to make your script easy to maintain and read. These locators in Selenium are the building blocks of your script, make sure they are correct and your road ahead on it is smoother and more focused towards other aspects of the functionality of your project as you automate them.

DEV Community: sadhvisingh1

Selenium Waits Tutorial: Guide to Implicit, Explicit, and Fluent Waits

Why Do We Need Selenium Waits?

Types of Selenium Waits For Page Load

Thread.Sleep() For Automation Testing with Selenium

Why Using Thread.Sleep() Is Not A Good Idea?

Implicit Wait For Automation Testing with Selenium

Explicit Wait For Automation Testing with Selenium

The Difference Between Selenium Waits: Explicit Vs Implicit

Fluent Wait For Automation Testing with Selenium

My opinion on Fluent Selenium Wait?

Role Of Selenium Waits for running automation Cloud Selenium Grid

The Final Verdict On Selenium Waits!

Handling Multiple Browser Tabs With Selenium Automation Testing

Getting Started With A Practical Scenario

Handling Tabs In Selenium Using The Window Handler Method

Handling Tabs In Selenium Using The Action Class

Executing Automation Testing With Selenium On Cloud

Conclusion

Using Selenium Webdriver For Full Page Screenshots

Automated Selenium Test Scripts for Taking Screenshots of Viewable Area

Capturing Full Webpage Screenshot using Automated Selenium Test Scripts

Taking Screenshot of Desired Web Element Using Selenium WebDriver

Taking Full Page Automated Screenshots On Cloud

Find Elements With Link Text & Partial Link Text In Selenium

Using Link Text In Selenium To Locate An Element

Using Partial Link Text In Selenium To Locate An Element

How To Select The Right Link Text When You Have Multiple Match Results?

Selenium Java Tutorial – Class Name Locator In Selenium

Getting Started With Class Name Locator In Selenium With Example

One Of The Most Common Exceptions For Class Name Locator In Selenium

How To Locate An Element When We Have Multiple Elements Sharing The Same Class Name?

Example For Class Name Locator In Selenium For Multiple Elements With A Similar Class Name

What Did We Learn About Class Name Locator In Selenium?

Selenium Java Tutorial – How To Test Login Process?

Some Prerequisites For Selenium Java Tutorial

Basic Steps For A Selenium Test Case

Let’s Automate Selenium Login With Java

1. Create A Selenium WebDriver Instance

2. Configure Your Browser If Required

3. Navigate To The Required URL

4. Locate The HTML Element

5. Perform Action On The Located HTML Element

6. Verify & Validate The Action

Moving Selenium Tests On Cloud

How Was That?

Complete Guide For Using XPath In Selenium With Examples

So, What Is XPath In Selenium?

Types Of XPath In Selenium

Absolute XPath Example In Selenium

Relative XPath Example In Selenium

Writing Complex & Dynamic XPath In Selenium Through Various Methods

Using Basic XPath

Using ‘OR’ & ‘AND’

Using Contains()

Using Starts-With()

Using Text()

Using Index

Using Chained XPath In Selenium

XPath axes

Conclusion

Related Articles

Complete Guide On TestNG Annotations For Selenium WebDriver

So, What Is An Annotation?

@test

@BeforeTest

@AfterTest

@BeforeMethod

@AfterMethod

@BeforeClass

@AfterClass

@BeforeSuite

@AfterSuite

@BeforeGroups

@AfterGroups

TestNG Report:

Console Output:

Execution Sequence Of Annotations In TestNG For Selenium

Attributes Used With TestNG Annotations

Console Output: