DEV Community: Luiz Eduardo Martins

API Testing with Java and Spring Boot Test - Part 2: Improving the solution

Luiz Eduardo Martins — Tue, 07 Feb 2023 08:06:43 +0000

In the last part of this step-by-step, we created the project, set up the test framework and also did all the configurations needed to run our API tests.

You can see the first part of the series here:

API Testing with Java and Spring Boot Test - Part 1: The basic setup.

Let's continue to grow our test framework, but first, we need to do some improvements to the existing code. In this guide, we'll:

Refactor the object mapping (to be easier to handle with the JSON files)
Improve the response validations
Handle multiple environments inside our tests.

These changes will let our code base cleaner and easier to maintain while helping us to create a scalable framework of API tests.

Let's do it.

Refactoring the Object mapping

We'll take advantage of using the Spring boot Repository to separate the responsibility of mapping the objects (JSON) we're going to use inside our tests. That way, we can do another step forward in our code cleanup.

So, first of all, we're going to:

Create a new package called repositories
Then we create a new Class inside this package called FileUtils.

We'll also take the opportunity to change the way we map the object to not be hard-coded but be in a proper resource file. That way when we need to change the test data, we don't have to change the test but only the correspondent resource file.

As you can see in the file above, we created a function to read a JSON file and then return the object already mapped - similar to the approach we had before in the test file.

Now, we'll structure the resources folder to accommodate the JSON files.

In the resources folder, let's create a new directory called user and then create a file to store the request body of the operation we'll do.

After that, we need to update our test. Now we want to get the file data by using the new function we created for that purpose.

The updated test will look like that:

Much better! By keeping the code cleaner, we are helping our future selves with its maintenance - trust me, you'll be very glad to see this.

Improving the response validation

Great! Now, let's have a look at the response validation.

In some cases, we want to check the full response body - or at least some parts of it - to fulfill the test requirements.

To do that, we'll create:

A new Repository to abstract the responsibility and help us check the full JSON response body
A function to handle the check of the JSON response.

We'll also add the "jsonassert" dependency to assert the JSON.

The pom.xml file will look like that:

The newly created ResponseUtils class will be something like this:

The next step should be to use this new function and improve our test. To do that, we'll configure a GET request on YourApiService and return the full Response object. Then we should be able to check the response body.

public Response getRequest(String endpoint) {

    return RestAssured.given(spec)
        .contentType(ContentType.JSON)
    .when()
        .get(endpoint);
}

Now, it's just a matter of adding the test case to the ApiTest test class and using the same strategy of letting the JSON response file be in its proper directory. Finally, we'll have something like this:

@Test
public void testGetUser() throws IOException, JSONException {

    Response res = yourApiService.getRequest("/users/2");

    JsonNode expectedResponse = FileUtils.readJsonFromFile("responses/user/specific.json");

    assertThat(res.statusCode(), is(equalTo(200)));
    ResponseUtils.assertJson(res, expectedResponse);
}

Quite easy to understand if you just look at the test case :)

Executing the tests over multiple environments

Now we have the tests properly set, and everything is in the right place. One thing that could be in your mind right now is: "Ok, but I have a scenario in my product in which I need to run my test suit over multiple environments. How do I do that?".

And the answer is - property files.

The property files are used to store specific data which we can use along our test suit, like the application host, port, and path to the API. You can also store environment variables to use within your test framework. However, be careful since we don't want to make this information public. You can see an example in the lines below.

With Spring boot, we take advantage of using the "profiles" to set the specifics of the environments our application has, and make them available as Spring boot profiles.

So, let's do that. Inside the resources folder, we'll create a new file called application-prod.properties to store the values of the production cluster of the test application. The file will store something like this:

apitest.base.uri=https://reqres.in
apitest.base.path=/api
apitest.token=${TOKEN}

Now, the only thing missing is to change our service to get the values stored in the property file.

To get the values from the property files, we'll use the annotation @Value. This annotation will provide the values from the properties we set in the application-prod.properties file.

*Bear in mind: * You'll need to set the environment variable before using it here. The @Value annotation will grab this value from the environment variables you have set.

The updated version of YourApiService class will look like this:

That's a great step up. This way, if you have multiple environments in your setup, you just need to create another application-YOUR_PROFILE_NAME.properties.

Executing the test suit

