Performance Testing#

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 },   // Hold at 50 users
    { duration: '1m', target: 100 },  // Ramp to 100 users
    { duration: '3m', target: 100 },  // Hold at 100 users
    { duration: '1m', target: 0 },    // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<300', 'p(99)<500'],  // SLO validation
    http_req_failed: ['rate<0.01'],                  // <1% error rate
  },
};

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

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 300ms': (r) => r.timings.duration < 300,
    'body has users': (r) => JSON.parse(r.body).length > 0,
  });

  sleep(1); // Think time between requests
}

# Local run
k6 run load-test.js

# With custom output
k6 run --out json=results.json load-test.js

# With environment variables
k6 run -e API_URL=https://staging.example.com load-test.js

from locust import HttpUser, task, between

class WebsiteUser(HttpUser):
    wait_time = between(1, 3)  # Think time: 1-3 seconds

    def on_start(self):
        """Login on start."""
        self.client.post("/login", json={
            "username": "testuser",
            "password": "testpass"
        })

    @task(3)  # Weight: 3x more likely than other tasks
    def view_items(self):
        self.client.get("/api/items")

    @task(1)
    def create_item(self):
        self.client.post("/api/items", json={
            "name": "Test Item",
            "price": 29.99
        })

    @task(2)
    def view_item_detail(self):
        item_id = 42  # In practice, pick from a pool
        self.client.get(f"/api/items/{item_id}")

# Start with web UI
locust -f locustfile.py --host=https://api.example.com

# Headless mode (for CI)
locust -f locustfile.py --headless -u 100 -r 10 --run-time 5m \
  --host=https://api.example.com

// k6 stress test
export const options = {
  stages: [
    { duration: '2m', target: 100 },   // Normal load
    { duration: '2m', target: 200 },   // High load
    { duration: '2m', target: 500 },   // Very high load
    { duration: '2m', target: 1000 },  // Breaking point?
    { duration: '5m', target: 0 },     // Recovery
  ],
};

// k6 soak test
export const options = {
  stages: [
    { duration: '5m', target: 50 },     // Ramp up
    { duration: '8h', target: 50 },     // Sustained load
    { duration: '5m', target: 0 },      // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],
  },
};

# Python benchmarking with pytest-benchmark
import pytest

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

def test_fibonacci_benchmark(benchmark):
    result = benchmark(fibonacci, 20)
    assert result == 6765

# Using hey (simple HTTP benchmarker)
hey -n 10000 -c 100 -m GET https://api.example.com/health

# Using wrk (scriptable benchmarker)
wrk -t12 -c400 -d30s https://api.example.com/users

import cProfile
import pstats

# Profile a function
profiler = cProfile.Profile()
profiler.enable()
result = expensive_function()
profiler.disable()

# View results
stats = pstats.Stats(profiler)
stats.sort_stats('cumulative')
stats.print_stats(20)  # Top 20 functions

// k6 thresholds map directly to SLOs
export const options = {
  thresholds: {
    // Latency SLOs
    'http_req_duration{endpoint:search}': ['p95<200'],
    'http_req_duration{endpoint:checkout}': ['p99<1000'],

    // Availability SLO
    'http_req_failed': ['rate<0.001'],  // 99.9% success rate

    // Throughput SLO
    'http_reqs': ['rate>100'],  // At least 100 RPS sustained
  },
};

// k6 budget enforcement
export const options = {
  thresholds: {
    // Page load budget
    'http_req_duration{type:page}': ['p95<2000'],

    // API response budget
    'http_req_duration{type:api}': ['p95<300'],

    // Payload size budget (custom metric)
    'response_size': ['p95<50000'],  // 50KB max
  },
};

// Custom metric for response size
import { Trend } from 'k6/metrics';
const responseSize = new Trend('response_size');

export default function () {
  const res = http.get(url);
  responseSize.add(res.body.length);
}

name: Performance Tests
on:
  pull_request:
    branches: [main]

jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run k6 load test
        uses: grafana/k6-action@v0.3.1
        with:
          filename: tests/performance/load-test.js
          flags: --out json=results.json

      - name: Upload results
        uses: actions/upload-artifact@v4
        with:
          name: k6-results
          path: results.json