How to Integrate Selenium With TestNG for Automated Testing

by

Have you ever felt stuck in a never-ending cycle of manual testing when it comes to Selenium Testing? Have you ever longed for a magic wand that could help you execute your tedious and repetitive software testing tasks in a jiffy? If you are a software tester or a developer, you must have experienced the pain of executing manual tests repeatedly, right? It’s like being stuck in the movie Groundhog Day, where every day feels the same, and you can’t break the cycle. What if we tell you there’s a solution that can break this never-ending cycle?

Enter TestNG, the software testing framework that can help you with your automated testing needs. TestNG is like the Harry Potter of software testing, a powerful tool that can help you automate your tests with ease. And when it’s integrated with Selenium, the automation becomes even more magical. It’s like Batman and Robin, where Selenium is Batman, and TestNG is Robin, the trusty sidekick that makes Batman’s job easier.

In this blog, we’ll show you how to integrate Selenium with TestNG, step by step. We’ll guide you through the process, from setting up your environment to running your first automated test. By the end of this blog, you’ll be equipped with the knowledge to break the cycle of manual testing and embrace the magic of automation. Get ready for some excitement because we’re about to jump right in! So, sit back, relax, and grab some snacks!

Selenium testing

What is TestNG?

TestNG is a software testing framework that has gained immense popularity among software testers and developers in recent years. It’s like the ultimate personal assistant that helps you manage and automate your testing tasks like a pro. It’s like having a Swiss Army Knife in your toolbox, a tool that can do multiple jobs effortlessly.

With TestNG, you can quickly write and execute automated tests, and it can handle different types of tests like unit, functional, and integration tests with excellent efficiency. It’s like a superhero that can tackle any challenge thrown its way, like Superman, who can handle any problem with ease.

But what sets TestNG apart from other testing frameworks is its powerful features, like the ability to handle dependencies, group tests, parallel execution, and generate reports.

In short, TestNG is a versatile and powerful testing framework that can help you become a testing superhero. So put on your cape, and explore TestNG!

TestNG Features

TestNG is a powerful testing framework that offers a range of features to facilitate automated testing. One of its vital features is the ability to generate HTML reports that are concise and easily understandable, overcoming the limitations of WebDriver in generating such reports.

In addition, TestNG allows for the grouping of multiple test cases, prioritization of test cases, and the execution of only failed cases. This enables efficient management of test cases and ensures that important cases are executed first.

TestNG’s support for cross-browser testing, data parameterization, and parallel testing is a significant advantage for automated testing. This allows for efficient and effective testing of multiple tasks simultaneously, leading to increased productivity.

Another advantage of TestNG is its easy-to-understand annotations, which enable control of the sequence of execution in automation scripts without the need for a static main method. This feature allows for better organization and management of scripts, making automation testing more manageable and scalable.

TestNG’s inherent ability to handle uncaught exceptions is a further advantage, preventing sudden test termination and ensuring a smoother testing process.

In short, TestNG is like a team of superheroes that can help you manage your testing needs with ease and finesse. So why not put them to work and see your testing process soar to new heights?

Installation and Setup of TestNG in Selenium

Integrating Selenium with TestNG is like having a loyal sidekick who can help you manage your testing needs. TestNG’s robust features complement Selenium’s automation capabilities, making it a match made in testing heaven. Let’s integrate Selenium with TestNG to make your testing process more efficient, and stress-free!

1. Installing TestNG in Eclipse

Installing TestNG in Eclipse is a straightforward process that can help streamline your Selenium testing. Here’s a simple guide to help you get started.

  1. Firstly, launch Eclipse and click on the Help option from the menu bar.
  2. Next, select the Eclipse Marketplace option. It’s like browsing a marketplace for the latest and greatest tools to enhance your testing game.
  3. Once the Eclipse Marketplace window is open, head to the Search tab and type in “TestNG.” If it’s already installed, you’ll see the “Installed” button, indicating that you’re good to go. If not, click the “Install” button to start the installation process.
  4. On the following window, make sure the TestNG checkbox is selected, and then click Confirm.
  5. After the installation is complete, it’s recommended that you restart Eclipse to ensure that the changes take effect correctly.
  6. Finally, verify that the installation was successful by right-clicking on any project and checking whether the TestNG menu appears.

