1. Overview
Gatling is a popular load-testing tool written in Scala that can help us create high-performance, stress, and load tests on local and cloud machines. Additionally, it’s widely used for testing HTTP servers. By default, Gatling focuses on capturing and analyzing performance indicators such as response time, error rate, etc., without displaying the full HTTP response body.
In this tutorial, we’ll learn how to display a full HTTP response body with Gatling. This can be useful for understanding and debugging server responses during load testing.
2. Project Setup
In this tutorial, we’ll use the Gatling Maven plugin to run a Gatling script. To do this, we need to add the plugin to the pom.xml:
<plugin>
<groupId>io.gatling</groupId>
<artifactId>gatling-maven-plugin</artifactId>
<version>4.3.0</version>
<configuration>
<includes>
<include>org.baeldung.gatling.http.FetchSinglePostSimulation</include>
<include>org.baeldung.gatling.http.FetchSinglePostSimulationLog</include>
</includes>
<runMultipleSimulations>true</runMultipleSimulations>
</configuration>
</plugin>
We configure the plugin to run multiple simulations. Also, we’ll need the Gatling app and Gatling highcharts dependencies:
<dependency>
<groupId>io.gatling</groupId>
<artifactId>gatling-app</artifactId>
<version>3.9.5</version>
</dependency>
<dependency>
<groupId>io.gatling.highcharts</groupId>
<artifactId>gatling-charts-highcharts</artifactId>
<version>3.9.2</version>
<scope>test</scope>
</dependency>
Our goal is to display the HTTP response body obtained from the sample API endpoint https://jsonplaceholder.typicode.com/posts/1 in both the console and a log file.
3. Displaying Full HTTP Response Body With Gatling
Let’s write a simple Gatling simulation class that makes an HTTP request to https://jsonplaceholder.typicode.com/posts/1:
public class FetchSinglePostSimulation extends Simulation {
public FetchSinglePostSimulation() {
HttpProtocolBuilder httpProtocolBuilder = http.baseUrl("https://jsonplaceholder.typicode.com");
ScenarioBuilder scn = scenario("Display Full HTTP Response Body")
.exec(http("GET Request")
.get("/posts/1")
.check(status().is(200))
.check(bodyString().saveAs("responseBody")))
.exec(session -> {
System.out.println("Response Body:");
System.out.println(session.getString("responseBody"));
return session;
});
setUp(scn.injectOpen(atOnceUsers(1))).protocols(httpProtocolBuilder);
}
}
In the code above, we define a new class called FetchSinglePostSimulation, and it extends the Simulation class from the Gatling library.
Next, we create an HttpProtocolBuilder object and set the base URL for the HTTP request to https://jsonplaceholder.typicode.com/.
Then, we define a ScenarioBuilder object. This object helps to define a series of simulation scenarios. First, we start an HTTP request using the exec() method. Next, we specify that the request is a GET request to the /posts/1 endpoint.
Additionally, we check if the HTTP status code of the response is 200. Finally, we save the response body as a string in the session variable responseBody by using the check() method.
Furthermore, we start a custom action that takes a Session object as input. Then, we print the value of responseBody to the console. Finally, we return the session object.
Moreover, the simulation is set up by injecting one user at once into the scenario and configuring the HTTP protocol with the httpProtocolBuilder object we created earlier.
To run the simulation, let’s open the terminal and change to the project’s root directory. Then, let’s run the Gatling test command:
mvn gatling:test
The command generates the simulation report and also outputs the response body to the console. Here’s the response body for the test:
The image above shows the response from the simulation report.
Let’s go further by logging the response in a file instead of outputting it to the console. First, let’s write a method to handle file creation:
void writeFile(String fileName, String content) throws IOException {
try(BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true))){
writer.write(content);
writer.newLine();
}
}
In the method above, we create new instances of BufferedWriter and FileWriter to write the HTTP response body to a text file.
Finally, let’s modify the custom action to write the response body to a file instead of outputting to the console:
public class FetchSinglePostSimulationLog extends Simulation {
public FetchSinglePostSimulationLog() {
HttpProtocolBuilder httpProtocolBuilder = http.baseUrl("https://jsonplaceholder.typicode.com");
ScenarioBuilder scn = scenario("Display Full HTTP Response Body")
.exec(http("GET Request")
.get("/posts/1")
.check(status().is(200))
.check(bodyString().saveAs("responseBody")))
.exec(session -> {
String responseBody = session.getString("responseBody");
try {
writeFile("response_body.log", responseBody);
} catch (IOException e) {
System.err.println("error writing file");
}
return session;
});
setUp(scn.injectOpen(atOnceUsers(1))).protocols(httpProtocolBuilder);
}
}
We modify the custom action by invoking the writeFile() method and adding the file name response_body.log and the HTTP response body as arguments. The writeFile() method performs the operation of logging the response to a file.
4. Conclusion
In this article, we learned how to display on the console the full HTTP response body with Gatling. Additionally, we saw how to log the response to a file instead of outputting it to the console.
As always, the complete source code for the examples is available over on GitHub.
