Performance Testing

SLA Example for Healthcare System:

- Patient lookup API: P95 < 500ms
- Critical alerts: P99 < 100ms
- Report generation: < 30s for standard reports
- Concurrent users: Support 500 simultaneous users
- Availability: 99.99% during business hours

// load-test.js
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 }, // Ramp up to 100 users
    { duration: '5m', target: 100 }, // Stay at 100 users
    { duration: '2m', target: 0 },   // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95% of requests under 500ms
    http_req_failed: ['rate<0.01'],    // Error rate under 1%
  },
};

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

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

  sleep(1);
}

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

const BASE_URL = 'https://api.example.com';

export default function () {
  // Login
  group('Authentication', function () {
    const loginRes = http.post(`${BASE_URL}/auth/login`, {
      email: 'user@example.com',
      password: 'password123',
    });

    check(loginRes, {
      'login successful': (r) => r.status === 200,
      'has token': (r) => r.json('token') !== undefined,
    });

    const token = loginRes.json('token');

    // Use token for subsequent requests
    const headers = { Authorization: `Bearer ${token}` };

    // Get user profile
    group('User Profile', function () {
      const profileRes = http.get(`${BASE_URL}/profile`, { headers });

      check(profileRes, {
        'profile loaded': (r) => r.status === 200,
        'has user data': (r) => r.json('id') !== undefined,
      });
    });

    // List resources
    group('List Resources', function () {
      const resourcesRes = http.get(`${BASE_URL}/resources`, { headers });

      check(resourcesRes, {
        'resources loaded': (r) => r.status === 200,
        'is array': (r) => Array.isArray(r.json()),
      });
    });
  });
}

// stress-test.js
import http from 'k6/http';
import { check } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 },   // Below normal load
    { duration: '5m', target: 100 },
    { duration: '2m', target: 200 },   // Normal load
    { duration: '5m', target: 200 },
    { duration: '2m', target: 300 },   // Around breaking point
    { duration: '5m', target: 300 },
    { duration: '2m', target: 400 },   // Beyond breaking point
    { duration: '5m', target: 400 },
    { duration: '10m', target: 0 },    // Recovery
  ],
};

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

  check(res, {
    'is healthy': (r) => r.status === 200,
  });
}

// spike-test.js
export const options = {
  stages: [
    { duration: '1m', target: 50 },    // Normal load
    { duration: '10s', target: 500 },  // Spike!
    { duration: '3m', target: 500 },   // Stay at spike
    { duration: '10s', target: 50 },   // Recovery
    { duration: '3m', target: 50 },
    { duration: '10s', target: 500 },  // Another spike
    { duration: '3m', target: 500 },
    { duration: '1m', target: 0 },
  ],
};

import sql from 'k6/x/sql';

const db = sql.open('postgres', 'postgres://user:pass@localhost:5432/test');

export function setup() {
  // Seed test data if needed
}

export default function () {
  // Test simple query
  const results = sql.query(db, 'SELECT * FROM users WHERE id = $1', [1]);

  check(results, {
    'query returns data': (r) => r.length > 0,
  });
}

export function teardown() {
  db.close();
}

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

export const options = {
  scenarios: {
    // Simulate connection exhaustion
    high_concurrency: {
      executor: 'constant-vus',
      vus: 100,  // More than pool size
      duration: '5m',
    },
  },
};

export default function () {
  // Each request acquires a DB connection
  const res = http.get('https://api.example.com/users');

  check(res, {
    'no connection errors': (r) => r.status !== 503,
  });
}

// benchmark.js
import http from 'k6/http';
import { Trend } from 'k6/metrics';

const getUserTrend = new Trend('get_user_duration');
const listUsersTrend = new Trend('list_users_duration');
const createUserTrend = new Trend('create_user_duration');

export const options = {
  vus: 10,
  duration: '5m',
};

