Apache JMeter Performance Testing Tutorial

# Verify Java
java -version
# Output: openjdk version "11.0.x"...

# Launch JMeter GUI (from bin folder)
# Windows:
jmeter.bat

# Mac / Linux:
./jmeter.sh

# Launch in CLI (Non-GUI) mode
jmeter -n -t testplan.jmx -l results.csv

<ThreadGroup guiclass="ThreadGroupGui"
             testname="Homepage Load Test">
  <intProp name="ThreadGroup.num_threads">100</intProp>
  <intProp name="ThreadGroup.ramp_time">60</intProp>
  <boolProp name="ThreadGroup.scheduler">true</boolProp>
  <stringProp name="ThreadGroup.duration">300</stringProp>
  <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
</ThreadGroup>
<!-- 100 users, 60s ramp-up, run for 300 seconds -->

/* HTTP Request Sampler Settings:
   Method: POST
   Server: api.example.com
   Path:   /auth/login
   Body:   JSON raw body below */

{
  "username": "${username}",
  "password": "${password}"
}

/* Headers (via HTTP Header Manager):
   Content-Type: application/json
   Accept: application/json       */

/* JSON Assertion Settings:
   Assert JSON Path exists: $.data.userId
   Additionally assert value: true
   Expected value: ${expectedUserId}

   Response Assertion Settings:
   Field to test: Response Code
   Pattern matching rules: Equals
   Patterns to test: 200          */

/* JSR223 Assertion (Groovy) — Custom logic */
def response = new groovy.json.JsonSlurper()
                  .parseText(prev.getResponseDataAsString())

if (response.status != "success") {
    AssertionResult.setFailure(true)
    AssertionResult.setFailureMessage(
        "Expected status=success, got: " + response.status
    )
}

// JSR223 Timer — think time based on scenario
// Simulates realistic: 1–3 seconds think time

import java.util.Random

Random rand = new Random()
long thinkTime = 1000 + (rand.nextInt(2000)) // 1000–3000ms

log.info("Think time: " + thinkTime + "ms")
return thinkTime // Timer returns delay in ms

/* Constant Throughput Timer:
   Target throughput: 120 requests/minute (= 2 RPS)
   Calculate based on: All active threads in current group
   This ensures JMeter maintains exactly 2 RPS
   regardless of how fast individual requests complete  */

/* users.csv file (placed in JMeter bin/ or full path):
   username,password,role
   alice,pass123,admin
   bob,secret99,user
   carol,mypass,user
   ...100 more rows... */

/* CSV Data Set Config Settings:
   Filename:      users.csv
   Variable Names: username,password,role
   Delimiter:     , (comma)
   Recycle on EOF: true  (restart from row 1 when file ends)
   Stop Thread on EOF: false
   Sharing mode:  All threads (all threads share the file)  */

/* In HTTP Request Body — reference variables: */
{
  "username": "${username}",
  "password": "${password}"
}

/* In HTTP Header Manager: */
X-User-Role: ${role}

/* JMeter Functions for dynamic data: */
${__Random(1000,9999)}    // random number between 1000-9999
${__UUID()}               // generate unique UUID
${__time(yyyy-MM-dd)}     // current date formatted
${__counter(TRUE,)}       // incrementing counter per thread

/* STEP 1: POST /auth/login
   Server Response (JSON):
   {
     "status": "success",
     "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
     "userId": 1042
   }

   Add JSON Path Extractor as child of Login sampler:
   Variable Name:       authToken
   JSON Path:           $.token
   Default Value:       EXTRACTION_FAILED
   Match No. (0=Random): 0                           */

/* STEP 2: GET /api/orders (next request)
   Add HTTP Header Manager:
   Authorization: Bearer ${authToken}

   JMeter automatically substitutes the extracted
   token from the Login response into this request */

/* Regular Expression Extractor example:
   Variable Name:    csrfToken
   RegEx:            name="_csrf" value="(.+?)"
   Template:         $1$
   Match No.:        1                             */

/* Verify extraction in Debug Sampler — it shows:
   JMeterVariables: authToken = eyJhbGciO...
   This confirms the token was correctly captured  */

# Basic CLI run — saves results to CSV
jmeter -n -t testplan.jmx -l results.csv

# Run + generate HTML report in one command
jmeter -n -t testplan.jmx -l results.csv -e -o ./reports/

# CLI flags explained:
# -n   : Non-GUI (headless) mode
# -t   : Path to .jmx test plan file
# -l   : Path to results log file (.csv or .jtl)
# -e   : Generate HTML report after test
# -o   : Output folder for HTML report (must be empty)
# -j   : JMeter log file path

# Run with overriding Thread Group properties
jmeter -n -t testplan.jmx -l results.csv \
  -Jthreads=200 \
  -Jrampup=120 \
  -Jduration=600

# Generate HTML report from existing CSV file
# (without re-running the test)
jmeter -g results.csv -o ./reports/

# Run test in distributed mode
# (controller sends to remote agents)
jmeter -n -t testplan.jmx -R agent1_ip,agent2_ip -l results.csv

# bin/user.properties — customize report thresholds

# APDEX thresholds (in milliseconds)
jmeter.reportgenerator.apdex_satisfied_threshold=1000
jmeter.reportgenerator.apdex_tolerated_threshold=3000

# Chart granularity (ms) — 1000 = 1 second ticks
jmeter.reportgenerator.overall_granularity=1000

# Custom report title
jmeter.reportgenerator.report_title=Load Test Report - v2.5.1

# Filter to show only specific transactions
jmeter.reportgenerator.exporter.html.series_filter=\
  ^(Login|SearchProducts|AddToCart|Checkout)(-success|-failure)?$

## PRE-TEST CHECKLIST
☐ Script verified with 1 thread — zero errors in Results Tree
☐ Correlation verified — tokens/session IDs extracted correctly
☐ CSV data set has enough rows for thread count × iterations
☐ Timers added — think time between requests
☐ Assertions added — verify response code AND response body
☐ HTTP Request Defaults set — easy environment switching
☐ All GUI Listeners disabled — only file writer active
☐ JMeter heap increased — -Xmx4g or higher
☐ Results file cleared/renamed — fresh file for this run

## RUN COMMAND
jmeter -n \
  -t testplan.jmx \
  -l results_$(date +%Y%m%d_%H%M).csv \
  -e -o ./report_$(date +%Y%m%d_%H%M)/ \
  -j jmeter_$(date +%Y%m%d_%H%M).log

## POST-TEST ANALYSIS
☐ Error% < 1% for all transactions
☐ 90th percentile within SLA thresholds
☐ Throughput stable (not degrading over time)
☐ No memory/CPU issues on server under test
☐ Response time did not increase as test progressed