If it does, you’re all set to create a TestNG class and start automating your testing. It’s like having all the necessary tools at your fingertips to tackle any testing challenge that comes your way.

2. Create TestNG Project In Eclipse

Creating a TestNG project in Eclipse can seem like a daunting task, but with the proper guidance, it’s a piece of cake! Let’s get started.

  1. First things first, launch Eclipse and get ready to create a new TestNG project. Navigate to File > New > Java Project, and voila! You’re on your way.
  2. Next, give your project a catchy name like ‘Super Awesome TestNG Project’ and hit the Next button.
  3. On the next screen, you’ll see the Java settings for your new project. Now, this is where things get interesting. To make your project a TestNG project, navigate to the Libraries tab and click on the Add Library button.
  4. From there, select TestNG from the list of libraries and click Next. You’ll see TestNG added to your project libraries, and you’re almost there!
  5. Click on the Finish button and boom! Your Java project has been created successfully.

You can easily find your project by clicking on the Package Explorer button on the left panel, and you’re all set to start integrating Selenium with TestNG for automated testing.

3. Add Selenium JAR files To Selenium TestNG Project

Adding Selenium JAR files to your TestNG project is as simple as 1-2-3!

  1. First, you need to right-click on your TestNG project “Super Awesome TestNG Project”. Next, select Properties from the context menu that appears.
  2. In the Properties window, you need to select the JAR files for Selenium API. These JAR files are a part of the Selenium Java language bindings, which you should have already downloaded and saved on your system. Browse to the location where you have saved the Selenium Java language bindings and select all the JAR files, including the ones inside the libs folder.
  3. Once you’ve selected all the JAR files, click on the Apply and Close button to add them to your project.

That’s it! You should now see a folder for Referenced Libraries in your Super Awesome TestNG Project. This folder will contain all the Selenium JAR files that you just added. With these JAR files in place, you’re now ready to start automating your tests with Selenium and TestNG.

4. Writing the first test case using Selenium and TestNG

Let’s start by writing our first test case using Selenium and TestNG. Below is a sample code for a test case to open a web page using ChromeDriver:

package com.example.tests;

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.chrome.ChromeDriver;

import org.testng.annotations.Test;

public class FirstTest {

@Test

public void testGoogleSearch() {

// Set the path of the ChromeDriver executable

System.setProperty(“webdriver.chrome.driver”, “path/to/chromedriver.exe”);

// Launch Chrome browser

WebDriver driver = new ChromeDriver();

// Navigate to Google

driver.get(“https://www.google.com/”);

// Verify the title of the page

if(driver.getTitle().equals(“Google”)) {

System.out.println(“Test Passed!”);

} else {

System.out.println(“Test Failed”);

}

// Close the browser

driver.close();

}

}

This test case uses the ChromeDriver to launch the Chrome browser, navigates to Google, verifies page’s title, and closes the browser. The ‘@Test’ annotation is used to indicate that this is a TestNG test case.

You can modify this code to suit your specific testing needs.

5. Run your Selenium TestNG Script

To run your Selenium TestNG script, you can follow these simple steps:

