Parameterization in TestNG

  

What is Parameterization in TestNG?

The theory of Parameterization in TestNG is a mechanism for running the same test logic multiple times with different input values (parameters). This technique eliminates the need to duplicate test code when you want to verify a feature across various scenarios, datasets, or environments. Parameterization allows you to externalize the data used by the test methods.

Parameterization in TestNG allows us to run the same test with different sets of data. It helps in data-driven testing, where test data is separated from the test logic. TestNG provides multiple ways to do this, mainly:

• @Parameters annotation (via testng.xml)

• @DataProvider annotation (method-based)

1. Using @Parameters (from XML)

This approach uses parameters defined externally in the TestNG XML configuration file, suitable for configuration-based data.

(a) Goal: To pass environment-specific or global configuration values into a test without hardcoding them.

(b) Mechanism:

• Parameters are defined using the <parameter> tag within the testng.xml file (at the Suite, Test, or Class level).
• The test method uses the @Parameters annotation to declare the name of the configuration parameter it expects to receive.

(c) The Contract: TestNG reads the XML file, finds the defined parameter value, and passes it directly to the annotated test method.

(d) Benefit: This is ideal for parameters that don't change per execution but vary per deployment environment, such as a browser name (chrome, firefox), a base URL, or a database connection type. The test method runs only once, using the configured value.

Pass parameters directly from the testng.xml file to your test methods.

Steps for Parameterization in TestNG

• Define parameters in testng.xml

• Use @Parameters in the test method

• Use @BeforeMethod or @Test to access them

Java Code for parameterization in TestNG

Below is Test class with name loginTest() having two parameters user and pass. These parameters get values from @Parameters annotations variables: username and password. these variables username and password gets values from parameter tag in testng.xml. We can see below in testng.xml file

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class ParameterExample {

    @Test
    @Parameters({"username", "password"})
    public void loginTest(String user, String pass) {
        System.out.println("Username: " + user);
        System.out.println("Password: " + pass);
    }
}

testng.xml:

It contains two parameters username and password having name and values as defined below

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="Suite">
  <test name="LoginTest">
    <parameter name="username" value="admin" />
    <parameter name="password" value="admin123" />
    <classes>
      <class name="ParameterExample" />
    </classes>
  </test>
</suite>

2. Using @DataProvider




The most flexible and common theoretical approach uses the @DataProvider annotation.

(a) Goal: To separate the test data from the test logic.

(b) Mechanism: A dedicated method is marked with the @DataProvider annotation. This method is theoretically responsible for generating and returning multiple sets of input data (e.g., a list of usernames and passwords, or a list of numbers to test a calculator function).

(c) The Contract: The main test method (marked with @Test) declares that it will accept parameters and specifies the name of the Data Provider it needs. TestNG acts as the mediator:

• It calls the Data Provider method first.
• For every set of data returned by the provider, TestNG instantiates and runs the @Test method once.

(d) Benefit: This creates Data-Driven Testing, which is crucial for efficiency and coverage, as one test method can cover hundreds of cases simply by supplying different data.

We can pass multiple sets of data to a test method from a @DataProvider method.

Below is the Java Code for @DataProvider in TestNG:

Below, there is a getData() which is annotated with @DataProvider annotation having name as 'loginData'. 

In test method that is loginTest, We have to include dataprovider method with dataProvider attribute with name of dataprovider method.

Like below we have, @Test(dataProvider = "loginData")

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class DataProviderExample {

    @Test(dataProvider = "loginData")
    public void loginTest(String username, String password) {
        System.out.println("Testing with Username: " + username + ", Password: " + password);
    }

    @DataProvider(name = "loginData")
    public Object[][] getData() {
        return new Object[][] {
            {"admin", "admin123"},
            {"user", "user123"},
            {"guest", "guest123"}
        };
    }
}

Suggested Posts:

1. Groups in TestNG
2. Annotations in TestNG
3. TestNG Asserts
4. First Script in TestNG
5. Read Excel Data by Data provider

TestNG Dependent Tests

 

The concept of Dependent Tests in TestNG is a mechanism used to establish a sequential, conditional relationship between test methods. It ensures that a specific test method (the dependent) is executed only if one or more other test methods (the dependencies) have successfully completed their run.

The Core Concept: Conditional Execution

• Goal: To prevent subsequent tests from running when a critical prerequisite test has failed.
• Mechanism: You use a specific TestNG setting (an annotation parameter) on a test method to declare which other test methods it depends on.

What Are Dependent Tests in TestNG?

TestNG allows you to create test dependencies, meaning you can specify that:

• A test method depends on another method or group
• If the depended method fails, is skipped, or is not run, the dependent method will also be skipped

Types of Dependencies in TestNG

Type	Annotation Attribute	Description
Method Dependency	dependsOnMethods	Test method runs only if other method(s) pass
Group Dependency	dependsOnGroups	Test method runs only if group(s) pass

If a test case execution depends upon successful execution of other test cases, then in this condition we can use attribute 'dependsOnMethods' in @Test annotation.

Example Java Code for method dependency

Below is the Test class contains 4 test cases, 

• Here, login() depends upon successful execution of launchApp() test case. if launchApp will execute successfully then only login() will execute otherwise, it will be skipped.
• searchproduct(), depends upon successful execution of login() test case. if login() will execute successfully then only searchproduct() will execute otherwise, it will be skipped.
• logout(), depends upon successful execution of searchproduct() test case. if searchproduct() will execute successfully then only logout() will execute otherwise, it will be skipped.