You must be wondering: How do I run the test suit with this newly created profile?

The answer is simple, just execute mvn clean test -Dspring.profiles.active=prod.

By default, if you just run the mvn clean test command, Spring Boot will try to find a file called application.properties and automatically activate it.

Now we have significantly improved the test setup of our application by:

The refactoring of the Object mapping to clean up our code and apply some best practices
Improving the response validation by adding a new dependency and using it to simplify the check
Learning how to handle multiple test environments. This should be useful when it comes to companies that have layers of environments before the code reach production

Are you curious about the article? Building a Java API test framework part 3 will further improve our application. We will then go deeper into the following topics:

Test reporting with Allure reports
Configure a CI pipeline with GitHub actions
Publish the test report on GitHub pages

See you soon!

API Testing with Java and Spring Boot Test - Part 1: The basic setup

Luiz Eduardo Martins — Fri, 16 Dec 2022 14:12:08 +0000

At Mercedes-benz.io (MB.io), we collaborate as multiple multi-disciplinary teams (nothing new to a Scrum-based organization).

I'm part of one of those teams, responsible for a Java-based microservice. Since this microservice sends data to a back-office application, we need to test the APIs provided by it.

With that said, we had the challenge to build a new API test framework from scratch.

In this series of articles we'll show:

How we choose the tools
The process of creating and improving the test framework
Pipeline configuration
Test report

Choosing the language and framework

The main reason why we went for a Java-based framework is that the background of our team is Java and the microservice itself is written in this language. Our team is composed of Java developers, so they can contribute to building the right solution for our team and also maintain the code base of the test repository in case it's needed.

The test framework we've chosen to be the base of our solution was Rest Assured.io. The reason behind it is that rest assured is already used in several projects within our tribe at MB.io and is also widely used and maintained in the community.

We also added Spring Boot to organize, structure and be the foundation of the project.

Setting up the project

Step 1: Create the project

We choose Maven as our dependencies manager. Now, the first thing to do is to add the dependencies we need in our project.

Tip: You can use the spring boot initializer to get the basic pom.xml file with the spring initial setup.

After the initial setup, we need to add the dependencies for the rest-assured test framework and other things we'll use to make our lives easier.

The pom.xml file should be something like that:

With this, we should be able to start organizing our project.

Step 2: Changing the `Main` class

The Main class should be changed to a SpringBootApplication. And the main method must be configured to run as a SpringApplication.

Step 3: Create a `Service` to manage your API

To abstract access and configure the requests in one single place, we can create a new Service and take advantage of it.

Here is the place to set the proper configuration of the requests.

Let's create a new method here to abstract the use of a post request. In this post request, we'll provide the URL and the JSON body as parameters, so the file will be something like this:

Note: We'll return the full response to be able to validate what we want within the test itself.

As you can see in the file above, we also take advantage of the built-in RequestSpecification that Rest-assured has to set the baseURI and basePath for this service. This is a smart way to configure your service because if you have more than one service in our test framework, each of them can have its setup and host.

Step 4: Add a test case

First things first, let's add the proper annotations to be a spring boot JUnit 5 test class.

@ExtendWith(SpringExtension.class)
@SpringBootTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS)

After that, let's add a constructor method and assign the Service to be used in our test as a class variable.

private final YourApiService yourApiService;

public ApiTest(YourApiService yourApiService) {

    this.yourApiService = yourApiService;
}

Now we are good to start adding the test cases here. Let's do that.

The postRequest method expects two parameters:

the endpoint we want to send the data as a String;
the request body as a JsonNode.

The first thing we want to do is create an object to send in the request body of our request. We'll take advantage of the jackson-databind library to help us with the object mapping.

@Test
public void testCreateUser() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();

    String body = "{\"name\": \"Luiz Eduardo\", \"job\": \"Senior QA Engineer\"}";
    JsonNode requestBody = mapper.readTree(body);
}

Now, we need to make the request and validate what we want. Let's add that to our test case. The final results should be something like that:

Note: Bear in mind that this is just the first iteration, we'll improve the code to keep the responsibilities within the respective classes.

What we've seen so far:

The project's basic setup
How to structure the project
How to abstract the requests in the service layer
The first functional test case

This is the end of part 1 of this series of articles. The next part will cover:

A short refactor on the object mapping
Improve the response validation
Property files