Selenium is the first thing that comes to mind when planning to automate web application testing. It is not only open source but also a portable framework for web applications that supports Java, C#, Ruby, and Python. Choosing the correct language depends on the application under test, the supporting community, available test automation frameworks, usability, elegance, and seamless build integration.

Source: StackOverflow Survey 2022

As per StackOverflow 2022 Survey, Java is the fifth most popular back-end technology after JavaScript and SQL. Also, the Java testing framework can help a project in cost management by reducing the project’s over-expenditure or poor-quality management approaches. Going ahead, we will learn Selenium with Java to run automated tests.

Why do Developers learn Selenium with Java?

A good community of developers to create documentation and resolve issues has helped Java to become the most preferred language among application developers. Thus, writing Selenium test cases using Java has multiple benefits:

• Selenium supports Java. So, testers can leverage the active community of contributors and detailed documentation to write test cases
• Programs written in Java are faster than other popular languages like Python
• Java is more widely used in commercial applications than other programming languages like Python, so integrating Selenium tests is easier.

Eventually, choosing the correct language varies by project, organization, and individuals driving it. An essential criterion is to know the language in-depth when dealing with Selenium.

Run Selenium Tests with Java

Get Started with Selenium Automation Framework in Java

To learn Selenium with Java, one must combine the different components to start coding.

• Preferred for automated functional testing
• Compatible with multiple operating systems like Windows, Linux, Solaris, and macOS
• Supports multiple browsers like Chrome, Safari, IE, Edge, and Firefox
• Easy to integrate with Jenkins, Maven, and Docker to achieve a continuous testing approach.
• Tools like TestNG and JUnit further help structure the Selenium tests for easy maintainability and generating reports.

This section teaches how to set up and run a simple test through Selenium with Java bindings.

Pre-requisites for Setup and Configuration of Selenium in Java

The following components will get started with Java to run Automated Tests:

Step 1 – Install Java

• A Java development kit that includes the JRE (Java Runtime Environment) is required to write and run Java programs. JRE is a child of JDK, which comes along with JDK installation.
• Even for running applications that need the dependency of Java, one needs to install JDK.
• One such application is Eclipse IDE. Download Java, install it, and set the environment path.
• Once the path is set, verify the installation by typing java -version on the command prompt, which provides the details of the installed java version.

Step 2 – Install Eclipse

Eclipse is a Java development platform for writing and running code.

• Download Eclipse from their office page. Based on the OS, one can go with the required option.
• Once downloaded, extract the downloaded file. Once completed, one can see the eclipse .exe in the eclipse folder:

Step 3 – Selenium Client and WebDriver Language Bindings

Selenium Webdriver supports multiple languages, and each language has its client driver. As we are using Selenium with Java, we need to have Selenium Java Client Driver. One can download the client driver from the official Selenium website and check the multiple language client drivers provided.

Once downloaded, extract the contents of the downloaded file and then move to the next step, configuring Selenium Webdriver with Eclipse.

Step 4 – Configuring Selenium WebDriver With Eclipse

This is a vital step of starting with Selenium. To configure Eclipse with the Selenium Webdriver client,

Create a workspace Think of it just like any other folder, which stores all the scripts in one place. One can choose to create as many workspaces as required. Click on Launch to launch the workspace.

Create a package under this project by right-clicking on the ‘src’ folder

Once the package is created, right-click on the package and create a class. Once the class is created, go ahead with adding the Selenium Jars to the project.

To add the Selenium Jars, right-click on the project folder and go to Properties:

From the Properties window, navigate to ‘Java Build Path’ and click on ‘Add External JAR’s

Add the downloaded Selenium Jars and click on ‘Apply and Close.’ Selenium with Eclipse is configured now. Now Eclipse is ready to execute the first script.

Step 5 – Creating and Running the first test using Selenium and Java

