Test Automation using JUnit Annotations and Selenium

JUnit is a widely used testing framework for Java applications and is crucial in automation testing. When combined with Selenium WebDriver, JUnit allows testers to write structured and efficient test cases for web applications.

By leveraging JUnit annotations, testers can define test execution flow, manage test dependencies, and improve automation reliability.
This article explores key JUnit annotations and their role in enhancing Selenium test automation.

JUnit Capabilities

JUnit, introduced in 2002, is a widely used framework for writing Java test cases. With the release of JUnit 5, the framework has evolved to support modern testing needs, making it a go-to choice for automation testing.

Key features of JUnit 5 include:

• Open-source and modular architecture, offering better flexibility.
• Annotations to define test execution flow efficiently.
• Assertions to validate expected outcomes.
• Test grouping and dynamic testing for improved test organization.
• The extension model allows custom extensions for additional functionality.
• Better integration with Selenium for UI test automation.
• Backward compatibility to support tests written in older JUnit versions.

Fundamentals of JUnit Annotations

JUnit annotations play a crucial role in structuring and managing test execution. These annotations help define initialization steps, test cases, and post-test cleanup, ensuring a well-organized and efficient testing process.

• JUnit allows multiple tests to be grouped within a single test class.
• Test cases often require setup before execution and clean up afterward.
• Annotations in JUnit help manage pre-test configurations, test execution, and post-test operations.
• These annotations streamline the testing process, ensuring better organization and efficiency.

Common JUnit Annotations

Here are some common JUnit Annotations:

• @BeforeClass: Runs once before all tests in a class, ideal for initializing resources like WebDriver.
• @AfterClass: Executes once after all tests and is used for closing resources or cleanup tasks.
• @Before: Runs before each test, commonly used for pre-test setups like opening a specific webpage.
• @After: Executes after each test, which is useful for logging or restoring test conditions.
• @Test: Marks a method as a test case where assertions validate expected outcomes.
• @RepeatedTest: Introduced in JUnit 5, runs the same test multiple times, useful for cache validation or performance testing.

Selenium Capabilities

Selenium is a widely used open-source tool for automating browser interactions and testing web applications across multiple browsers. It enables developers to simulate user actions and supports multiple programming languages, including Java, Python, .NET, PHP, and Ruby.

Key Features of Selenium:

• Provides plugins for popular IDEs, making adoption easier.
• Supports cross browser and cross-platform testing for better compatibility.
• Offers a robust open-source community, ensuring continuous improvements and extensive support.
• Includes a complete testing suite with Selenium Grid for distributed testing and WebDriver for multi-browser automation.

What is JUnit in Selenium?

Through JUnit, developers can run unit tests on each software component before it goes to testers. Tests are run quickly, and failed tests are listed separately for easy debugging.

• Besides manual testing, JUnit is preferred for automation as it can also be used along with the Selenium WebDriver to automate tests for web applications.
• It provides a unique way to write structured, short, and better test cases.
• JUnit uses annotations to create different test scripts for various purposes using several methods.

JUnit Selenium Testing with Annotations

The ideal automation suite comprises a robust testing framework, a leading test automation framework, and a comprehensive set of real devices. Their strengths can be combined to build scalable multi-browser, multi-device test cases that deliver reliability to application development.

• A JUnit test annotation is meta-data that JUnit provides to determine what action should be performed by a method.
• It allows developers to organize, group, and maintain test cases. Selenium allows integration with JUnit.
• To combine the two, one has to write Selenium test code within JUnit test classes.

This Selenium JUnit tutorial delves into JUnit annotations, Selenium test cases, and how they can be combined to achieve automated website testing.

Run Selenium Tests for Free

Attributes to JUnit Annotations

Some JUnit annotations accept parameters called attributes that are used to provide more details to the test being run. Selenium requires these parameters to apply restrictions like timeout, the number of times a test has to be executed, etc. Let’s look at an example and explore some of these annotation attributes.