export default function () {
  // GET /users/:id
  let res = http.get('https://api.example.com/users/1');
  getUserTrend.add(res.timings.duration);

  // GET /users
  res = http.get('https://api.example.com/users');
  listUsersTrend.add(res.timings.duration);

  // POST /users
  res = http.post('https://api.example.com/users', JSON.stringify({
    name: 'Test User',
    email: `test${Date.now()}@example.com`,
  }), {
    headers: { 'Content-Type': 'application/json' },
  });
  createUserTrend.add(res.timings.duration);
}

// lighthouserc.js
module.exports = {
  ci: {
    collect: {
      url: ['http://localhost:3000/', 'http://localhost:3000/dashboard'],
      numberOfRuns: 3,
    },
    assert: {
      assertions: {
        'categories:performance': ['error', { minScore: 0.9 }],
        'categories:accessibility': ['error', { minScore: 0.9 }],
        'first-contentful-paint': ['error', { maxNumericValue: 2000 }],
        'largest-contentful-paint': ['error', { maxNumericValue: 2500 }],
        'cumulative-layout-shift': ['error', { maxNumericValue: 0.1 }],
        'total-blocking-time': ['error', { maxNumericValue: 300 }],
      },
    },
    upload: {
      target: 'temporary-public-storage',
    },
  },
};

import { test, expect } from '@playwright/test';

test('should meet Web Vitals thresholds', async ({ page }) => {
  await page.goto('/');

  const metrics = await page.evaluate(() => {
    return new Promise((resolve) => {
      const results = {};

      new PerformanceObserver((list) => {
        for (const entry of list.getEntries()) {
          results[entry.name] = entry.value;
        }
      }).observe({ type: 'largest-contentful-paint', buffered: true });

      new PerformanceObserver((list) => {
        for (const entry of list.getEntries()) {
          results.cls = entry.value;
        }
      }).observe({ type: 'layout-shift', buffered: true });

      setTimeout(() => resolve(results), 5000);
    });
  });

  expect(metrics.LCP).toBeLessThan(2500);
  expect(metrics.cls).toBeLessThan(0.1);
});

name: Performance Tests
on:
  push:
    branches: [main]
  schedule:
    - cron: '0 2 * * *'  # Nightly

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

      - name: Start application
        run: docker-compose up -d

      - name: Wait for application
        run: |
          timeout 60 bash -c 'until curl -s http://localhost:3000/health; do sleep 2; done'

      - name: Run k6 load test
        uses: grafana/k6-action@v0.3.0
        with:
          filename: tests/performance/load-test.js

      - name: Run Lighthouse
        uses: treosh/lighthouse-ci-action@v10
        with:
          configPath: ./lighthouserc.js

      - name: Upload results
        uses: actions/upload-artifact@v4
        with:
          name: performance-results
          path: |
            summary.json
            lighthouse-report.html

// baseline-test.js
import http from 'k6/http';
import { check } from 'k6';
import { textSummary } from 'https://jslib.k6.io/k6-summary/0.0.1/index.js';

export const options = {
  vus: 50,
  duration: '10m',
  thresholds: {
    'http_req_duration{endpoint:get_users}': ['p(95)<200'],
    'http_req_duration{endpoint:get_user}': ['p(95)<100'],
    'http_req_duration{endpoint:create_user}': ['p(95)<500'],
  },
};

export default function () {
  // Tag requests for separate metrics
  http.get('https://api.example.com/users', {
    tags: { endpoint: 'get_users' },
  });

  http.get('https://api.example.com/users/1', {
    tags: { endpoint: 'get_user' },
  });
}

export function handleSummary(data) {
  return {
    'stdout': textSummary(data, { indent: ' ', enableColors: true }),
    'summary.json': JSON.stringify(data),
  };
}

// Compare current run against baseline
import { previousRun } from './baseline.json';

export const options = {
  thresholds: {
    // Fail if more than 10% slower than baseline
    http_req_duration: [
      `p(95)<${previousRun.p95 * 1.1}`,
    ],
  },
};