Tutorials123: Automation Testing with Rest Assured

Showing posts with label Automation Testing with Rest Assured. Show all posts

How to test API Response by Rest Assured

What is an API Response?

When you send a request to an API (like GET, POST, PUT, DELETE), the server processes it and sends back a response.
An API Response generally contains:

Status Line → Includes status code (e.g., 200 OK, 404 Not Found, 500 Internal Server Error) and protocol version.

Response Headers → Provide metadata about the response (e.g., Content-Type, Server, Cache-Control).

Response Body → The actual data returned (in JSON, XML, or HTML). Example: user details, order status, product list, etc.

How to Test API Response using Rest Assured

Rest Assured is a Java-based library for testing REST APIs. It provides a fluent interface to validate API responses.

When testing an API response with Rest Assured, you typically check:

1. Response Status Code

Verify that the returned status code matches the expected one.
Example: A successful request should return 200, creating a resource might return 201, and invalid requests might return 400 or 404.

2. Response Headers

Validate that important headers are present and contain correct values.
Example: Content-Type should be application/json.

3. Response Body Content

Check if the data returned in the body is correct.
Example: For a user API, ensure the returned user’s id, name, or email matches what you expect.

4. Response Time / Performance

Measure how long the API took to respond.
Example: The response time should be within 2 seconds.

5. Schema Validation

Verify that the response structure matches the expected JSON or XML schema.
Example: Ensures fields like id, name, and email exist and are of the correct data type.

6. Error Handling

Check how the API behaves when invalid requests are sent.
Example: If you send a request with missing data, the API should return a proper error code and message.

In below example, we are going to test response of API.

This is the API we are going to test:

https://reqres.in/api/users?page=2

Below are maven dependencies:

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

    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>7.9.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Java Code:

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

public class ResponseBodyContainsTest {

    @Test
    public void testResponseBodyContains() {
        // Set the base URI
        RestAssured.baseURI = "https://reqres.in";

        // Send GET request and capture response
        Response response = RestAssured
                .given()
                .when()
                .get("/api/users?page=2")
                .then()
                .statusCode(200) // Validate status code
                .extract()
                .response();

        // Convert response body to String
        String responseBody = response.asString();

        // Print for reference
        System.out.println("Response Body:\n" + responseBody);

        // Use contains() to validate specific strings
        Assert.assertTrue(responseBody.contains("George"), "Expected name not found in response");
        Assert.assertTrue(responseBody.contains("email"), "Expected 'email' field not found in response");
        Assert.assertTrue(responseBody.contains("janet.weaver@reqres.in") == false, "Unexpected email found in response");
    }
}

Code explanation:

1. Set the base URI

2. Send GET request and extract response

3. Convert response body to string type

4. Print response body

5. Use contains() to validate string

Important Points:

.contains() is case-sensitive.
You can test for presence/absence of any string that should/shouldn't be in the response.
Prefer this method for quick validations; for structured validations, use JSON path instead.

How to Test GET API by Rest Assured

What is Rest Assured?

Rest Assured is a Java-based library used for testing RESTful APIs.
It provides a domain-specific language (DSL) that makes writing HTTP request tests simple and readable.
You can use it to send requests like GET, POST, PUT, DELETE, etc., and then validate responses (status code, headers, body, etc.).
It integrates well with JUnit, TestNG, Maven, and CI/CD tools.

To test a GET API using Rest Assured in Java, you can follow the steps below. We'll walk through the process and test the endpoint:

API Endpoint: https://reqres.in/api/users

This API returns paginated user data in JSON format.

Basic Steps to Test GET API

Add Rest Assured dependency in your pom.xml (if using Maven).
Set the Base URI.
Send the GET request.
Validate the Response (status code, headers, body).
Log response (optional but useful for debugging).

Maven Dependency (pom.xml):

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

Java Code to Test GET API

import io.restassured.RestAssured;
import io.restassured.response.Response;

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class GetUserApiTest {

    public static void main(String[] args) {

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

        // Step 2: Send GET request and validate
        given()
            .log().all()  // Logs the request details
        .when()
            .get("/api/users?page=2")  // Endpoint
        .then()
            .log().all()  // Logs the response details
            .assertThat()
            .statusCode(200)  // Validate HTTP Status code
            .body("data", notNullValue())  // Validate response body contains 'data'
            .body("data.size()", greaterThan(0))  // Validate non-empty data
            .body("data[0].id", notNullValue());  // Validate user id present
    }
}

Explanation of Code:

Line	Purpose
baseURI	Sets the base URL for the request.
given()	Prepares request specification.
log().all()	Logs all request and response data for visibility.
get()	Triggers the GET request to the specified endpoint.
then()	Begins response verification.
statusCode(200)	Verifies the status code is 200 (OK).
body(...)	Verifies the presence and contents of specific JSON fields.

Response Validation:

Below is the screenshot of code which is validating GET API response.

In above screenshot, data is json array, and code is validating that data contains any values or not or we can say it is null or not. In the second line we are verifying size of array data is greater than 0 or not and in third line we are verifying, first element of data array that is id, is null or contains any value.

Sample JSON Output from API

{
  "page": 2,
  "per_page": 6,
  "data": [
    {
      "id": 7,
      "email": "michael.lawson@reqres.in",
      "first_name": "Michael",
      "last_name": "Lawson",
      ...
    }
  ]
}