@Test(timeout=5000)
@RepeatedTest(6)
public void test_search()
{ 
// code to search something using the search_bar
driver.findElement(By.id("search_bar")).sendKeys("Browserstack automation testing"); 
driver.findElement(By.name("search_btn")).click();

String first_result = driver.findElementByXPath("/html/body/result").getText(); 

assertEquals(first_result,”Testing and annotations”);
}

In the code snippet, two annotations @Test and @RepeatedTest being used. Each of them has been passed an attribute. The first annotation @Test has been set with the timeout (in milliseconds) attribute, which tells Selenium to set the timeout to 5 seconds. Similarly, the second annotation @RepeatedTest takes in an integer which tells JUnit to run the test called “test_search” 6 times.

Passing attributes to some annotations is optional, while for others, it’s mandatory. In the example above, the @Test annotation attribute is optional, whereas the attribute to @RepeatedTest is mandatory.

JUnit Selenium Test: A Complete Example using Annotations

Look at a simple automation test that ties up everything discussed so far. This example intends to perform the following actions:

• Submitting some details for the Sign-Up page
• Testing successive page loads and checking if page reload succeeded

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
public class JUnitSeleniumTest {

public static RemoteWebDriver driver = null;
Public static DesiredCapabilities capabilities = null;

@Before
public void initializeSelenium() {
capabilities = new DesiredCapabilities()
capabilities.setCapability("browserName", "chrome");
capabilities.setCapability("version", "70.0");
capabilities.setCapability("platform", "win10");

driver = new RemoteWebDriver(new URL("https://google.com), capabilities);

}

@Test
public void signUp() {
driver.findElement(By.id("Name")).sendKeys("John Doe");
driver.findElement(By.id("Email")).sendKeys("johndoe@testemail.com");
driver.findElement(By.id("City")).sendKeys("Bangalore”);
driver.findElement(By.name("submit_btn")).click();

String result = driver.findElementByXPath("/html/body/response").getText();

assertEquals(result,”Sign-up Successful”);
}

@Test
@RepeatedTest(3)
public void reloadPage() {

driver = new RemoteWebDriver(new URL("https://google.com), capabilities);
assertEquals(homeUrl, "https://google.com/");
}

@AfterClass
public void cleanUp() {

driver.quit(); // close the browser
}
}

Let’s summarize the test class above. The test class consists of two tests, each annotated with @Test. The code starts by initializing Selenium Webdriver and annotating it with @Before on the initializeSelenium() method. This ensures that Selenium capabilities are initialized before running each test.

JUnit Testing on BrowserStack

To ensure seamless functionality across different browsers and devices, cross-browser testing is essential. Every browser renders web elements differently, which can lead to inconsistencies in user experience.

Instead of setting up and maintaining an in-house testing infrastructure, teams can leverage BrowserStack Automate for scalable testing in real user conditions.

With BrowserStack, teams can:

• Run JUnit Selenium tests on a real device cloud with 3,500+ real browsers and devices.
• Automate test execution across multiple environments without infrastructure setup.
• Identify and fix cross-browser issues early to enhance web compatibility.

Talk to an Expert

Useful Resources for JUnit

• How to run JUnit 4 Test Cases in JUnit 5
• JUnit Testing Tutorial: JUnit in Java
• How to write JUnit test cases
• How to Ignore a Base Test Class in JUnit
• How to run JUnit Parameterized Test in Selenium
• Understanding JUnit assertions for Selenium Testing with Examples
• Test Automation using JUnit Annotations and Selenium
• How to create JUnit Test Suite? (with Examples)
• Unit Testing in Java with JUnit
• JUnit vs NUnit: Framework Comparison
• JUnit Vs TestNG

Conclusion

JUnit annotations streamline test automation by defining pre-test setups, test executions, and post-test cleanups efficiently. When combined with Selenium, they enable robust, scalable, and repeatable test cases for web applications.

To ensure seamless cross-browser functionality, running JUnit Selenium tests on real devices and browsers is crucial. Using cloud-based platforms like BrowserStack allows teams to execute automated tests effortlessly, ensuring high-quality web experiences across all environments.

Run Selenium Tests on Real Device Cloud