  1. Go to your test script and right-click on it.
  2. From the menu, select “Run As” and then “TestNG Test”.
  3. Your script will now be executed, and you can monitor the progress in the console.
  4. Once the script has completed running, you can view the test results either in the TestNG reports or in the console itself.
  5. If there are any errors or failures in your test script, TestNG will highlight them in the results, allowing you to identify and fix the issues easily.

By following these steps, you can easily run your Selenium TestNG script and get valuable insights into the performance and functionality of your web application.

Upgrade Your Selenium Game with LambdaTest – The Ultimate Cloud Selenium Grid!

Testing

Hey there, it looks like you’re doing great with your Selenium TestNG scripts, but let’s take things up a notch! Imagine you’re the Iron Man of Selenium testing, trying to save the world from slow and inefficient test runs.

So, you’ve got your Selenium WebDriver on your local machine, but what if you need to run your tests on multiple browsers and operating systems? That’s where a Selenium Grid comes in, and let’s be honest, running tests in parallel is way cooler than doing them one at a time. It’s like assembling the Avengers and taking on the bad guys all at once!

But hold on a second, building and maintaining your own Selenium Grid can be a hassle, like trying to build your own suit of armor in a cave. That’s why you should consider using a cloud-based Selenium Grid, like LambdaTest. Think of it as your own Jarvis, always there to help you out with your testing needs.

With LambdaTest, you can run your Selenium TestNG scripts on over 3000 real browsers and operating systems, so you won’t have to worry about which ones are new in the market. Plus, you can save the money you would have spent on building and maintaining your in-house Selenium infrastructure and spend it on something more exciting, like a trip to Asgard.

Here’s an example test case using Selenium and TestNG that can be run on the LambdaTest platform:

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.remote.DesiredCapabilities;

import org.openqa.selenium.remote.RemoteWebDriver;

import org.testng.Assert;

import org.testng.annotations.AfterMethod;

import org.testng.annotations.BeforeMethod;

import org.testng.annotations.Test;

import java.net.MalformedURLException;

import java.net.URL;

public class LambdaTestExample {

public WebDriver driver;

public String username = “YOUR_USERNAME”;

public String accessKey = “YOUR_ACCESS_KEY”;

public String gridURL = “@hub.lambdatest.com/wd/hub”;

@BeforeMethod

public void setUp() throws MalformedURLException {

DesiredCapabilities capabilities = new DesiredCapabilities();

capabilities.setCapability(“browserName”, “Chrome”);

capabilities.setCapability(“version”, “91.0”);

capabilities.setCapability(“platform”, “WIN10”);

capabilities.setCapability(“build”, “LambdaTestSampleApp”);

capabilities.setCapability(“name”, “LambdaTestJavaSample”);

capabilities.setCapability(“network”, true);

capabilities.setCapability(“visual”, true);

capabilities.setCapability(“video”, true);

capabilities.setCapability(“console”, true);

capabilities.setCapability(“selenium_version”,”4.0.0″);

capabilities.setCapability(“timezone”, “UTC+05:30”);

// Launch remote browser and set it as the current thread

driver = new RemoteWebDriver(new URL(“https://” + username + “:” + accessKey + gridURL), capabilities);

}

@Test

public void lambdatestExampleTest() {

// Navigate to LambdaTest homepage

driver.get(“https://www.lambdatest.com/intl/en-in”);

// Verify title of the page

String pageTitle = driver.getTitle();

Assert.assertEquals(pageTitle, “Cross Browser Testing Tool | Browser Compatibility Testing – LambdaTest”);

// Assert that there is a CTA button on the page

boolean ctaButtonExists = driver.getPageSource().contains(“Start Free Trial”);

Assert.assertTrue(ctaButtonExists);

}

@AfterMethod

public void tearDown() {

// Close the browser

driver.quit();

}

}

To run this test case on the LambdaTest platform, you will need to replace “YOUR_USERNAME” and “YOUR_ACCESS_KEY” with your actual LambdaTest username and access key, respectively. You will also need to update the DesiredCapabilities object to specify the desired browser, version, and platform you want to run the test.

Lamba test

Once you’ve made those changes, you can upload the test case to the LambdaTest platform and run it on any of the 3000+ browser/OS combinations available.

Happy testing!

Wrap-up

Alright, let’s wrap up this journey of integrating Selenium with TestNG for automated testing!

So, we’ve learned how to create a TestNG project in Eclipse, add Selenium JAR files to it, and write our first test case using Selenium and TestNG. And, of course, we’ve also talked about the importance of using a cloud Selenium Grid like LambdaTest for parallel testing and scaling our test suites.

Now, as a software tester, you might feel like you’re in a never-ending battle against bugs and glitches. But fear not, for we have the power of Selenium and TestNG on our side!

And just like how the Avengers had to work together to defeat Thanos, we, too need to collaborate and integrate different tools and technologies for efficient and effective testing. Integrating Selenium with TestNG is just one of the many ways to do that.

So, don’t forget to keep your eyes peeled for new and improved ways to optimize your testing process! And who knows, you might even become the Tony Stark of software testing someday!