Serialization and Deserialization using Rest Assured

by | Apr 29, 2019 | Rest API Testing, Java, Rest Assured | 7 comments

Serialization_Deserialization_Rest_Assured_Techndeck
Post Views: 12,975

It’s very likely that you could have a requirement that you have a POJO (Plain Old Java Object) and you need to send it to the API call. To do that you need to ‘Serialize’ it in Rest-Assured and this process is referred as ‘Serialization’. While on the other hand, you have the API response and you would need to ‘Deserialize’ it into a POJO then it’s called ‘De-Serialization’. Now, In this tutorial, we will learn“How to perform Serialization and De-serialization in Rest Assured?”.

Simple representation of Serialization and De-serialization using RESTAssured...!!! Click To Tweet

 

In this tutorial, we are going to cover the below topics:

  1. Serialization of POJO into a JSON Request Body Object
  2. De-Serialization of API Response to a POJO

 

But, first let’s understand what are these concepts ‘Serialization and Deserialization’ actually mean in Java.  

What is Serialization and Deserialization?

Serialization is a process of conversion of the Instance of a Class (state of the Java object) to a byte stream. Then, this serialized object or we say this Byte steam can be stored in files or external sources and can be transferred over networks.  While on the other hand, Deserialization is simply the reverse of Serialization meaning converting the byte stream back to the Java object.

To achieve Serialization, a class needs to implement Serializable Interface and such class are actually Java Beans or say POJO (Plain Old Java Object). So, basically Serialization is the process of Converting a POJO to a JSON object and converting a JSON object back to POJO is called Deserialization.

 

Let’s begin:

1. Serialization of POJO into a JSON Request Body Object

Let’s take an example, Here we are using a ‘Student’ class as a POJO which is holding some basic attributes like name, batch, and roll number.

Student.java (POJO)

Student - POJO
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Student {
 
String name;
String batch;
int rollNumber;
public Student(String name, String batch, int rollNumber) {
this.name=name;
this.batch=batch;
this.rollNumber=rollNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getBatch() {
return batch;
}
public void setBatch(String batch) {
this.batch = batch;
}
public Integer getRollNumber() {
return rollNumber;
}
public void setRollNumber(Integer rollNumber) {
this.rollNumber = rollNumber;
}
 
        public String toString(){
                return "The Student name is " + this.name + " studies in Batch " + this.batch + "and has rollNumber " + this.rollNumber;
        }
}

 

Now our POJO is ready to use, so we will move onto our main step of creating a Rest Assured Test to perform the serialization bypassing this POJO to the API.

Here I am using an API that I build in my local machine to support this example which is having a POST Endpoint on which we are making a call request with the above-mentioned POJO (in the form of the object instance) in the Request body object.

As I’ve mentioned this line above “in the form of the object instance”, it means we need to create a sample object instance of Student (POJO) class and specify some values to it. Like below:

Student student = new Student(“Isha Durani”, “A”, 101);

Now, let’s create the test class:

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import static org.testng.Assert.assertTrue;
import org.testng.annotations.Test;
import io.restassured.RestAssured;
import io.restassured.response.Response;
 
public class TestSerialization {
 
    @Test
    public void testSerialization() {
 
        Response response = null;
 
        Student student = new Student("Isha Durani", "A", 101);
 
        response = RestAssured.given()
            .contentType("application/json")
            .body(student)
            .when()
            .post("http://localhost:9091/students");
 
        assertTrue(response.toString().contains("Student added successfully."));
 
    }
 
}

 

When you’ll execute this above class, Rest-Assured will render the ‘Student’ object instance into the JSON formatted request body object. Like below:

Student - JSON Request Body
XHTML
1
2
3
4
5
{
  "name": "Isha Durani",
  "batch": "A",
  "rollNumber": 101
}

That’s it. It’s that simple to serialize the Java Object (POJO) to a JSON Request object.

 

2. De-Serialization of the API Response into a POJO

As we have seen above in point number 1, we passed POJO as a Java object to the API Request. But now, we are doing the reverse by transforming the API response to a POJO Java instance.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import org.testng.annotations.Test;
import io.restassured.RestAssured;
 
public class TestDeSerialization {
 
    @Test
    public void testDeSerialization() {
 
        Student student = RestAssured.get("http://localhost:9091/students/1").as(Student.class);
 
        System.out.println(student.toString());
    }
 
}

 

Notice that “http://localhost:9091/students/1” is the GET Endpoint. Here on this Endpoint, we are looking for a student having id as 1. You can set up any rest GET API endpoint for testing purposes.

Below is the output of the execution of TestDeSerialization class:

Deserialization Output
1
The Student name is Isha Durani studies in Batch A and has rollNumber 101

 

That’s it. It’s that simple to de-serialize the API Response into a Java Object (POJO).

 

Simple representation of Serialization and De-serialization using RESTAssured...!!! Click To Tweet

If you like this post, please check out my other useful blog posts on Rest Assured:

Other Useful References:

Related posts:

  1. How to make a GET Request using Rest Assured
  2. REST API testing using REST Assured
  3. How to send POST XML Request using Rest Assured?

7 Comments

  1. Appan
    Appan on July 18, 2020 at 2:39 pm

    Hi Deepak, I was trying the serialization / deserialization with your example shown here but got stuck in the deserialization. I guess the json data is not getting extracted and shows an exception as below. –
    com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of serialization.Users (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
    at [Source: (String)”{
    “firstName”: “Hikaru”,
    “lastName”: “Nakamura”,
    “fideRating”: 2727,
    “id”: 26
    }”; line: 2, column: 3]

    Please let me know what needs to be done to fix this issue. I’m using jackson data binding.

    Reply
    • Deepak Verma
      Deepak Verma on January 21, 2020 at 11:13 am

      Thanks for appreciating the article, Nakshtra.

      There is no restriction mentioned on the website.

      But, if you experience any issue with the larger payload, let me know.

      Thanks

      Reply
  3. Andy Turfer
    Andy Turfer on July 17, 2019 at 2:23 am

    Thanks for the write-up. It would have been extremely useful if your “Student” example included slightly more complex nested JSON. Nevertheless, thanks for sharing.

    Reply
    • Deepak Verma
      Deepak Verma on July 17, 2019 at 5:40 pm

      I am glad you liked it Andy.

      And, thanks for the valuable feedback. I kept a note of your suggestion and I’ll publish a post on nested json example as soon as possible.

      Thanks again.

      Reply

Submit a Comment

Your email address will not be published. Required fields are marked *