Performance Testing

Performance Testing

Validate system behavior under load.

k6 Load Test (JavaScript)

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

export const options = {
  stages: [
    { duration: '30s', target: 20 },  // Ramp up
    { duration: '1m', target: 20 },   // Steady
    { duration: '30s', target: 0 },   // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],  // 95% under 500ms
    http_req_failed: ['rate<0.01'],    // <1% errors
  },
};

export default function () {
  const res = http.get('http://localhost:8500/api/health');

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 200ms': (r) => r.timings.duration < 200,
  });

  sleep(1);
}

Locust Load Test (Python)

from locust import HttpUser, task, between

class APIUser(HttpUser):
    wait_time = between(1, 3)

    @task(3)
    def get_analyses(self):
        self.client.get("/api/analyses")

    @task(1)
    def create_analysis(self):
        self.client.post(
            "/api/analyses",
            json={"url": "https://example.com"}
        )

    def on_start(self):
        """Login before tasks."""
        self.client.post("/api/auth/login", json={
            "email": "test@example.com",
            "password": "password"
        })

Test Types

Load Test

// Normal expected load
export const options = {
  vus: 50,           // Virtual users
  duration: '5m',    // Duration
};

Stress Test

// Find breaking point
export const options = {
  stages: [
    { duration: '2m', target: 100 },
    { duration: '2m', target: 200 },
    { duration: '2m', target: 300 },
    { duration: '2m', target: 400 },
  ],
};

Spike Test

// Sudden traffic surge
export const options = {
  stages: [
    { duration: '10s', target: 10 },
    { duration: '1s', target: 1000 },  // Spike!
    { duration: '3m', target: 1000 },
    { duration: '10s', target: 10 },
  ],
};

Soak Test

// Sustained load (memory leaks)
export const options = {
  vus: 50,
  duration: '4h',
};

Metrics to Track

import { Trend, Counter, Rate } from 'k6/metrics';

const responseTime = new Trend('response_time');
const errors = new Counter('errors');
const successRate = new Rate('success_rate');

export default function () {
  const start = Date.now();
  const res = http.get('http://localhost:8500/api/data');

  responseTime.add(Date.now() - start);

  if (res.status !== 200) {
    errors.add(1);
    successRate.add(false);
  } else {
    successRate.add(true);
  }
}

CI Integration

# GitHub Actions
- name: Run k6 load test
  run: |
    k6 run --out json=results.json tests/load/api.js

- name: Check thresholds
  run: |
    if [ $(jq '.thresholds | .[] | select(.ok == false)' results.json | wc -l) -gt 0 ]; then
      exit 1
    fi

Key Decisions

Common Mistakes

• Testing against production without protection
• No warmup period
• Unrealistic load profiles
• Missing error rate thresholds

Related Skills

• observability-monitoring - Metrics collection
• performance-optimization - Fixing bottlenecks
• e2e-testing - Functional validation

Capability Details

load-testing

Keywords: load test, concurrent users, k6, Locust, ramp up Solves:

• Simulate concurrent user load
• Configure ramp-up patterns
• Test system under expected load

stress-testing

Keywords: stress test, breaking point, peak load, overload Solves:

• Find system breaking points
• Test beyond expected capacity
• Identify failure modes under stress

latency-measurement

Keywords: latency, response time, p95, p99, percentile Solves:

• Measure response time percentiles
• Track latency distribution
• Set latency SLO thresholds

throughput-testing

Keywords: throughput, requests per second, RPS, TPS Solves:

• Measure maximum throughput
• Test transactions per second
• Verify capacity requirements

bottleneck-identification

Keywords: bottleneck, profiling, hot path, performance issue Solves:

• Identify performance bottlenecks
• Profile critical code paths
• Diagnose slow operations

Performance Testing Checklist

Test Planning

• [ ] Define performance goals
• [ ] Identify critical paths
• [ ] Determine test scenarios
• [ ] Set baseline metrics

Test Setup

• [ ] Production-like environment
• [ ] Realistic test data
• [ ] Proper warm-up period
• [ ] Isolated test environment

Metrics

• [ ] Response time (p50, p95, p99)
• [ ] Throughput (requests/sec)
• [ ] Error rate
• [ ] Resource utilization

Load Patterns

• [ ] Steady state
• [ ] Ramp up
• [ ] Spike testing
• [ ] Soak testing

Analysis

• [ ] Identify bottlenecks
• [ ] Compare to baseline
• [ ] Document findings
• [ ] Create action items

k6 Load Testing Patterns

Common patterns for effective performance testing with k6.

Implementation

Staged Ramp-Up Pattern

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

export const options = {
  stages: [
    { duration: '1m', target: 50 },   // Ramp up to 50 users
    { duration: '3m', target: 50 },   // Stay at 50 users
    { duration: '1m', target: 100 },  // Ramp to 100 users
    { duration: '3m', target: 100 },  // Stay at 100 users
    { duration: '2m', target: 0 },    // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500', 'p(99)<1000'],
    http_req_failed: ['rate<0.01'],
    checks: ['rate>0.99'],
  },
};

export default function () {
  const res = http.get('http://localhost:8000/api/health');

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 200ms': (r) => r.timings.duration < 200,
    'body contains status': (r) => r.body.includes('ok'),
  });

  sleep(Math.random() * 2 + 1); // 1-3 second think time
}

Authenticated Requests Pattern

import http from 'k6/http';
import { check } from 'k6';

export function setup() {
  const loginRes = http.post('http://localhost:8000/api/auth/login', {
    email: 'loadtest@example.com',
    password: 'testpassword',
  });

  return { token: loginRes.json('access_token') };
}

export default function (data) {
  const params = {
    headers: { Authorization: `Bearer ${data.token}` },
  };

  const res = http.get('http://localhost:8000/api/protected', params);
  check(res, { 'authenticated request ok': (r) => r.status === 200 });
}

Test Types Summary

Checklist

• [ ] Define realistic thresholds (p95, p99, error rate)
• [ ] Include proper ramp-up period (avoid cold start)
• [ ] Add think time between requests (sleep)
• [ ] Use checks for functional validation
• [ ] Externalize configuration (stages, VUs)
• [ ] Run smoke test before full load test