load-testing-patterns

# Load Testing Patterns

Performance validation with k6 for SLO-driven load testing.

## Basic k6 Script Template

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

// Custom metrics
const errorRate = new Rate('errors')
const loginDuration = new Trend('login_duration')

// Thresholds define pass/fail criteria
export const options = {
  thresholds: {
    http_req_duration: ['p(95)<500', 'p(99)<1000'],  // 95th < 500ms, 99th < 1s
    http_req_failed: ['rate<0.01'],                    // Error rate < 1%
    errors: ['rate<0.05'],                             // Custom error rate < 5%
  },
  scenarios: {
    smoke: {
      executor: 'constant-vus',
      vus: 5,
      duration: '1m',
    }
  }
}

export default function () {
  const res = http.get('https://api.example.com/health')

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
    'body has status': (r) => JSON.parse(r.body).status === 'ok',
  }) || errorRate.add(1)

  sleep(1)
}
```

## Load Profiles

```javascript
export const options = {
  scenarios: {
    // 1. Smoke Test: verify system works under minimal load
    smoke: {
      executor: 'constant-vus',
      vus: 3,
      duration: '1m',
    },

    // 2. Load Test: normal expected traffic
    load: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 50 },   // Ramp up
        { duration: '5m', target: 50 },   // Steady state
        { duration: '2m', target: 0 },    // Ramp down
      ],
    },

    // 3. Stress Test: find breaking point
    stress: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 100 },
        { duration: '5m', target: 100 },
        { duration: '2m', target: 200 },  // Beyond normal
        { duration: '5m', target: 200 },
        { duration: '2m', target: 300 },  // Breaking point?
        { duration: '5m', target: 300 },
        { duration: '5m', target: 0 },
      ],
    },

    // 4. Spike Test: sudden traffic surge
    spike: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 10 },
        { duration: '10s', target: 500 },  // Instant spike
        { duration: '1m', target: 500 },
        { duration: '10s', target: 10 },   // Instant drop
        { duration: '1m', target: 10 },
      ],
    },

    // 5. Soak Test: sustained load over time (memory leaks, connection exhaustion)
    soak: {
      executor: 'constant-vus',
      vus: 50,
      duration: '2h',
    },
  }
}
```

## Realistic User Scenarios

```javascript
import http from 'k6/http'
import { check, group, sleep } from 'k6'

const BASE_URL = __ENV.BASE_URL || 'https://api.example.com'

export default function () {
  // Simulate real user journey, not isolated endpoints
  let token

  group('01_login', () => {
    const res = http.post(`${BASE_URL}/auth/login`, JSON.stringify({
      email: `user${__VU}@test.com`,
      password: 'testpass123'
    }), { headers: { 'Content-Type': 'application/json' } })

    check(res, { 'login successful': (r) => r.status === 200 })
    token = JSON.parse(res.body).token
  })

  sleep(Math.random() * 3 + 1)  // Think time: 1-4 seconds

  group('02_browse_products', () => {
    const headers = { Authorization: `Bearer ${token}` }

    const listRes = http.get(`${BASE_URL}/products?page=1&limit=20`, { headers })
    check(listRes, { 'products loaded': (r) => r.status === 200 })

    const products = JSON.parse(listRes.body).data
    if (products.length > 0) {
      const product = products[Math.floor(Math.random() * products.length)]
      const detailRes = http.get(`${BASE_URL}/products/${product.id}`, { headers })
      check(detailRes, { 'product detail loaded': (r) => r.status === 200 })
    }
  })

  sleep(Math.random() * 2 + 1)

  group('03_add_to_cart', () => {
    const res = http.post(`${BASE_URL}/cart/items`, JSON.stringify({
      productId: 'prod_001',
      quantity: 1
    }), {
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${token}`
      }
    })
    check(res, { 'item added to cart': (r) => r.status === 201 })
  })
}
```

## SLO Validation

```javascript
export const options = {
  thresholds: {
    // SLO: Availability > 99.9%
    http_req_failed: ['rate<0.001'],

    // SLO: p50 < 100ms, p95 < 500ms, p99 < 1000ms
    http_req_duration: [
      'p(50)<100',
      'p(95)<500',
      'p(99)<1000',
    ],

    // SLO per endpoint using tags
    'http_req_duration{name:login}': ['p(95)<800'],
    'http_req_duration{name:get_products}': ['p(95)<200'],
    'http_req_duration{name:checkout}': ['p(95)<2000'],

    // SLO: Throughput > 1000 RPS
    http_reqs: ['rate>1000'],
  }
}

// Tag requests for per-endpoint SLOs
export default function () {
  http.get(`${BASE_URL}/products`, { tags: { name: 'get_products' } })
  http.post(`${BASE_URL}/auth/login`, payload, { tags: { name: 'login' } })
}
```

## CI Integration

```yaml
# .github/workflows/load-test.yml
name: Load Test
on:
  pull_request:
    branches: [main]

jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: grafana/k6-action@v0.3.1
        with:
          filename: tests/load/smoke.js
        env:
          BASE_URL: ${{ secrets.STAGING_URL }}

      # k6 exits non-zero if thresholds fail → PR check fails
```

## Checklist

- [ ] Run smoke test on every PR (fast, catches regressions)
- [ ] Load test weekly against staging with production-like data
- [ ] Stress test quarterly to find breaking points
- [ ] Soak test before major releases (2+ hours, detect memory leaks)
- [ ] Thresholds set per endpoint, not just global p95
- [ ] Realistic think times between requests (sleep 1-5s)
- [ ] Use multiple VU scenarios (not everyone does the same thing)
- [ ] Store results in Grafana/InfluxDB for trend analysis

## Anti-Patterns

- Testing only happy paths: include error scenarios (404, 429, 500)
- No think time: unrealistic request rate, not how users behave
- Testing against production without traffic control (use staging)
- Single endpoint tests: real users hit multiple endpoints per session
- Ignoring connection time: p95 duration hides DNS/TLS overhead
- Hardcoded test data: VUs sharing same user account causes contention