Load Test Generator

Skill: Load Test Generator

Generate load test scripts for API endpoints with configurable scenarios, thresholds, and reporting.

Trigger

When the user asks to create load tests, stress tests, performance benchmarks, or capacity tests.

Prerequisites

• [ ] Target API endpoints identified
• [ ] Expected load profile known (requests/sec, concurrent users)
• [ ] Performance thresholds defined (latency, error rate)

Steps

Step 1: Choose Tool

Default to k6 unless user specifies otherwise.

Step 2: Identify Scenarios

Step 3: Define Test Configuration

// k6 load test
export const options = {
  scenarios: {
    load_test: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 50 },   // Ramp up
        { duration: '5m', target: 50 },   // Steady state
        { duration: '2m', target: 100 },  // Peak
        { duration: '1m', target: 0 },    // Ramp down
      ],
    },
  },
  thresholds: {
    http_req_duration: ['p(95)<500', 'p(99)<1000'],
    http_req_failed: ['rate<0.01'],
    http_reqs: ['rate>100'],
  },
};

Step 4: Generate Test Script (k6)

import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const BASE_URL = __ENV.BASE_URL || '[API_BASE_URL]';
const AUTH_TOKEN = __ENV.AUTH_TOKEN || '[TEST_TOKEN]';

const errorRate = new Rate('errors');
const latency = new Trend('request_latency');

const headers = {
  'Content-Type': 'application/json',
  'Authorization': `Bearer ${AUTH_TOKEN}`,
};

export default function () {
  // Scenario: List resources
  const listRes = http.get(`${BASE_URL}/api/v1/resources`, { headers });
  check(listRes, {
    'list returns 200': (r) => r.status === 200,
    'list latency < 500ms': (r) => r.timings.duration < 500,
    'list returns array': (r) => JSON.parse(r.body).data.length >= 0,
  });
  errorRate.add(listRes.status !== 200);
  latency.add(listRes.timings.duration);

  sleep(1);

  // Scenario: Create resource
  const payload = JSON.stringify({
    name: `load-test-${Date.now()}`,
    type: 'test',
  });
  const createRes = http.post(`${BASE_URL}/api/v1/resources`, payload, { headers });
  check(createRes, {
    'create returns 201': (r) => r.status === 201,
    'create latency < 1000ms': (r) => r.timings.duration < 1000,
  });
  errorRate.add(createRes.status !== 201);

  sleep(1);
}

Step 5: Add Data-Driven Testing

import { SharedArray } from 'k6/data';
import papaparse from 'https://jslib.k6.io/papaparse/5.1.1/index.js';

const testData = new SharedArray('users', function () {
  return JSON.parse(open('./test-data.json'));
});

export default function () {
  const user = testData[__VU % testData.length];
  // Use user.id, user.email, etc. in requests
}

Step 6: Add Cleanup (Optional)

export function teardown(data) {
  // Clean up test data created during the load test
  http.del(`${BASE_URL}/api/v1/test-data/cleanup`, null, { headers });
}

Step 7: Create Run Scripts

# Smoke test
k6 run --vus 5 --duration 1m load-test.js

# Load test
k6 run load-test.js

# Stress test (override VUs)
k6 run --stage 2m:200,5m:200,2m:0 load-test.js

# With environment variables
k6 run -e BASE_URL=https://staging.example.com -e AUTH_TOKEN=$TOKEN load-test.js

Step 8: Document Thresholds

• [ ] p95 latency target: <500ms
• [ ] p99 latency target: <1000ms
• [ ] Error rate target: <1%
• [ ] Throughput target: >100 RPS
• [ ] Document what "pass" and "fail" mean for each threshold

Rules

• NEVER run load tests against production without explicit approval
• NEVER hardcode credentials — use environment variables
• ALWAYS include think time (sleep) between requests to simulate real users
• ALWAYS include check assertions for response validation
• ALWAYS define thresholds (the test should pass/fail based on performance)
• Use test-specific API tokens, not production credentials
• Clean up test data after runs
• Start with smoke tests before running full load tests

Completion

Load test script with scenarios, thresholds, data-driven testing, and run instructions. Ready to execute locally or in CI.

If a Step Fails

• Don't know expected load: Start with smoke test, baseline current performance
• Auth complexity: Create a dedicated load-test user/token
• Rate limiting blocks tests: Coordinate with ops to allowlist test IP or increase limits
• No staging environment: Use a dedicated load-test environment, never hit production directly