How to test DELETE in Rest Assured

HOME

In the last tutorial, I explained How to test PUT Request using Rest Assured. In this tutorial, I will automate a DELETE Request using Rest Assured. I will verify the status code, line of Status, and content of the Response.

To set up a basic Rest Assured Maven Project, click here and Gradle project, click here.

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.1</version>
      <scope>test</scope>
</dependency>
  
<dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>5.3.2</version>
      <scope>test</scope>
</dependency>

What is the DELETE Method?

An HTTP DELETE method is used to delete an existing resource from the collection of resources. The DELETE method requests the origin server to delete the resource identified by the Request-URI. On successful deletion of a resource, it returns  200 (OK) and 204 (No Content) status codes. It may return as 202 (Accepted) status code if the request is queued. To learn more about Rest API, please click here.

Below are the steps to test a DELETE Request using Rest Assured:

The steps to test the DELETE request are similar to any API request like GET, POST, or PUT. To know about the steps and various imports used in the below example in detail, please refer to the tutorial for POST Request.

Let’s see the existing details of an Employee ID 3 using Postman:

Let’s write DELETE request in REST Assured in Non BDD Format for id 3:-

import io.restassured.RestAssured;
import io.restassured.response.Response;
import io.restassured.response.ValidatableResponse;
import io.restassured.specification.RequestSpecification;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.equalTo;

public class Delete_NonBddDemo {

    RequestSpecification requestSpecification;
    Response response;
    ValidatableResponse validatableResponse;

    @Test
    public void deleteUser() {

        RestAssured.baseURI = "https://dummy.restapiexample.com/api";

        // Create a request specification
        requestSpecification = RestAssured.given();

        // Calling DELETE method
        response = requestSpecification.delete("/v1/delete/3");

        // Let's print response body.
        String resString = response.prettyPrint();

        /*
         * To perform validation on response, we need to get ValidatableResponse type of
         * response
         */
        validatableResponse = response.then();

        // Get status code
        validatableResponse.statusCode(200);

        // It will check if status line is as expected
        validatableResponse.statusLine("HTTP/1.1 200 OK");

        // Check response - message attribute
        validatableResponse.body("message", equalTo("Successfully! Record has been deleted"));

    }
}

Let’s write DELETE request in REST Assured in BDD Format:

import io.restassured.http.ContentType;
import io.restassured.response.ValidatableResponse;
import org.junit.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.equalTo;

public class Delete_BDDDemo {

    ValidatableResponse validatableResponse;

    @Test
    public void deleteUser() {
        
        validatableResponse = given()
                .baseUri("https://dummy.restapiexample.com/api/v1/delete/3")
                .contentType(ContentType.JSON)
                .when()
                .delete()
                .then()
                .assertThat().statusCode(200)
                .body("message", equalTo("Successfully! Record has been deleted"));

        System.out.println("Response :" + validatableResponse.extract().asPrettyString());

    }

}

.baseUri("https://dummy.restapiexample.com/api/v1/delete/3")
  .contentType(ContentType.JSON)
assertThat().statusCode(200)
.body("message", equalTo("Successfully! Record has been deleted"));

We are done. Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

How to test PUT Request using Rest Assured

HOME

In the last tutorial, I explained How to test POST Request using Rest Assured. In this tutorial, I will automate a PUT Request using Rest Assured. I will verify the status code, line of Status, and content of the Response.

To set up a basic Rest Assured Maven Project, click here and Gradle project, click here.

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.1</version>
      <scope>test</scope>
</dependency>
  
<dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>5.3.2</version>
      <scope>test</scope>
</dependency>

What is the PUT Method?

The HTTP PUT API is primarily used to update existing resources. If the resource does not exist, then API may decide to create a new resource or not (Depending on API development). If a new resource has been created by the PUT API, the origin server MUST inform the user agent via the HTTP response code 201 (Created) response, and if an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to indicate successful completion of the request. To learn more about Rest API, please click here.

Below are the steps to test a PUT Request using Rest Assured:

The steps to test the PUT request are similar to the POST request. The only difference is that in POST we send a request to create a new resource, whereas here we have a resource and I will update the detail of the already existing resource. To know about the steps and various imports used in the below example, please refer to the tutorial for POST Request.

Below is the response received for Employee with id 2.

I want to change the employee_salary to 99999. Below is the example for the test to update employee_salary.

import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import io.restassured.response.Response;
import io.restassured.response.ValidatableResponse;
import io.restassured.specification.RequestSpecification;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.equalTo;

public class PUT_NonBDDDemo {

    RequestSpecification requestSpecification;
    Response response;
    ValidatableResponse validatableResponse;

