The Talent500 Blog

Creating Performance Testing Scripts with JMeter and Gatling to Simulate and Analyze System Performance

Afreen Khalfe

Software applications need to perform optimally to meet user expectations and business requirements. Poor application performance can lead to dissatisfied users, lost revenue, and damage to a company’s reputation. To ensure applications can handle real-world user loads, performance testing is crucial. In this blog, we will explore how to create performance-testing scripts using two popular tools, JMeter and Gatling. We’ll delve into their setup, scripting methods, and how to analyze the gathered data to make informed decisions about application performance improvements.

Why Performance Testing Matters

Performance testing is a crucial aspect of the software development lifecycle. It helps identify bottlenecks and performance issues before an application is deployed to a production environment. The primary objectives of performance testing are:

Performance Testing Tools – JMeter and Gatling

JMeter and Gatling are two popular open-source tools for performance testing, each with its unique strengths.

Apache JMeter

java

import org.apache.jmeter.protocol.http.sampler.HTTPSampler;

import org.apache.jmeter.testelement.TestPlan;

import org.apache.jmeter.threads.ThreadGroup;

import org.apache.jmeter.control.LoopController;

import org.apache.jmeter.engine.StandardJMeterEngine;

import org.apache.jmeter.reporters.ResultCollector;

import org.apache.jmeter.reporters.Summariser;

import org.apache.jmeter.save.SaveService;

import org.apache.jmeter.util.JMeterUtils;

 

public class JMeterPerformanceTest {

 

    public static void main(String[] args) throws Exception {

        // Initialize JMeter

        JMeterUtils.loadJMeterProperties(“jmeter.properties”);

        JMeterUtils.setJMeterHome(“path_to_jmeter_home”);

        JMeterUtils.initLocale();

 

        // Create Test Plan

        TestPlan testPlan = new TestPlan(“Performance Test Plan”);

 

        // Create Thread Group

        ThreadGroup thread group = new ThreadGroup();

        threadGroup.setNumThreads(100);

        threadGroup.setRampUp(10);

        threadGroup.setSamplerController(new LoopController());

 

        // Create HTTP Sampler

        HTTPSampler httpSampler = new HTTPSampler();

        httpSampler.setDomain(“example.com”);

        httpSampler.setPort(80);

        httpSampler.setPath(“/api/endpoint”);

        httpSampler.setMethod(“GET”);

 

        // Add Sampler to Thread Group

        threadGroup.addTestElement(httpSampler);

        threadGroup.addTestElement(new ResultCollector(new Summariser()));

 

        // Assemble Test Plan

        testPlan.addThreadGroup(threadGroup);

        testPlan.addTestElement(httpSampler);

 

        // Save Test Plan to file

        SaveService.saveTree(testPlan, SaveService.getFileOutputStream(“test_plan.jmx”));

 

        // Run Test Plan

        StandardJMeterEngine jMeterEngine = new StandardJMeterEngine();

        jMeterEngine.configure(SaveService.loadProperties(“jmeter.properties”));

        jMeterEngine.run();

    }

}

Gatling

scala

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class GatlingPerformanceTest extends Simulation {
val httpProtocol = http
.baseUrl(“http://example.com”)
.acceptHeader(“application/json”)

val scn = scenario(“Performance Test Scenario”)
.exec(http(“request_1”)
.get(“/api/endpoint”)
)

setUp(
scn.inject(
rampUsers(100) during (10 seconds)
)
).protocols(httpProtocol)
}

Setting Up the Tools

Both JMeter and Gatling require Java to be installed on the system. Ensure that you have the latest version of Java Development Kit (JDK) installed before proceeding.

Setting up JMeter

Setting up Gatling

Creating Performance Testing Scripts

Now that we have the tools set up, let’s dive into creating performance-testing scripts using both JMeter and Gatling.

Performance Testing with JMeter:

Step 1: Creating a Test Plan

Step 2: Configuring Samplers

Step 3: Adding Listeners

Listeners display the test results in various formats like graphs, tables, and trees.

Right-click on the Thread Group and add a listener (e.g., “Summary Report” or “View Results Tree”) to view the results.

Step 4: Running the Test

Performance Testing with Gatling

Step 1: Creating a Gatling Scenario

Step 2: Writing the Gatling Script

Step 3: Executing the Gatling Test

Execute the Gatling command, specifying the simulation class to run the test (e.g., “./bin/gatling.sh -s MySimulation”).

Analyzing Performance Test Results

Both JMeter and Gatling provide valuable performance test results to analyze and draw insights from. The gathered data can help identify performance bottlenecks and areas that require optimization.

JMeter

Gatling

Interpreting Performance Test Results

Understanding the performance test results is vital to make informed decisions and take appropriate actions for system improvement. Here are some essential metrics to consider:

Conclusion

Performance testing is a critical process to ensure applications can handle real-world user loads effectively. Tools like JMeter and Gatling empower developers and testers to create reliable performance testing scripts and gain insights into system behaviour under various conditions. By following best practices and analyzing the test results, teams can identify bottlenecks and optimize their applications for peak performance. Implementing performance testing as an integral part of the development process will lead to more stable, scalable, and high-performing applications, satisfying user expectations and driving business success.

0