import org.testng.annotations.Test;

public class DependentTestExample {

    @Test
    public void launchApp() {
        System.out.println("App launched successfully.");
    }

    @Test(dependsOnMethods = "launchApp")
    public void login() {
        System.out.println("Logged in successfully.");
    }

    @Test(dependsOnMethods = {"login"})
    public void searchProduct() {
        System.out.println("Product searched successfully.");
    }

    @Test(dependsOnMethods = {"searchProduct"})
    public void logout() {
        System.out.println("Logged out successfully.");
    }
}

Output

App launched successfully.
Logged in successfully.
Product searched successfully.
Logged out successfully.

Note: If a Test Fails then searchProduct() and logout() will be skipped.

Example Java Code for group dependency

Below there are two test cases comes in a group that is database. If all the test cases present in group database will be executed successfully then only generateReport() will execute.

import org.testng.annotations.Test;

public class GroupDependencyExample {

    @Test(groups = "database")
    public void connectToDB() {
        System.out.println("Database connected.");
    }

    @Test(groups = "database")
    public void fetchData() {
        System.out.println("Data fetched from DB.");
    }

    @Test(dependsOnGroups = "database")
    public void generateReport() {
        System.out.println("Report generated using DB data.");
    }
}

Optional Attributes

Attribute	Description
alwaysRun = true	Run test even if dependency fails
enabled = false	Disable the test
dependsOnMethods	Declare method dependencies
dependsOnGroups	Declare group dependencies

Example of attribute: alwaysRun




alwaysRun attribute always executes test cases. Below sendEmail() testcase has attribute alwaysRun, which means even if dependent test case fails then also this testcase sendEmail() will execute.

@Test(dependsOnMethods = "login", alwaysRun = true)
public void sendEmail() {
    System.out.println("Email sent (even if login fails).");
}

Suggested Posts:

1. Groups in TestNG
2. TestNG Annotations
3. TestNG Asserts
4. First Script in TestNG
5. Read Excel Data by Data provider

How to Test a PUT API by Rest Assured

What is a PUT API?

• PUT is an HTTP method used to update an existing resource on the server.
• It can also be used to create a resource if it doesn’t exist, but typically it’s for updates.
• The client sends the complete updated data to the server at a specified URL (endpoint).
• Idempotent: Calling the same PUT request multiple times will have the same effect as calling it once.

Example scenario:

• Suppose you have a user with id = 5.
• A PUT request to /users/5 with new data (like updated name and job) will update the user’s information on the server.

How to Test a PUT API in Rest Assured

• Set the Base URI: Define the server address where your API is hosted.
• Specify the Endpoint: Use the URL of the resource you want to update.
• Prepare the Request Body: Create a JSON object containing the updated data (like new name, job, or other attributes).
• Send PUT Request: Send the PUT request along with the JSON body to the server.
• Validate Response:

Status Code: Usually 200 OK or 204 No Content.
Response Body: Check if it contains the updated data or confirmation.
Headers: Verify content type, server info, etc.

• Optional: You can perform a GET request afterward to ensure that the resource has been updated correctly.

To test a PUT API using Rest Assured in Java, you'll follow these steps:

Steps to test PUT API using Rest Assured

• Add dependencies (Maven or Gradle)
• Set the Base URI
• Create the JSON request body using JSONObject
• Send PUT request using given()
• Validate the response

The endpoint we'll use:
https://reqres.in/api/users/2 — This updates user with ID 2.

Maven Dependency

<dependencies>
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>5.3.1</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.json</groupId>
        <artifactId>json</artifactId>
        <version>20230227</version>
    </dependency>
</dependencies>

Java Code using Rest Assured & JSONObject

import io.restassured.RestAssured;
import io.restassured.response.Response;
import org.json.JSONObject;

import static io.restassured.RestAssured.given;

public class PutApiTest {

    public static void main(String[] args) {

        // Step 1: Set Base URI
        RestAssured.baseURI = "https://reqres.in/api";

        // Step 2: Create JSON body using JSONObject
        JSONObject requestBody = new JSONObject();
        requestBody.put("name", "Himanshu");
        requestBody.put("job", "Software Engineer");

        // Step 3: Send PUT request and get the response
        Response response = given()
                .header("Content-Type", "application/json")
                .body(requestBody.toString())
                .when()
                .put("/users/2")
                .then()
                .statusCode(200)  // Verifying status code
                .extract()
                .response();

        // Step 4: Print response
        System.out.println("Response Body:");
        System.out.println(response.getBody().asPrettyString());
    }
}

Code Explanation:

Line	Purpose
RestAssured.baseURI	Sets the base server endpoint
JSONObject	Builds the request payload
given().header().body()	Prepares the request with header & body
.put("/users/2")	Sends PUT request to /users/2
.statusCode(200)	Asserts response code is 200 OK
.response()	Extracts full response
.asPrettyString()	Converts raw response to formatted JSON string

Response:

Put respond with status code of 204 or 200, that means API executes successfully and performed update operation.

{
    "name": "Himanshu",
    "job": "Software Engineer",
    "updatedAt": "2025-07-28T13:48:32.054Z"
} 

           

Suggested Posts:

1. Test Digest Auth by RestAssured
2. How to extract Response in Rest Assured by JSONPath
3. Test OAth2 in RestAssured
4. Validate Request and Response in POJO by RestAssured
5. How to Test Basic Authentication in RestAssured