• As the first test, we will write a script to open ‘google.com’ on the Chrome browser.
• To use Chrome, it is mandatory to have the driver executable. To download the driver executable, visit the Selenium website.
• One can download the executable file for specific browsers in the third-party driver browser section.

Post downloading, below is the code snippet to run the first test using Selenium and Java:

import java.util.concurrent.TimeUnit; import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; public class FirstTestInSelenium { 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(); //Applied wait time driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); //maximize window driver.manage().window().maximize(); //open browser with desried URL driver.get("https://www.google.com"); //closing the browser driver.close(); } }

In the code snippet above, we have used the Selenium keyword driver.get(“URL to open in browser”) to open URL in the desired browser. Other keywords like driver.close help to close the browser window as a cleanup part.

This was a quick starter to learn Selenium with Java and run Automated Tests. One should also consider the best practices while writing Selenium tests.

Best Practices while writing Selenium tests with Java

Some of the essential aspects to remember while writing Selenium tests with Java are:

• Using the Right Locator

Selecting locators are the building blocks of a Selenium script, and using the right one is critical. If incorrect locators are used, they tend to make the script flaky and unreliable. Using ‘ID’ and ‘Name’ locators is easy. They also provide faster execution and are more reliable than CSS and XPath.

• Incorporate the Test-Driven Script

When we talk about testing, it is about testing the software on multiple permutations and a combination of data. The same should be incorporated into the Selenium tests. Multiple data points should drive all Selenium tests, and a data-driven framework helps achieve this.

• Using the right Wait

For WebElements or a page to load, it is essential to give a specific halt time to the script and avoid failure. Selenium provides certain waits like ‘Implicit’ or ‘Explicit’ to achieve this. Both these waits halt the execution of the script until it finds the element.

The moment it finds the element, it continues the execution of the script. ‘Thread.sleep’, on the other hand, stops the execution for the defined period even when it finds the element in the defined interval. This increases the execution time of the script.

• Don’t make scripts specific to a Browser or Driver

Cross browser testing plays a vital role in testing. Depending on business needs, one may expect the scripts to run on multiple browsers or a specific browser. Selenium frameworks like TestNG provide annotations like @parameters, and JUnit provides annotations like @RunWith, which helps run tests on multiple browsers and corresponding drivers.

• Validate Tests using Assertions

The key to writing a good test is validating the tests. Just like when one writes a test case and mentions the actual and expected results, one needs to assert the tests in Selenium with the help of assertions provided in frameworks like TestNG and JUnit. If the assertions are not used, the testing process is incomplete, as it does not validate the test build’s correctness.

• Take Screenshots for Reporting

As a QA tester, it is essential to provide proof of testing for failures with supportive screenshots. The same stands for Automated Selenium testing. In case a test fails, it is vital to have corresponding screenshots. This helps explain the bug to the developer, who can debug it instantly.

Similarly, from a reporting perspective, to provide insight to the stakeholders, it is valuable to share reports with them, to establish the stability of the product. For this, Selenium provides a default reporting system with frameworks like TestNG and provides further customizations to them using TestNG listeners.

Conclusion

• Automation testing using Selenium with Java has made life easier for developers and testers. Being an open-source tool, it provides an opportunity to speed up the time of execution and to remove manual redundancy and human-prone errors.
• Learning Selenium with Java optimizes testing, especially in regression and cross-browser testing.
• With multiple plugins making their way into Selenium, it has resulted in making testing effortless and less time-consuming. Continuous Integrations with Jenkins and Maven have led to continuous testing models.

Cloud-based automated infrastructure like BrowserStack provides instant access to a Cloud Selenium Grid of 3000+ desktop browsers & real mobile devices. Join the testing infrastructure preferred by global teams and developers worldwide for Selenium automation with Java.

Run Selenium Tests with Java

ncG1vNJzZmivp6x7o77OsKqeqqOprqS3jZympmeXqralsY6snKWdnp7CrnnWoquhZZqWw6J5xaipZpmlqbyurdOem2aslajB