In the world of test automation, efficiency and reusability are key. Writing a test for each possible input is not scalable. That’s where Data-Driven Testing (DDT) steps in. When combined with the power of TestNG, DDT becomes incredibly simple and effective.
In this blog, we’ll walk through what DDT is, how to implement it using TestNG, and how it stacks up against other testing frameworks.
What is Data-Driven Testing
This testing approach focuses on running the same test case multiple times with different data inputs to validate various scenarios. We write our test once and execute it multiple times with different input values. This is extremely useful for:
Login forms
Registration tests
Validation scenarios
Boundary testing
Instead of writing multiple test cases, we just supply different data sets to one test method.
Imagine we're testing a login form. We need to verify that it works correctly with a bunch of different usernames and passwords – valid ones, invalid ones, edge cases, the whole shebang. Instead of writing a separate test for each combination, data-driven testing let’s feed all those inputs into a single test function. The test runs once for each set of data, making our test suite way more efficient and maintainable.
Why TestNG?
TestNG is a highly capable testing tool that brings flexibility and efficiency to Java test automation. It offers a bunch of cool features that make data-driven testing a breeze:
1. Annotations: TestNG uses annotations to define test methods, set up fixtures, and configure data providers. It simplifies the structure of our tests, making them easier to follow.
2. Data Providers: In TestNG, data providers are responsible for passing multiple sets of data to a single test method. They can return data from various sources, like CSV files, Excel spreadsheets, databases, or even hardcoded arrays.
3. Parameterization: TestNG makes it easy to pass data from our data providers to our test methods as parameters. This allows us to write generic test methods that can handle different sets of data.
4. Reporting: TestNG generates detailed reports that show us which tests passed, which failed, and how long each test took to run. This makes it easy to identify and fix problems in our code.
Getting Started with Data-Driven Testing in TestNG
Let’s jump into a simple example to demonstrate how DDT works with TestNG.
Step 1: Add TestNG to our Project
If We're using Maven, include this in our pom.xml:
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.8.0</version>
<scope>test</scope>
</dependency>
Step 2: Create a Data Provider Method
This method returns a 2D array of test data.
import org.testng.annotations.DataProvider;
public class TestData {
@DataProvider(name = "loginCredentials")
public Object[][] getCredentials() {
return new Object[][] {
{"admin", "admin123"},
{"user1", "pass1"},
{"user2", "pass2"}
};
}
}
Step 3: Link Test Method to DataProvider
import org.testng.annotations.Test;
public class LoginTest {
@Test(dataProvider = "loginCredentials", dataProviderClass = TestData.class)
public void loginTest(String username, String password) {
System.out.println("Attempting login with: " + username + " / " + password);
// Your login logic goes here
// Assertions can be added here to validate outcome
}
}
Advanced Data Sources for Data-Driven Testing with TestNG
TestNG's built-in @DataProvider is excellent for static data. But in real-world applications, we often need to pull data from external files like:
✅ Excel (.xls/.xlsx)
✅ CSV
✅ JSON
✅ Databases
Here we will take example with Excel.
Step 1: Create a excel file with name as Loginform.xlsx.
Step 2: Add required dependencies (Maven)
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>5.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>5.2.3</version>
</dependency>
Step 3: Excel Reader Utility
import org.apache.poi.ss.usermodel.*;
import java.io.FileInputStream;
public class ExcelUtils {
public static Object[][] getExcelData(String filePath, String sheetName) throws Exception {
FileInputStream fis = new FileInputStream(filePath);
Workbook workbook = WorkbookFactory.create(fis);
Sheet sheet = workbook.getSheet(sheetName);
int rowCount = sheet.getPhysicalNumberOfRows();
int colCount = sheet.getRow(0).getLastCellNum();
Object[ ][ ] data = new Object[rowCount - 1] [colCount];
for (int i = 1; i < rowCount; i++) {
Row row = sheet.getRow(i);
for (int j = 0; j < colCount; j++) {
data[i - 1][j] = row.getCell(j).toString();
}
}
workbook.close();
return data;
}
}
Step 4: Data Provider Using Excel
@DataProvider(name = "excelData")
public Object[][] getExcelTestData() throws Exception {
return ExcelUtils.getExcelData("src/test/resources/testdata.xlsx", "Loginform");
}
Conclusion: Using external data sources in TestNG let us build highly maintainable, scalable, and real-world test cases. Whether we're testing 1,000+ inputs from Excel or querying data directly from our staging database, TestNG can handle it with ease.