How To Perform Data-Driven API Automation Testing With REST Assured Using Iterator And TestNG

|

In modern software development, APIs (Application Programming Interfaces) form the backbone of communication between systems. Ensuring that APIs behave correctly under various inputs is critical, and this is where data-driven API automation testing becomes essential. Instead of writing repetitive test cases for each input, data-driven testing allows you to execute the same test logic with multiple datasets, improving efficiency, coverage, and maintainability.

When combined with REST Assured, TestNG, and the use of an Iterator, data-driven testing becomes highly flexible and scalable. REST Assured simplifies API testing in Java, TestNG provides a robust testing framework, and Iterators allow dynamic feeding of test data.

This article provides a comprehensive guide on how to perform data-driven API automation testing using REST Assured with Iterator and TestNG, including detailed coding examples and best practices.

What is Data-Driven API Testing?

Data-driven testing is a testing methodology where test scripts are executed multiple times using different input datasets. Instead of hardcoding values in your test cases, you externalize the data (e.g., from arrays, Excel, JSON, or databases) and feed it into your tests.

Key benefits include:

  • Increased test coverage
  • Reduced code duplication
  • Easier maintenance
  • Better scalability

For API testing, this means validating endpoints with multiple request payloads, parameters, and expected responses.

Why Use REST Assured with TestNG?

REST Assured is a Java library specifically designed for testing REST APIs. It provides a domain-specific language (DSL) that makes writing API tests simple and readable.

TestNG complements REST Assured by offering:

  • Data providers
  • Test configuration annotations
  • Parallel execution
  • Detailed reporting

When combined, they create a powerful framework for API automation testing.

Understanding Iterator in TestNG DataProvider

TestNG allows supplying test data using the @DataProvider annotation. While arrays and two-dimensional objects are commonly used, an Iterator provides more flexibility.

Why use Iterator?

  • Handles large datasets efficiently
  • Supports dynamic data generation
  • Avoids loading all data into memory at once

The return type of a DataProvider using Iterator is:

Iterator<Object[]>

Each Object[] represents a set of parameters for a single test execution.

Project Setup

Before diving into the implementation, ensure your project has the following dependencies (using Maven):

<dependencies>
    <!-- REST Assured -->
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>5.3.0</version>
    </dependency>

    <!-- TestNG -->
    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>7.8.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Basic API Test Using REST Assured

Before implementing data-driven testing, let’s look at a simple API test:

import io.restassured.RestAssured;
import io.restassured.response.Response;
import org.testng.annotations.Test;

public class BasicAPITest {

    @Test
    public void getUserTest() {
        Response response = RestAssured
                .given()
                .baseUri("https://reqres.in")
                .when()
                .get("/api/users/2");

        response.then().statusCode(200);
        System.out.println(response.asString());
    }
}

This test sends a GET request and validates the response.

Implementing Data-Driven Testing Using Iterator

Now let’s extend this approach using a DataProvider with an Iterator.

Creating DataProvider with Iterator

import org.testng.annotations.DataProvider;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestDataProvider {

    @DataProvider(name = "userData")
    public Iterator<Object[]> getUserData() {

        List<Object[]> data = new ArrayList<>();

        data.add(new Object[]{1, 200});
        data.add(new Object[]{2, 200});
        data.add(new Object[]{3, 200});
        data.add(new Object[]{999, 404});

        return data.iterator();
    }
}

Explanation:

  • Each Object[] contains test parameters
  • First value: user ID
  • Second value: expected status code

Writing Data-Driven API Test

import io.restassured.RestAssured;
import org.testng.annotations.Test;

public class DataDrivenAPITest {

    @Test(dataProvider = "userData", dataProviderClass = TestDataProvider.class)
    public void validateUserAPI(int userId, int expectedStatusCode) {

        RestAssured
                .given()
                .baseUri("https://reqres.in")
                .when()
                .get("/api/users/" + userId)
                .then()
                .statusCode(expectedStatusCode);

        System.out.println("Test executed for User ID: " + userId);
    }
}

What happens here:

  • Test runs multiple times
  • Each run uses different user IDs
  • Validates expected status codes

Using Iterator with POST Request Payloads

Data-driven testing is especially useful for POST requests.

