Introduction to API Testing with Rest Assured

In today’s tech-driven world, Application Programming Interfaces (APIs) are essential for enabling communication between different software systems. With the rise of microservices and cloud-based architectures, API testing has become crucial in validating the accuracy, functionality, and performance of APIs. Among various tools available, Rest Assured has gained popularity due to its simplicity and effectiveness in testing RESTful APIs. In this blog post, we’ll dive into an introduction to API testing with Rest Assured, explore its benefits, and go through some fundamental steps to get started.

What is API Testing?

API testing is a type of software testing that involves verifying the API's functionality, reliability, performance, and security. It focuses on ensuring that the API:

  • Returns the correct responses for given requests
  • Follows specified data formats (e.g., JSON, XML)
  • Meets performance benchmarks (e.g., response times)
  • Secures sensitive data and prevents unauthorized access

With API testing, we can automate a wide range of scenarios, allowing for faster and more accurate results than traditional testing methods.

Why Use Rest Assured for API Testing?

Rest Assured is a Java-based library that simplifies testing RESTful APIs. It’s designed with developers and testers in mind and offers an easy way to test and validate HTTP requests and responses. Here are some reasons why Rest Assured is a popular choice for API testing:

  1. Easy to Learn: Rest Assured provides a straightforward, fluent API that is easy to learn and work with, even for those with minimal Java experience.
  2. Readable Syntax: Its syntax is simple and expressive, making test scripts highly readable and maintainable.
  3. Built-in HTTP Methods: It supports all standard HTTP methods such as GET, POST, PUT, DELETE, PATCH, making it flexible for different types of requests.
  4. Automated Validation: Built-in validation capabilities allow for quick and effective checks on status codes, response bodies, headers, etc.
  5. Seamless Integration: It can be easily integrated with TestNG or JUnit frameworks, making it ideal for building a comprehensive test suite.

Getting Started with Rest Assured

To begin using Rest Assured, you’ll need to set up a Maven project, as Rest Assured dependencies are readily available in the Maven repository.

Step 1: Setting Up the Project

If you’re working with Maven, add the Rest Assured dependency to your pom.xml file:

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


Step 2: Writing Your First API Test
Here’s how we can write a test to verify the response:

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

public class APITest {

    @Test
    public void testGetRequest() {
        RestAssured.baseURI = "https://jsonplaceholder.typicode.com";

        given()
            .when()
            .get("/posts/1")
            .then()
            .statusCode(200) // Verify status code
            .body("id", equalTo(1)) // Check that id matches
            .body("title", notNullValue()); // Ensure title is not null
    }
}

This test performs a GET request and validates the response:
  • Checks if the status code is 200.
  • Confirms that the id field in the JSON response is 1.
  • Ensures that the title field is present in the response.
Step 3: Adding Assertions
Assertions are a critical part of API testing to validate different aspects
of the response. Rest Assured provides a variety of built-in matchers (such
as equalTo,hasSize, notNullValue, etc.) to check specific elements in the 
response body, headers, and status codes.
For example, let’s validate that a POST request successfully creates a new 
record:
@Test
public void testPostRequest() {
    RestAssured.baseURI = "https://jsonplaceholder.typicode.com";

    String requestBody = "{ \"title\": \"foo\", \"body\": \"bar\", 
\"userId\": 1 }";

    given()
        .header("Content-type", "application/json")
        .and()
        .body(requestBody)
        .when()
        .post("/posts")
        .then()
        .statusCode(201) // Expected HTTP Status code for creation
        .body("title", equalTo("foo"))
        .body("body", equalTo("bar"))
        .body("userId", equalTo(1));
}


In this example, we send a JSON payload in the request body and check that:
  • The status code is 201, indicating successful creation.
  • The title, body, and userId fields in the response match our request
payload.
Step 4: Working with Different HTTP Methods
Beyond GET and POST requests, Rest Assured also supports other HTTP methods 
such as PUT, PATCH, and DELETE, allowing full CRUD (Create, Read, Update,
Delete) operations.
For instance, here’s how we might perform a DELETE request to remove an 
item:
@Test
public void testDeleteRequest() {
    RestAssured.baseURI = "https://jsonplaceholder.typicode.com";

    given()
        .when()
        .delete("/posts/1")
        .then()
        .statusCode(200); // Expecting 200 OK for successful deletion
}

Advanced Concepts
Once you’ve mastered the basics, Rest Assured offers additional features to 
enhance 
your API testing:
Parameterization: Use query parameters and path parameters to make tests
dynamic.
Authentication: Support for different authentication schemes (Basic, OAuth,  
etc.).
Logging: Log requests and responses to debug failed tests easily.
Custom Headers: Add custom headers and cookies to test various request 
configurations.

Followers