    @Test
    public void updateUser() {

        String jsonString = "{\"id\": 2,\r\n"
                + "        \"employee_name\": \"Garrett Winters\",\r\n"
                + "        \"employee_salary\": 99999,\r\n"
                + "        \"employee_age\": 63,\r\n"
                + "        \"profile_image\": \"\"}";

        RestAssured.baseURI = "https://dummy.restapiexample.com/api/v1/update/2";

        // Create a request specification
        requestSpecification = RestAssured.given();

        // Setting content type to specify format in which request payload will be sent.
        requestSpecification.contentType(ContentType.JSON);

        // Adding body as string
        requestSpecification.body(jsonString);

        // Calling PUT method
        response = requestSpecification.put();

        // Let's print response body.
        String responseString = response.prettyPrint();

        /*
         * To perform validation on response, we need to get ValidatableResponse type of
         * response
         */
        validatableResponse = response.then();

        // Get status code
        validatableResponse.statusCode(200);

        // It will check if status line is as expected
        validatableResponse.statusLine("HTTP/1.1 200 OK");

        // Check response - name attribute
        validatableResponse.body("data.employee_salary", equalTo(99999));

        // Check response - message attribute
        validatableResponse.body("message", equalTo("Successfully! Record has been updated."));

    }
}

Now, let us convert the same test into BDD format. In the below example, in the first part, we have retrieved the details of the employee with ID 2, and in the second part, we have updated the value of employee_salary to 99999.

import io.restassured.http.ContentType;
import io.restassured.response.Response;
import io.restassured.response.ValidatableResponse;
import io.restassured.specification.RequestSpecification;
import org.junit.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.equalTo;

public class PUT_BDDDemo {

    RequestSpecification requestSpecification;
    Response response;
    ValidatableResponse validatableResponse, validatableResponse1;

    @Test
    public void updateUser() {

        // To get the detail of employee with id 2
        validatableResponse = given()
                .baseUri("https://dummy.restapiexample.com/api/v1/employee/2")
                .contentType(ContentType.JSON)
                .when()
                .get()
                .then()
                .assertThat().statusCode(200);

        System.out.println("Response1 :" + validatableResponse.extract().asPrettyString());

        String jsonString = "{\"id\": 2,\r\n"
                + "        \"employee_name\": \"Garrett Winters\",\r\n"
                + "        \"employee_salary\": 99999,\r\n"
                + "        \"employee_age\": 63,\r\n"
                + "        \"profile_image\": \"\"}";

        // Update employee_salary
        validatableResponse1 = given()
                .baseUri("https://dummy.restapiexample.com/api/v1/update/2")
                .contentType(ContentType.JSON)
                .body(jsonString)
                .when()
                .put()
                .then()
                .assertThat().statusCode(200)
                .body("data.employee_salary", equalTo(99999))
                .body("message", equalTo("Successfully! Record has been updated."));

        System.out.println("Response2 :" + validatableResponse1.extract().asPrettyString());

    }

}

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

How to test SOAP Services using Rest Assured

HOME

In this tutorial, I will test a SOAP Service using Rest Assured. I will verify the status code, line of Status, and content of the Response. To set up a basic Rest Assured Maven Project, click here and Gradle project, click here.

Add the below-mentioned dependencies to the pom.xml.

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.1</version>
      <scope>test</scope>
</dependency>
 
<dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>5.3.2</version>
      <scope>test</scope>
</dependency>

What is the SOAP WebService?

SOAP is an XML-based protocol for accessing web services over HTTP. It has some specifications that could be used across all applications.

Implementation Steps:

Step 2 – Specify the base URL to the RESTful web service using the RestAssured class.

RestAssured.baseURI = "http://www.dneonline.com";

Step 3  The response to a request made by REST Assured.

  Response response = given()

Response is imported from package:

import io.restassured.response.Response;

Step 4 – Set the content type to specify the format in which the request payload will be sent to the server. Here, the Content-Type is “text/xml; charset=utf-8”.

 .header("Content-Type", "text/xml; charset=utf-8")

Step 5 Pass Request Body.

   .body(requestBody)
 requestBody = new File(getClass().getClassLoader().getResource("Number.xml").getFile());

Step 6 – Send the POST request to the server and receive the response of the request made by REST Assured. This response contains every detail returned by hitting request i.e. response body, response headers, status code, status lines, cookies, etc. The response is imported from package:

import io.restassured.response.Response;

Step 7 – To validate a response like status code or value, we have used the below code

 Assert.assertEquals(200, response.statusCode());
Assert.assertEquals(13, result);

PrettyPrint() – It prints the response body if possible and returns it as a string. Pretty printing is possible for content types JSON, XML, and HTML.

System.out.println(response.prettyPrint());

Below is an example of testing a SOAP Web Service request using the Rest Assured.

import io.restassured.response.Response;
import org.junit.Assert;
import org.junit.Test;
import java.io.File;
import static io.restassured.RestAssured.given;

