Tutorials123: API Test Automation with Rest Assured

Showing posts with label API Test Automation with Rest Assured. Show all posts

How to validate JSON Schema in Rest Assured

What is JSON Schema?

JSON Schema is a specification that defines the structure of a JSON document.
It is used to validate that a given JSON response (or request) follows a predefined format.

A JSON Schema defines:

Data types (string, number, object, array, boolean, null)
Required vs optional fields
Field constraints (min/max length, patterns, ranges, enum values, etc.)
Nested objects and arrays

Why validate JSON Schema?

To check that API responses always follow the contract agreed between client and server.
To avoid breaking changes when backend updates occur.
To make automated testing more robust and reliable.

How to validate JSON Schema in Rest Assured

Rest Assured provides built-in support for JSON Schema validation using the json-schema-validator library.

This includes:

1. Prepare a JSON Schema file

Create a .json file that defines the expected schema of the API response.
Example: define required fields, their data types, and structure.

2. Add JSON Schema Validator dependency

Rest Assured integrates with the json-schema-validator library, which enables schema-based validation.

3. Call the API using Rest Assured

Perform a request (GET/POST/etc.) to get the API response.

4. Validate Response against JSON Schema

Use Rest Assured’s built-in schema validator methods to check whether the actual JSON response matches the schema.
If the response matches → test passes.
If not → test fails with details about what part of the schema is violated.

In short:

To validate a JSON schema using Rest Assured in a GET API response, you can use the JsonSchemaValidator provided by Rest Assured. It helps ensure that the structure of the JSON returned from the API matches an expected schema.

Steps to Use JSON Schema Validation in Rest Assured

1. Add Dependencies

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

    <!-- JSON Schema Validator -->
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>json-schema-validator</artifactId>
        <version>5.4.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Just visit this page to create JSON schema or use existing below schema for API:

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

2. Create JSON Schema File

We can create schema from any json schema creator website. One of the best website is: http://json-schema.org/

Create a json schema file named as users-schema.json for GET API: https://reqres.in/api/users?page=2 and placed in the src/test/resources directory.

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": { "type": "integer" },
    "per_page": { "type": "integer" },
    "total": { "type": "integer" },
    "total_pages": { "type": "integer" },
    "data": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": { "type": "integer" },
          "email": { "type": "string" },
          "first_name": { "type": "string" },
          "last_name": { "type": "string" },
          "avatar": { "type": "string" }
        },
        "required": ["id", "email", "first_name", "last_name", "avatar"]
      }
    },
    "support": {
      "type": "object",
      "properties": {
        "url": { "type": "string" },
        "text": { "type": "string" }
      },
      "required": ["url", "text"]
    }
  },
  "required": ["page", "per_page", "total", "total_pages", "data", "support"]
}

3. Java Code to Validate Schema

import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import static io.restassured.module.jsv.JsonSchemaValidator.matchesJsonSchemaInClasspath;
import static io.restassured.RestAssured.*;

public class JsonSchemaValidationTest {

    public static void main(String[] args) {

        RestAssured.baseURI = "https://reqres.in";

        given()
            .contentType(ContentType.JSON)
        .when()
            .get("/api/users?page=2")
        .then()
            .assertThat()
            .statusCode(200)
            .body(matchesJsonSchemaInClasspath("users-schema.json"));

        System.out.println("Schema validated successfully.");
    }
}

Code explanation:

(a) Define the base URI

(b) Send request for GET API as mentioned in code and get response

How to Test Status Line of API by Rest Assured

What is the Status Line of an API?

The status line is the first line of the HTTP response sent by the server.
It provides three parts:

HTTP Version → Example: HTTP/1.1 or HTTP/2

Status Code → Example: 200, 404, 500

Reason Phrase → Example: OK, Not Found, Internal Server Error

Example of a status line:

HTTP/1.1 200 OK

In this,

HTTP/1.1 → HTTP protocol version
200 → Status code (success)
OK → Reason phrase

How to Test Status Line of API in Rest Assured

When testing an API’s status line using Rest Assured, you:

Send the API Request (GET, POST, etc.).
Extract the Status Line from the response.
Verify the Status Line against the expected value.

What to Check in Status Line:

Ensure HTTP version is correct (e.g., HTTP/1.1).
Ensure status code is as expected (e.g., 200).
Ensure reason phrase is correct (e.g., OK).

To test the status line of a GET API using Rest Assured in Java, you need to understand what a status line is and how to retrieve it.

Example:

HTTP/1.1 200 OK

Steps to Test Status Line Using Rest Assured

Set the base URI.
Use given() to prepare the request.
Use .when().get() to make the GET call.
Use .then().statusLine() to verify the status line.
You can also extract the status line using .extract().statusLine().

API to be automated:

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

Maven Dependencies:

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

Java Code Using Rest Assured to Test Status Line

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

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

public class StatusLineTest {
    public static void main(String[] args) {
        // Set base URI
        RestAssured.baseURI = "https://reqres.in";

        // Send GET request and validate status line
        given()
            .when()
            .get("/api/users?page=2")
            .then()
            .assertThat()
            .statusLine("HTTP/1.1 200 OK");  // Validate full status line

        // Optionally, print the actual status line
        Response response = get("/api/users?page=2");
        String actualStatusLine = response.getStatusLine();
        System.out.println("Status Line is: " + actualStatusLine);
    }
}

Code explanation:

1. Set the base URI

2. Send GET API request

3. validate status line

4. Print the actual status line on console

Output:

Status Line is: HTTP/1.1 200 OK

At a glance:

Use .statusLine("HTTP/1.1 200 OK") to validate the exact status line.
Use .getStatusLine() to fetch and print it.
This is useful to ensure your API response is well-formed and meets expectations.