1. Introduction

This article is a quick, practical introduction to working with Selenium and writing tests with JUnit and TestNG.

2. Selenium Integration

In this section, we’ll start with a simple scenario – opening a browser window, navigating to a given URL and looking for some desired content on the page.

2.1. Maven Dependencies

In the pom.xml file, add the following dependency:

<dependency>
 <groupId>org.seleniumhq.selenium</groupId>
 <artifactId>selenium-java</artifactId>
 <version>3.4.0</version>
</dependency>

The latest version can be found in the Maven Central Repository.

2.2. Selenium Configuration

First, create a new Java class file called SeleniumConfig:

public class SeleniumConfig {

 private WebDriver driver;

 //...

}

Given we’re using a Selenium 3.x version, we have to specify the path of an executable GeckoDriver file (based on your OS) using a system property called webdriver.gecko.driver The latest version of the GeckoDriver may be downloaded from Github Geckodriver Releases.

Let’s now initialize the WebDriver in the constructor; we’ll also set 5 seconds as a time-out for WebDriver to wait for an element on the page to appear:

public SeleniumConfig() {
 Capabilities capabilities = DesiredCapabilities.firefox();
 driver = new FirefoxDriver(capabilities);
 driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
}

static {
 System.setProperty("webdriver.gecko.driver", findFile("geckodriver.mac"));
}

static private String findFile(String filename) {
 String paths[] = {"", "bin/", "target/classes"};
 for (String path : paths) {
 if (new File(path + filename).exists())
 return path + filename;
 }
 return "";
}

This configuration class contains a couple of methods that we will ignore for now, but we will see more about these in the second part of this series.

Next, we will need to implement a SeleniumExample class:

public class SeleniumExample {

 private SeleniumConfig config;
 private String url = "http://www.baeldung.com/";

 public SeleniumExample() {
 config = new SeleniumConfig();
 config.getDriver().get(url);
 }

 // ...
}

Here, we will initialize the SeleniumConfig and set the desired URL to navigate to. Similarly, we’ll implement a simple API to close the browser and get the title of the page:

public void closeWindow() {
 this.config.getDriver().close();
}

public String getTitle() {
 return this.config.getDriver().getTitle();
}

In order to navigate to the About section of baeldung.com, we need to create a closeOverlay() method that checks and closes the overlay on a homepage load. Thereafter, we navigate to the About Baeldung page using the getAboutBaeldungPage() method:

public void getAboutBaeldungPage() {
 closeOverlay();
 clickAboutLink();
 clickAboutUsLink();
}

private void closeOverlay() {
 List<WebElement> webElementList = this.config.getDriver()
 .findElements(By.tagName("a"));
 if (webElementList != null) {
 webElementList.stream()
 .filter(webElement -> "Close".equalsIgnoreCase(webElement.getAttribute("title")))
 .filter(WebElement::isDisplayed)
 .findAny()
 .ifPresent(WebElement::click);
 }
}

private void clickAboutLink() {
 Actions actions = new Actions(config.getDriver());
 WebElement aboutElement = this.config.getDriver()
 .findElement(By.id("menu-item-6138"));
 
 actions.moveToElement(aboutElement).perform();
}

private void clickAboutUsLink() {
 WebElement element = this.config.getDriver()
 .findElement(By.partialLinkText("About Baeldung."));
 element.click();
}

We can check if the required information is available on the displayed page:

public boolean isAuthorInformationAvailable() {
 return this.config.getDriver()
 .getPageSource()
 .contains("Hey ! I'm Eugen");
}

Next, we are going to test this class with both JUnit and TestNG.

3. With JUnit

Let’s create a new test class as SeleniumWithJUnitLiveTest:

public class SeleniumWithJUnitLiveTest {

 private static SeleniumExample seleniumExample;
 private String expectedTitle = "About Baeldung | Baeldung";

 // more code goes here...

}

We’re going to use the @BeforeClass annotation from org.junit.BeforeClass to do an initial setup. In this setUp() method, we are going to initialize the SeleniumExample object:

@BeforeClass
public static void setUp() {
 seleniumExample = new SeleniumExample();
}

In a similar way, when our test case finishes, we should close the newly opened browser. We’re going to do this with @AfterClass annotation – to clean up the settings when the test case execution has finished:

@AfterClass
public static void tearDown() {
 seleniumExample.closeWindow();
}

Please note the static modifier on our SeleniumExample member variable – because we need to use this variable in the setUp() and tearDown() static methods – @BeforeClass and @AfterClass can be invoked on static methods only.

Finally, we can create our full test:

@Test
public void whenAboutBaeldungIsLoaded_thenAboutEugenIsMentionedOnPage() {
 seleniumExample.getAboutBaeldungPage();
 String actualTitle = seleniumExample.getTitle();
 
 assertNotNull(actualTitle);
 assertEquals(expectedTitle, actualTitle);
 assertTrue(seleniumExample.isAuthorInformationAvailable());
}

This test method asserts that the title of the web page is not null and is set as expected. Besides that, we check that the page contains the expected information.

When the test runs, it simply opens the URL in Firefox and subsequently closes it after the title of the web page and content have been verified.

4. With TestNG

Let’s now use TestNG to run our test case/suite.

Note that if you’re using Eclipse, the TestNG plugin may be downloaded and installed from the Eclipse Marketplace.

First, let’s create a new test class:

public class SeleniumWithTestNGLiveTest {

 private SeleniumExample seleniumExample;
 private String expectedTitle = "About Baeldung | Baeldung";

 // more code goes here...

}

We’ll use a @BeforeSuite annotation from org.testng.annotations.BeforeSuite to instantiate our SeleniumExample class. The setUp() method will be launched just before the test suite is activated:

@BeforeSuite
public void setUp() {
 seleniumExample = new SeleniumExample();
}

Similarly, we’ll use the @AfterSuite annotation from org.testng.annotations.AfterSuite to close our opened browser once the test suite has been completed:

@AfterSuite
public void tearDown() {
 seleniumExample.closeWindow();
}

Finally, let’s implement our test:

@Test
public void whenAboutBaeldungIsLoaded_thenAboutEugenIsMentionedOnPage() {
 seleniumExample.getAboutBaeldungPage();
 String actualTitle = seleniumExample.getTitle();
 
 assertNotNull(actualTitle);
 assertEquals(expectedTitle, actualTitle);
 assertTrue(seleniumExample.isAuthorInformationAvailable());
}

After successful completion of the test suite, we find HTML and XML reports in the test-output folder of the project. These reports summarize the test results.

5. Conclusion

In this quick article, we’ve focused on a quick intro to writing Selenium 3 tests with both JUnit and TestNG.