public class RestAssured_SOAPDemo {

    File requestBody;
    Response response;

    @Test
    public void test() {

        requestBody = new File(getClass().getClassLoader().getResource("Number.xml").getFile());
        response = given()
                .baseUri("http://www.dneonline.com")
                .basePath("/calculator.asmx")
                .header("Content-Type", "text/xml; charset=utf-8")
                .body(requestBody)
                .post();

        System.out.println(response.prettyPrint());

        var xPathResult = response.xmlPath().get("//SubtractResult/text()");
        var result = Integer.parseInt(String.valueOf(xPathResult));

        System.out.println("xPathResult :" + xPathResult);
        System.out.println("result :" + result);

        Assert.assertEquals(200, response.statusCode());
        Assert.assertEquals(13, result);
    }

}

The below image shows the test result of the above test.

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

How to test POST Request using Rest Assured

HOME

In the last tutorial, I explained How to test GET Request using Rest Assured. In this tutorial, I will automate a POST Request using Rest Assured. I will verify the status code, line of Status, and content of the Response. To set up a basic Rest Assured Maven Project, click here and Gradle project, click here.

Add the below-mentioned dependencies to the pom.xml. The latest dependency can be downloaded from here.

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
</dependency>
 
<dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>5.5.1</version>
      <scope>test</scope>
</dependency>

What is the POST Method?

An HTTP POST method is used to create a new resource in the collection of resources. The request body is passed as a JSON/XML or in a different format. If a resource is created successfully by the endpoint or server, it returns a status code 201(Created). It also provides a Location header with a link to the newly-created resource with the 201 HTTP status. It may return 200 (OK) and 204 (No Content) status code as well, based on how the API is developed.

POST is neither safe nor idempotent. It is therefore recommended for non-idempotent resource requests. Making two identical POST requests will most result in two resources containing the same information.

Below are the steps to test a POST Request using Rest Assured:

Step 1 Specify the base URL to the RESTful web service using the RestAssured class.

RestAssured.baseURI = "https://dummy.restapiexample.com/api/v1/create";

Step 2  Every Request in the Rest-Assured library is represented by an interface called RequestSpecification. This interface allows modifying the request, like adding headers or adding authentication details. Use the RestAssured class to generate a RequestSpecification.

requestSpecification = RestAssured.given();

RequestSpecification is imported from package:

import io.restassured.specification.RequestSpecification;

Step 3 – Set the content type. This step specifies the format in which the request payload will be sent to the server. Here, the Content-Type is JSON.

requestSpecification.contentType(ContentType.JSON);

contentType is imported from restassured.http package:

import io.restassured.http.ContentType;

Step 4 Pass Request Body as String.

requestSpecification.body(jsonString);

Step 5 – Send the POST request to the server. Then receive the response of the request made by REST Assured. This response contains every detail returned by hitting request i.e. response body, response headers, status code, status lines, cookies, etc. The response is imported from package:

import io.restassured.response.Response;

Step 6 To validate a response like status code or value, we need to get the reference of type ValidatableResponse

ValidatableResponse is an interface. A validatable response to a request made by, REST Assured. ValidatableResponse is imported from package:

import io.restassured.response.ValidatableResponse;

PrettyPrint() – It prints the response body if possible and returns it as a string. Pretty printing is possible for content-types JSON, XML, and HTML.

Below is the example of testing a POST request in Non-BDD format. I have used ValidatableResponse for the assertion of status. It is also used for the status line and body of the Response.

import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import io.restassured.response.Response;
import io.restassured.response.ValidatableResponse;
import io.restassured.specification.RequestSpecification;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.equalTo;

public class POST_NonBDDDemo {

    RequestSpecification requestSpecification;
    Response response;
    ValidatableResponse validatableResponse;

    @Test
    public void verifyStatusCode() {

        String jsonString = "{\"name\":\"newapitest\",\"salary\":\"4000\",\"age\":\"29\"}";

        RestAssured.baseURI = "https://dummy.restapiexample.com/api/v1/create";

        // Create a request specification
        requestSpecification = RestAssured.given();

        // Setting content type to specify format in which request payload will be sent.
        requestSpecification.contentType(ContentType.JSON);

        // Adding body as string
        requestSpecification.body(jsonString);

        // Calling POST method
        response = requestSpecification.post();

        // Let's print response body.
        String responseString = response.prettyPrint();

        /*
         * To perform validation on response, we need to get ValidatableResponse type of
         * response
         */
        validatableResponse = response.then();

        // Check status code
        validatableResponse.statusCode(200);

        // It will check if status line is as expected
        validatableResponse.statusLine("HTTP/1.1 200 OK");

        // Check response body - name attribute
        validatableResponse.body("data.name", equalTo("newapitest"));

        // Check response body - message attribute
        validatableResponse.body("message", equalTo("Successfully! Record has been added."));

    }
}

