In this tutorial, I will explain the Integration of Serenity BDD with Rest Assured for the testing of RestFul API.
What is Serenity BDD?
Serenity BDD is an open-source library that aims to make the idea of living documentation a reality.
What is Rest Assured?
Rest Assured is one of the most powerful libraries for testing RESTful API using Java language. Rest-Assured is a Java-based library that is used to test RESTful Web Services. This library behaves like a headless Client to access REST web services. The rest-Assured library also provides the ability to validate the HTTP Responses received from the server.
Pre-Requisite
- Java 11 installed
- Maven installed
- Eclipse or IntelliJ installed
This framework consists of:
- Java 11
- Maven – 3.8.1
- Serenity – 3.2.5
- Serenity Rest Assured – 3.2.5
- Rest Assured – 5.1.1
- JUnit – 4.13.2
- Maven Surefire Plugin – 3.0.0-M5
- Maven Failsafe Plugin – 3.0.0-M5
- Maven Compiler Plugin – 3.8.1
Implementation Steps
- Update Properties section in Maven pom.xml
- Add repositories and pluginRepository to Maven pom.xml
- Add Serenity, Serenity Rest Assured, and JUnit4 dependencies to POM.xml
- Update Build Section of pom.xml
- Create the Test Code under src/java/test
- Create serenity.properties file in the root of the project
- Run the tests through the command line which generates Serenity Reports.
Project Structure
Step 1 – Update the Properties section in Maven pom.xml
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<serenity.version>3.2.5</serenity.version>
<serenity.maven.version>3.2.5</serenity.maven.version>
<junit.version>4.13.2</junit.version>
<rest.assured.version>5.1.1</rest.assured.version>
<json.version>20210307</json.version>
<maven.surefire.plugin.version>3.0.0-M5</maven.surefire.plugin.version>
<maven.failsafe.plugin.version>3.0.0-M5</maven.failsafe.plugin.version>
<maven.compiler.plugin.version>3.8.1</maven.compiler.plugin.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
Step 2 – Add repositories and pluginRepository to Maven pom.xml
<repositories>
<repository>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>bintray</name>
<url>https://jcenter.bintray.com</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>bintray-plugins</name>
<url>https://jcenter.bintray.com</url>
</pluginRepository>
</pluginRepositories>
Step 3 – Add Serenity, Serenity Cucumber, Serenity Rest Assured, Rest Assured, and JUnit dependencies to POM.xml
<dependencies>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-core</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-junit</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-screenplay-rest</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-rest-assured</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.rest-assured</groupId>
<artifactId>rest-assured</artifactId>
<version>${rest.assured.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>${json.version}</version>
</dependency>
</dependencies>
Step 4 – Update the Build Section of pom.xml
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>${maven.surefire.plugin.version}</version>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
<plugin>
<artifactId>maven-failsafe-plugin</artifactId>
<version>${maven.failsafe.plugin.version}</version>
<configuration>
<includes>
<include>**/*.java</include>
<include>**/*.Test</include>
</includes>
</configuration>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven.compiler.plugin.version}</version>
<configuration>
<source>${maven.compiler.source}</source>
<target>${maven.compiler.target}</target>
</configuration>
</plugin>
<plugin>
<groupId>net.serenity-bdd.maven.plugins</groupId>
<artifactId>serenity-maven-plugin</artifactId>
<version>${serenity.version}</version>
<dependencies>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-single-page-report</artifactId>
<version>${serenity.version}</version>
</dependency>
</dependencies>
<configuration>
<tags>${tags}</tags>
<reports>single-page-html</reports>
</configuration>
<executions>
<execution>
<id>serenity-reports</id>
<phase>post-integration-test</phase>
<goals>
<goal>aggregate</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
Step 5 – Create the Test Code in src/java/test directory
There are 2 ways to create the same test. One approach is to have a Definition file that contains all the test code as shown below.
public class Employee {
private static final String URL = "http://dummy.restapiexample.com/api/v1";
public Response response;
@Test
public void verifyValidUser() {
response = SerenityRest.given().contentType("application/json").header("Content-Type", "application/json").when().get(URL + "/employee/" + id);
SerenityRest.restAssuredThat(response -> response.statusCode(200)
.body("data.id", equalTo(1))
.body("data.employee_salary", equalTo(320800))
.body("data.employee_name", equalTo("Tiger Nixon"))
.body("data.employee_age", equalTo(61)).and()
.body("message", equalTo("Successfully! Record has been fetched.")));
}
@Test
public void verifycreateUser() {
JSONObject data = new JSONObject();
data.put("employee_name", "Shawn Test");
data.put("profile_image", "test.png");
data.put("employee_age", 30);
data.put("employee_salary", 11111);
response = SerenityRest.given().contentType("application/json").header("Content-Type", "application/json")
.body(data.toString()).when().post(URL + "/create");
SerenityRest.restAssuredThat(response -> response.statusCode(200)
.body("data.employee_salary", equalTo(11111))
.body("data.employee_name", equalTo("Shawn Test"))
.body("data.employee_age", equalTo(30)).and()
.body("message", equalTo("Successfully! Record has been added.")));
}
}
Another approach is that all tests are split into reusable blocks called “steps“. The main principle of the BDD approach is that we are trying to keep complexity to a high-level human-readable level. First of all, let’s create a separate package to keep our steps. It is always better to keep them separate as it shows which classes contain reusable components. It is better to make steps smaller. So let’s make separate reusable steps from our tests:
import static org.hamcrest.Matchers.equalTo;
import org.json.JSONObject;
import io.restassured.response.Response;
import net.serenitybdd.rest.SerenityRest;
import net.thucydides.core.annotations.Step;
public class EmployeeSteps {
private static final String URL = "http://dummy.restapiexample.com/api/v1";
public Response response;
@Step("Search user by id {0}")
public void sendUser(int id) {
response = SerenityRest.given().contentType("application/json").header("Content-Type", "application/json")
.when().get(URL + "/employee/" + id);
}
@Step("Create a new user")
public void createUser() {
JSONObject data = new JSONObject();
data.put("employee_name", "Shawn Test");
data.put("profile_image", "test.png");
data.put("employee_age", 30);
data.put("employee_salary", 11111);
response = SerenityRest.given().contentType("application/json").header("Content-Type", "application/json")
.body(data.toString()).when().post(URL + "/create");
}
@Step("Verify the status code {0}")
public void verifyStatusCode(int expectedStatusCode) {
SerenityRest.restAssuredThat(response -> response.statusCode(expectedStatusCode));
}
@Step("Verify the user id {0}")
public void verifyId(int expectedId) {
SerenityRest.restAssuredThat(response -> response.body("data.id", equalTo(expectedId)));
}
@Step("Verify the user name {0}")
public void verifyName(String expectedName) {
SerenityRest.restAssuredThat(response -> response.body("data.employee_name", equalTo(expectedName)));
}
@Step("Verify the user salary {0}")
public void verifySalary(int expectedSalary) {
SerenityRest.restAssuredThat(response -> response.body("data.employee_salary", equalTo(expectedSalary)));
}
@Step("Verify the user age {0}")
public void verifyAge(int expectedAge) {
SerenityRest.restAssuredThat(response -> response.body("data.employee_age", equalTo(expectedAge)));
}
@Step("Verify the message {0}")
public void verifyMessage(String expectedMessage) {
SerenityRest.restAssuredThat(response -> response.body("message", equalTo(expectedMessage)));
}
}
Now our steps are ready. Let’s refactor the main class with our tests:
import org.example.SerenityWithRestAssuredDemo.steps.EmployeeSteps;
import org.junit.Test;
import org.junit.runner.RunWith;
import net.serenitybdd.junit.runners.SerenityRunner;
import net.thucydides.core.annotations.Steps;
import net.thucydides.core.annotations.Title;
@RunWith(SerenityRunner.class)
public class EmployeesTest {
@Steps
EmployeeSteps employeeSteps;
@Test
@Title("Get User")
public void verifyValidUser() {
employeeSteps.sendUser(1);
employeeSteps.verifyStatusCode(200);
employeeSteps.verifyId(1);
employeeSteps.verifyName("Tiger Nixon");
employeeSteps.verifyAge(61);
employeeSteps.verifySalary(320800);
employeeSteps.verifyMessage("Successfully! Record has been fetched.");
}
@Test
@Title("Create User")
public void createValidUser() {
employeeSteps.createUser();
employeeSteps.verifyStatusCode(200);
employeeSteps.verifyName("Shawn Test");
employeeSteps.verifyAge(30);
employeeSteps.verifySalary(11111);
employeeSteps.verifyMessage("Successfully! Record has been added.");
}
}
One more important thing we added is the “@RunWith(SerenityRunner.class)” annotation on top of the class. As we have now organized our structure to meet some basic Serenity principles, we are ready to run the test using Serenity. This time (after we added the mentioned annotation) these tests will be run using the “SerenityRunner”. For that we can use exactly the same command to run our tests:
mvn clean verify
The output of the above program is
In the console, you should find printed messages for tests to start. At the same time under the target directory you can find the HTML-generated report we were talking about before:
You can open the report in any browser:
If you click on any test you should see a detailed description of the test steps:
One of the most important features of the Serenity and REST Assured integration is that by using detailed reporting, you can easily validate all requests and response details even if you are not adding any logs inside tests. Like the example above, for each executed REST request you can click the button “REST Query” and get a detailed request and response description:
There is another very useful Serenity Report – Serenity Symmary.html
As you can see, Serenity and REST Assured provide you with a wonderful combination. REST Assured keeps API testing clean and easy to maintain, while Serenity gives you outstanding test reporting and flexibility in running and grouping your tests inside a test suite.
Complete Source Code:
Refer to GitHub for source code.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
QA Automation Expert 