DataProvider for POST Payload

@DataProvider(name = "createUserData")
public Iterator<Object[]> createUserData() {

    List<Object[]> data = new ArrayList<>();

    data.add(new Object[]{"John", "Engineer"});
    data.add(new Object[]{"Alice", "Manager"});
    data.add(new Object[]{"Bob", "Developer"});

    return data.iterator();
}

POST API Test Example

import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import org.testng.annotations.Test;

import java.util.HashMap;
import java.util.Map;

public class PostAPITest {

    @Test(dataProvider = "createUserData", dataProviderClass = TestDataProvider.class)
    public void createUserTest(String name, String job) {

        Map<String, String> requestBody = new HashMap<>();
        requestBody.put("name", name);
        requestBody.put("job", job);

        RestAssured
                .given()
                .baseUri("https://reqres.in")
                .contentType(ContentType.JSON)
                .body(requestBody)
                .when()
                .post("/api/users")
                .then()
                .statusCode(201);

        System.out.println("User created: " + name);
    }
}

Enhancing Data-Driven Testing with External Data

Instead of hardcoding data, you can fetch it from:

  • Excel files
  • JSON files
  • Databases

Example using JSON (simplified concept):

public Iterator<Object[]> getJsonData() {

    List<Object[]> data = new ArrayList<>();

    data.add(new Object[]{"Michael", "Tester"});
    data.add(new Object[]{"Sara", "Analyst"});

    return data.iterator();
}

You can extend this by parsing JSON files using libraries like Jackson or Gson.

Best Practices for Using Iterator in API Testing

  1. Keep Data Separate
    Store test data in separate classes or files.
  2. Use Meaningful Data Sets
    Include both valid and invalid scenarios.
  3. Avoid Large In-Memory Lists
    For huge datasets, consider streaming data instead.
  4. Parameterize Everything
    URLs, headers, payloads, and expected results.
  5. Combine with Assertions
    Validate response body, headers, and schema—not just status codes.

Common Pitfalls to Avoid

  • Hardcoding values inside tests
  • Using static datasets only
  • Ignoring negative test cases
  • Overloading DataProviders with too much logic
  • Not validating response content

Advantages of Using Iterator in Data-Driven API Testing

  • Efficient memory usage
  • Dynamic test data generation
  • Better handling of large datasets
  • Improved test scalability
  • Cleaner and more modular code

Conclusion

Data-driven API automation testing is a crucial practice in modern quality assurance, especially in environments where APIs must handle a wide range of inputs and scenarios. By leveraging REST Assured, TestNG, and Iterators, testers can build highly efficient, scalable, and maintainable test frameworks.

REST Assured simplifies the complexity of API interactions with its intuitive DSL, making it easier to write and understand tests. TestNG adds powerful features such as DataProviders, annotations, and reporting, which enhance test organization and execution control. The use of Iterators within DataProviders introduces an additional level of flexibility, allowing dynamic and memory-efficient handling of test data.

Throughout this article, we explored how to:

  • Build basic API tests using REST Assured
  • Implement data-driven testing using TestNG
  • Use Iterators to feed multiple datasets
  • Handle both GET and POST requests
  • Structure clean and reusable test code

The real strength of this approach lies in its adaptability. Whether you are testing a simple API endpoint or a complex microservices architecture, data-driven testing ensures that your test coverage is broad and your scripts remain maintainable. By externalizing data and separating it from logic, teams can easily update test scenarios without modifying core test code.

Moreover, incorporating negative scenarios and diverse datasets helps uncover edge cases that might otherwise go unnoticed. This leads to more robust APIs and higher confidence in production deployments.

As systems grow in complexity, manual testing becomes insufficient. Automation, combined with intelligent data handling through Iterators, empowers teams to execute large volumes of tests quickly and reliably. It also integrates seamlessly into CI/CD pipelines, enabling continuous testing and faster feedback cycles.

In conclusion, mastering data-driven API testing with REST Assured, TestNG, and Iterators is not just a technical skill—it is a strategic advantage. It allows teams to deliver high-quality APIs with confidence, reduce defects, and accelerate development cycles. By following the practices and examples outlined in this guide, you can build a strong foundation for scalable and efficient API automation testing.