The below image shows the test result of the above test.

Test implemented in BDD Format

import static org.hamcrest.Matchers.equalTo;

2. given is a static import from package:

import static io.restassured.RestAssured.given;

Below is an example of a BDD Test.

import io.restassured.http.ContentType;
import io.restassured.response.ValidatableResponse;
import org.junit.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.equalTo;

public class POST_BDDDemo {
    
    ValidatableResponse validatableResponse;

    @Test
    public void createUser() {

        String json = "{\"name\":\"apitest\",\"salary\":\"5000\",\"age\":\"30\"}";

        // GIVEN
        validatableResponse = given()
                .baseUri("https://dummy.restapiexample.com/api")
                .contentType(ContentType.JSON)
                .body(json)

                // WHEN
                .when()
                .post("/v1/create")

                // THEN
                .then()
                .assertThat().statusCode(200).body("data.name", equalTo("apitest"))
                .body("message", equalTo("Successfully! Record has been added."));

        System.out.println("Response :" + validatableResponse.extract().asPrettyString());
    }

}

The below image shows the test result of the above test.

String json = "{\"name\":\"apitest\",\"salary\":\"5000\",\"age\":\"30\"}";

.baseUri("https://dummy.restapiexample.com/api")
.contentType(ContentType.JSON)
.body(json)

".assertThat().statusCode(200)"
.body("data.name", equalTo("apitest"))
.body("message", equalTo("Successfully! Record has been added."))

The above tests can be used in both Maven and Gradle projects.

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

How to test GET Request using Rest Assured

HOME

In the last tutorial, I explained the Setup of the REST Assured Maven Project In Eclipse IDE. In this tutorial, I will automate a GET Request. I will verify the status code, line of Status, and content of the Response.

RestAssured is a class that consists of many static fields and methods. It supports POST, GET, PUT, DELETE, HEAD, PATCH, and OPTIONS requests and verifies the response to these requests.

 <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
</dependency>

<dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>5.5.5</version>
      <scope>test</scope>
</dependency>

Below are the steps to test a GET Request using Rest Assured:

Step 1 Specify the base URL to the RESTful web service using the RestAssured class.

RestAssured.baseURI = "http://dummy.restapiexample.com/api/v1/employees";

Step 2 Every Request in the Rest-Assured library is represented by an interface called RequestSpecification. This interface allows modification of the request, like adding headers or adding authentication details.

requestSpecification = RestAssured.given();

RequestSpecification is imported from the package:

import io.restassured.specification.RequestSpecification;

Step 3 Send the request to the server and receive the response to the request made by REST Assured. This response contains every detail returned by hitting request i.e. response body, response headers, status code, status lines, cookies, etc.

response = requestSpecification.get();

The response is imported from package:

import io.restassured.response.Response;

Step 4 To validate a response like status code or value, we need to acquire a reference. This reference should be of type ValidatableResponse. ValidatableResponse is an interface. A validatable response to a request made by, REST Assured. ValidatableResponse is imported from the package:

import io.restassured.response.ValidatableResponse;

PrettyPrint() It prints the response body if possible and returns it as a string. Pretty printing is possible for content-types JSON, XML, and HTML.

Below is an example of creating a test in Non-BDD format. I have used ValidatableResponse for the assertion of the status. It is also used for the status line of the Response.

import io.restassured.RestAssured;
import io.restassured.response.Response;
import io.restassured.response.ValidatableResponse;
import io.restassured.specification.RequestSpecification;
import org.junit.Test;

public class Get_NonBDDDemo {
    RequestSpecification requestSpecification;
    Response response;
    ValidatableResponse validatableResponse;

    @Test
    public void verifyStatusCode() {

        RestAssured.baseURI = "http://dummy.restapiexample.com/api/v1/employees";

        // Create a request specification
        requestSpecification = RestAssured.given();

        // Calling GET method
        response = requestSpecification.get();

        // Let's print response body.
        String resString = response.prettyPrint();
        System.out.println("Response Details : " + resString);

        /*
         * To perform validation on response, we need to get ValidatableResponse type of
         * response
         */
        validatableResponse = response.then();

        // Get status code
        validatableResponse.statusCode(200);

        // Check status line is as expected
        validatableResponse.statusLine("HTTP/1.1 200 OK");

    }
}

If you don’t want to use ValidatableResponse for the assertion, you can use Response from io.restassured .response to get the status code and status line, which are asserted using JUnit.Assert.

import io.restassured.RestAssured;
import io.restassured.response.Response;
import io.restassured.response.ValidatableResponse;
import io.restassured.specification.RequestSpecification;
import org.junit.Assert;
import org.junit.Test;

public class Get_NonBDDResponseDemo {
    RequestSpecification requestSpecification;
    Response response;

    @Test
    public void verifyStatusCode() {

        RestAssured.baseURI = "http://dummy.restapiexample.com/api/v1/employees";

        // Create a request specification
        requestSpecification = RestAssured.given();

        // Calling GET method
        response = requestSpecification.get();

        // Let's print response body.
        String resString = response.prettyPrint();
        System.out.println("Response Details : " + resString);

        // Get status line
        String statusLine = response.getStatusLine();
        Assert.assertEquals(statusLine, "HTTP/1.1 200 OK");

        // Get status code
        int statusCode = response.getStatusCode();
        Assert.assertEquals(statusCode, 200);

    }
}

The output of the above program is

Below is the test implemented in BDD Format. In this test, I am asserting the data of Employee of Id 2. I have validated the name of the employee as well as the response message.

1. equalTo is used for assertion, and is imported from a static hamcrest package:

import static org.hamcrest.Matchers.equalTo;

2. given is a static import from package:

import static io.restassured.RestAssured.given;

import org.junit.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.equalTo;

public class Get_BDDDemo {

    @Test
    public void verifyUser() {

        // Given
        given()

                // When
                .when()
                .get("http://dummy.restapiexample.com/api/v1/employee/2")

                // Then
                .then()
                .statusCode(200).statusLine("HTTP/1.1 200 OK")

                // To verify booking id at index 3
                .body("data.employee_name", equalTo("Garrett Winters"))
                .body("message", equalTo("Successfully! Record has been fetched."));
    }

}

    given
    
    .when()
    .get("http://dummy.restapiexample.com/api/v1/employee/2")
    
    .then()
    .statusCode(200)
    .statusLine("HTTP/1.1 200 OK")
    
    .body("data.employee_name", equalTo("Garrett Winters"))
    .body("message", equalTo("Successfully! Record has been fetched."));
    

    That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

    Rest Assured Tutorials

    HOME

    RestAssured is a Java-based library that is used to test RESTful Web Services. REST-assured was designed to simplify the testing and validation of REST APIs. It takes influence from testing techniques used in dynamic languages such as Ruby and Groovy.

    Chapter 1 Assertion of JSON in Rest Assured using Hamcrest
    Chapter 2 Extraction from JSON in Rest Assured – JsonPath
    Chapter 3 How to perform multiple assertions in Rest Assured? 
    Chapter 4 How to validate JSON body in Rest Assured?
    Chapter 5 Compare JSON Objects using JSONAssert Library
    Chapter 6 Compare JSON Arrays using JSONAssert Library
    Chapter 7 How to Read JSON with JSON.simple – NEW
    Chapter 8 How to create and write to JSON with JSON.simple – NEW

    JSON Handling and manipulation

    Category 10: XML Manipulations

    XML Handling and manipulation

    Gradle

    Chapter 1 Setup Basic REST Assured Gradle Project In Eclipse IDE

    Frameworks

    Chapter 1 Integration of REST Assured with TestNG
    Chapter 2 Integration of REST Assured with JUnit4
    Chapter 3 Integration of REST Assured with JUnit5
    Chapter 4 Serenity BDD with Cucumber and Rest Assured
    Chapter 5 Serenity BDD with Cucumber and Rest Assured in Gradle
    Chapter 6 How To Create Gradle Project with Cucumber to test Rest API
    Chapter 7 Rest API Test in Cucumber and JUnit4
    Chapter 8 API Automation with REST Assured, Cucumber and TestNG

    Integration of REST Assured with JUnit5

    HOME

    In this tutorial, I’ll create a Test Framework for the testing of REST API using REST Assured and JUnit5 as the test framework.

    What is Rest Assured?

    Rest Assured enables you to test REST APIs using Java libraries and integrates well with Maven/Gradle. REST Assured is a Java library that provides a domain-specific language (DSL) for writing powerful, maintainable tests for RESTful APIs.

    What is JUnit5?

    JUnit 5 is the next generation of JUnit. JUnit 5 is composed of several different modules from three different sub-projects.

    Dependency List:-

    1. REST Assured – 5.3.2
    2. Java 11
    3. JUnit Jupiter API – 5.10.0
    4. JUnit Jupiter Engine – 5.10.0
    5. Maven – 3.8.1
    6. Json – 20230618

    Detailed Step Description

    Step 1- Download and Install Java

    Java needs to be present on the system to run the tests. Click here to know How to install Java. To know if Java is installed or not on your machine, type this command in the command line. This command will show the version of Java installed on your machine.

    java -version
    

    Step 2 – Download and setup Eclipse IDE on the system

    The Eclipse IDE (integrated development environment) provides strong support for Java developers, which is needed to write Java code. Click here to learn How to install Eclipse.

    Step 3 – Setup Maven

    To build a test framework, we need to add a number of dependencies to the project. It is a very tedious and cumbersome process to add each dependency manually. So, to overcome this problem, we use a build management tool. Maven is a build management tool that is used to define project structure, dependencies, build, and test management. Click here to learn How to install Maven.

    To know if Maven is already installed or not on your machine, type this command in the command line. This command will show the version of Maven installed on your machine.

    mvn -version
    

    Step 4 – Create a new Maven Project

    Click here to learn How to create a Maven project

    Below is the Maven project structure. Here,

    Group Id – com.example
    Artifact Id – RestAssured_JUnit5_Demo
    Version – 0.0.1-SNAPSHOT
    Package – com. example.RestAssured_JUnit4_Demo

    Step 5 – Add REST Assured and JUnit5 dependencies to the project

    Add the below-mentioned dependencies to the project.

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>org.example</groupId>
      <artifactId>RestAssured_Junit5_Demo</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>jar</packaging>
    
      <name>RestAssured_Junit5_Demo</name>
      <url>http://maven.apache.org</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <rest-assurd.version>5.3.2</rest-assurd.version>
        <json.version>20230618</json.version>
        <hamcrest.version>1.3</hamcrest.version>
        <junit5.version>5.10.0</junit5.version>
        <maven.surefire.report.plugin.version>3.1.2</maven.surefire.report.plugin.version>
        <maven.compiler.plugin.version>3.10.1</maven.compiler.plugin.version>
        <maven.surefire.plugin.version>3.1.2</maven.surefire.plugin.version>
        <maven.compiler.source.version>11</maven.compiler.source.version>
        <maven.compiler.target.version>11</maven.compiler.target.version>
        <maven.site.plugin.version>3.12.0</maven.site.plugin.version>
      </properties>
    
      <dependencies>
    
        <!-- Rest Assured Dependency -->
        <dependency>
          <groupId>io.rest-assured</groupId>
          <artifactId>rest-assured</artifactId>
          <version>${rest-assurd.version}</version>
          <scope>test</scope>
        </dependency>
    
        <!-- JUNIT Jupiter API Dependency-->
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter-api</artifactId>
          <version>${junit5.version}</version>
          <scope>test</scope>
        </dependency>
    
        <!-- JUNIT Jupiter Engine Dependency-->
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter-engine</artifactId>
          <version>${junit5.version}</version>
          <scope>test</scope>
        </dependency>
    
        <!-- JSON Dependency -->
        <dependency>
          <groupId>org.json</groupId>
          <artifactId>json</artifactId>
          <version>${json.version}</version>
        </dependency>
    
        <!-- Hamcrest Dependency -->
        <dependency>
          <groupId>org.hamcrest</groupId>
          <artifactId>hamcrest-all</artifactId>
          <version>${hamcrest.version}</version>
          <scope>test</scope>
        </dependency>
    
      </dependencies>
    
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>${maven.compiler.plugin.version}</version>
            <configuration>
              <source>${maven.compiler.source.version}</source>
              <target>${maven.compiler.target.version}</target>
            </configuration>
          </plugin>
    
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>${maven.surefire.plugin.version}</version>
            <configuration>
              <testFailureIgnore>true</testFailureIgnore>
            </configuration>
          </plugin>
    
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-site-plugin</artifactId>
            <version>${maven.site.plugin.version}</version>
          </plugin>
        </plugins>
      </build>
    
        <reporting>
          <plugins>
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-surefire-report-plugin</artifactId>
              <version>${maven.surefire.report.plugin.version}</version>
              <configuration>
                <outputName>JUnit5 Report</outputName>
              </configuration>
            </plugin>
          </plugins>
        </reporting>
    
    </project>
    

    Step 6 – Create the TEST file

    The tests should be written in src/test/java directory. To learn how to create a JSON Request body using JSONObject, please refer to this tutorial.

    import io.restassured.http.ContentType;
    import org.json.JSONObject;
    import org.junit.jupiter.api.Test;
    import static io.restassured.RestAssured.given;
    import static org.hamcrest.Matchers.equalTo;
    
    public class APITests {
    
            String BaseURL = "https://reqres.in/api";
    
        @Test
        public void createUser() {
    
            JSONObject data = new JSONObject();
    
            data.put("name", "NewUser1");
            data.put("job", "Testing");
    
            // GIVEN
            given()
                    .contentType(ContentType.JSON)
                    .body(data.toString())
    
                    // WHEN
                    .when()
                    .post(BaseURL + "/users")
    
                    // THEN
                    .then()
                    .statusCode(201)
                    .body("name", equalTo("NewUser1"))
                    .body("job", equalTo("Testing"))
                    .log().all();
    
        }
    
        @Test
        public void getUser() {  //Failed Test
    
            // GIVEN
            given()
                    .contentType(ContentType.JSON)
    
                    // WHEN
                    .when()
                    .get(BaseURL + "/users/2")
    
                    // THEN
                    .then()
                    .statusCode(200)
                    .body("data.first_name", equalTo("Janet1"))
                    .log().all();
    
        }
    
    }
    

    Step 7 – Test Execution through JUnit Test

    Go to the Runner class and right-click Run As JUnit Test. The tests will run as JUnit tests.

    Below is the image to run the tests in IntelliJ.

    This is how the execution console will look like.

    Step 8 – Run the tests from the command line

    Maven Site Plugin creates a folder – site under the target directory, and the Maven Surefire Report plugin generates the JUnit Reports in the site folder. We need to run the tests through the command line to generate the JUnit Report.

    mvn clean test site
    

    The output of the above program is

    Step 9 – Report Generation

    After the test execution, refresh the project, and a new folder with the name site in the target folder will be generated. This folder contains the reports generated by JUnit. The structure of the folder site looks as shown below.

    View the Report

    Right-click on the Junit5 Report.html and select Open In -> Browser ->Chrome.

    Summary Report

    Below is the summary Report.

    Surefire Report

    Below is an example of a Surefire Report. This report contains a summary of the test execution.

    We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

    Basic Selenium Tutorials

    HOME

    Selenium – Introduction, Installation, Test Script

    Chapter 1 Introduction to Selenium Automation Tool
    Chapter 2 How to Download & Install Java JDK 11 in Windows
    Chapter 3 How to Download and Install Eclipse IDE
    Chapter 4 How to install IntelliJ on Windows
    Chapter 5 How to Download & Install Selenium WebDriver 
    Chapter 6  How to create first Selenium WebDriver Script using Java
    Chapter 7 How to run Selenium Tests using on Internet Explorer

    Locators in Selenium

     Chapter 1 How to Locate Elements in Chrome, Firefox and IE Browsers for creating Selenium Scripts
    Chapter 2 Locators in Selenium – Locate by ID, ClassName,  Name, TagName,  LinkText, PartialLinkText
    Chapter 3 Dynamic XPath  in Selenium WebDriver
    Chapter 4 CSS Selector in Selenium WebDriver

    Launching Browsers and headless Browser

    Chapter 1 How to run Chrome tests in headless mode in Selenium
    Chapter 2 How to run Firefox tests in headless mode in Selenium
    Chapter 3 How to run Edge tests in headless mode in Selenium4
    Chapter 4 How to manage driver executables using WebDriverManager
    Chapter 5 How to disable infobar warning for Chrome tests in Selenium
    Chapter 6 How to maximize and minimize the window in Selenium

    WebDriver Commands

    Chapter 1 Difference between FindElement and FindElements in WebDriver
    Chapter 2 Difference between getText() and getAttribute() method in WebDriver
    Chapter 3 WebDriver Browser Commands – get,  getTitle, getCurrentUrl, getPageSource, getClass, close, quit in WebDriver
    Chapter 4 WebDriver Navigation Commands – Navigate, Forward, Back, Refresh in  WebDriver
    Chapter 5 Selenium Form WebElement Commands – Sendkeys, Clear, Click,Submit
    Chapter 6 How to automate selecting Checkbox and Radio Buttons in Selenium WebDriver
    Chapter 7 How to Select value from Drop down list or perform Multiple Selection  Operations in WebDriver
    Chapter 8 How to get all options in a DropDown list in WebDriver
    Chapter 9 How to automate Radio Button in WebDriver
    Chapter 10 How to automate BootStrap DropDown using WebDriver
    Chapter 15 How to handle Dynamic Web Tables using Selenium WebDriver
    Chapter 16 How to get all the values from a Dynamic Table in Selenium WebDriver 
    Chapter 17 isDisplayed, isSelected, isEnabled in Selenium
    Chapter 18 How to test HTML ordered list in Selenium
    Chapter 19 How to test HTML5 validation messages with Selenium

    Waits in Selenium

    Chapter 1 Implicit and Explicit Wait in Selenium WebDriver
    Chapter 2 What is Fluent Wait in Selenium WebDriver

    Handle Window and Alerts

    Chapter 1 Switch Window Commands in Selenium WebDriver
    Chapter 2 How to handle Alerts in Selenium WebDriver
    Chapter 3 How to Switch Between Frames in Selenium WebDriver

    Selenium Interview Questions and Answers 2026
    Advanced Selenium Interview Questions and Answers 2026
    Selenium Multiple Choice Questions – MCQ1
    Selenium Multiple Choice Questions – MCQ1
    Selenium Multiple Choice Questions – MCQ3

    How to configure Junit in Intellij

    HOME

    In this tutorial we will discuss to create a JUnit  project using IntelliJ. We will be at first creating a simple Java Project and will add JUnit5 as well as create a Maven Project, then we will add a basic Class and a JUnit Test for it.

    Create a Java Project

    Step 1 – Create a new Java Project.

    To create a new Java project in Intellij, please refer to this tutorial.

    Step 2 – Right click on the project and select Open Module Settings.

    Step 3 – Go to the “Libraries” group, click the little plus (look up), and choose From Maven…option.

    Step 4 – Search for “junit” — something like “junit:junit-4.13“. Click the OK button.

    Step 5 – A new dialog will appear to confirm that “junit:junit:4.13.2” will be added to the module. Click the OK button.

    Step 6 – This screens shows that junit:junit:4.13.2 is added to the Libraries. It contains the highlighted classes – junit-4.13.2.jar and hamcrest-core-1.3.jar. Click the “OK” button.

    Step 7 – This image shows that the Junit is added to the External Libraries.

    Step 8 – Create a Java Class – JUnit4Test under src and create a JUnit test to verify that it is installed properly.

    import org.junit.Assert;
    import org.junit.Test;
    
    public class JUnit4Test {
    
        @Test
        public void Test() {
    
            String str1 = "Happy";
            String str2 = new String("Happy");
            Assert.assertEquals("String1 and String 2 are equal",str1, str2);
    
        }
    }
    

    Step 9 – There are many ways to run the test. One of the way is to Right-Click and select Run JUnit4Test

    The successful execution of the test shows that the JUnit is configured properly.

    Create a Maven Project

    Add Junit dependency to the POM.xml and build the project.

    <dependencies>
    
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        
    </dependencies>
    

    Now we need to apply the changes in the build script. Press Ctrl+Shift+O or click Load Maven Changes in the notification that appears in the top-right corner of the editor.

    Create a Java Class – JUnit4Test under src/test/java and create a JUnit test to verify that it is installed properly.

    import org.junit.Test;
    import static org.junit.Assert.assertArrayEquals;
    
    public class JUnitMavenTest {
    
        @Test
        public void Test() {
    
            String[] expected = {"happy","days","summer","spring"};
            String[] actual = {"happy","days","summer","spring"};
    
            assertArrayEquals("Expected and Actual Arrays are not equal",expected,actual);
    
        }
    }
    
    

    The output of the above program is

    Similarly, to add JUnit5 we can add below mentioned dependencies to the POM.xml.

    <dependency>
         <groupId>org.junit.jupiter</groupId>
         <artifactId>junit-jupiter-engine</artifactId>
         <version>5.8.2</version>
         <scope>test</scope>
    </dependency>
    
    <dependency>
         <groupId>org.junit.jupiter</groupId>
         <artifactId>junit-jupiter-api</artifactId>
         <version>5.8.2</version>
         <scope>test</scope>
    </dependency>
    

    Congratulations. We are able to add JUnit to Java or Maven project. Happy Learning!!

    JUnit Tutorials

    HOME

    JUnit is an open source Unit Testing Framework for JAVA.
    JUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.

    JUnit4

    Chapter 1 How to configure Junit in Intellij
    Chapter 2 How to run JUnit5 tests through Command Line
    Chapter 3 JUnit4 Assertions
    Chapter 4 How to Parameterize tests in JUnit4
    Chapter 5 How to generate JUnit4 Report
    Chapter 6 Integration of Cucumber with Selenium and JUnit
    Chapter 7 Integration of Serenity with Cucumber6 and JUnit5
    Chapter 8 Integration of Serenity with JUnit4
    Chapter 9 Rest API Test in Cucumber BDD
    Chapter 10 Difference between JUnit4 and JUnit5
    Chapter 11 Integration of REST Assured with JUnit4

    JUnit5

    Chapter 1 JUnit5 Assertions Example
    Chapter 2 Grouped Assertions in JUnit 5 – assertAll()
    Chapter 3 How to Retry Test in JUnit5 – @RepeatedTest
    Chapter 4 How to disable tests in JUnit5 – @Disabled
    Chapter 5 How to run JUnit5 tests in order
    Chapter 6 How to tag and filter JUnit5 tests – @Tag
    Chapter 7 Assumptions in JUnit5
    Chapter 8 How to parameterized Tests in JUnit5
    Chapter 9 How to run parameterized Selenium test using JUnit5
    Chapter 10 Testing of Web Application using Serenity with JUnit5
    Chapter 11 Integration of Serenity with Cucumber6 and JUnit5
    Chapter 12 How to generate JUnit5 Report – NEW

    Gradle

    Chapter 1 Gradle – Allure Report for Selenium and JUnit4
    Chapter 2 Gradle Project with Cucumber, Selenium and JUnit4
    Chapter 3 Gradle – Integration of Selenium and JUnit5