Load tests

Author: KillerX

backend/.gitignore

@@ -58,3 +58,6 @@ tmp/
 *~
 \#*\#
 .\#*
+
+# Load testing
+cmd/loadtest/config.json

backend/Makefile

@@ -95,3 +95,33 @@ jaeger-logs: ## View Jaeger logs
 
 jaeger-ps: ## Show Jaeger container status
 	@cd ../docker/jaeger && docker compose ps
+
+## Load Testing Commands
+
+loadtest-gen: ## Generate JWT tokens for load testing (run after seed-large)
+	@echo "Generating load test tokens..."
+	@go run ./cmd/loadtest/tokengen -limit 1000 -output ./cmd/loadtest/config.json
+
+loadtest-gen-all: ## Generate tokens for all seeded users (up to 10k)
+	@echo "Generating load test tokens for all users..."
+	@go run ./cmd/loadtest/tokengen -limit 10000 -output ./cmd/loadtest/config.json
+
+loadtest: loadtest-gen ## Run default load test (50 VUs, 5 minutes)
+	@echo "Running load test..."
+	@k6 run ./cmd/loadtest/k6/steady.js
+
+loadtest-quick: loadtest-gen ## Run quick load test (10 VUs, 1 minute)
+	@echo "Running quick load test..."
+	@k6 run --env STEADY_VUS=10 --env DURATION=1m ./cmd/loadtest/k6/steady.js
+
+loadtest-stress: loadtest-gen-all ## Run stress test (200 VUs, 10 minutes)
+	@echo "Running stress test..."
+	@k6 run --env STEADY_VUS=200 --env DURATION=10m ./cmd/loadtest/k6/steady.js
+
+loadtest-spike: loadtest-gen ## Run spike test only (500 VUs)
+	@echo "Running spike test..."
+	@k6 run --env SPIKE_PEAK=500 --env SPIKE_HOLD=2m ./cmd/loadtest/k6/spike.js
+
+loadtest-leaderboard: loadtest-gen ## Run leaderboard stress test only (100 RPS)
+	@echo "Running leaderboard stress test..."
+	@k6 run --env LEADERBOARD_RPS=100 --env LEADERBOARD_DURATION=5m ./cmd/loadtest/k6/leaderboard.js

backend/cmd/loadtest/README.md

@@ -0,0 +1,141 @@
+# Load Testing
+
+k6-based load testing for the Wayfarer GraphQL API.
+
+## Prerequisites
+
+1. Install k6:
+   ```bash
+   brew install k6  # macOS
+   # or see https://k6.io/docs/getting-started/installation/
+   ```
+
+2. Seed the database with test users:
+   ```bash
+   make seed-large  # Creates 10k users
+   ```
+
+3. Start the server:
+   ```bash
+   make dev
+   ```
+
+## Quick Start
+
+```bash
+# Run the default load test (50 VUs, 5 minutes)
+make loadtest
+
+# Run a quick sanity check (10 VUs, 1 minute)
+make loadtest-quick
+```
+
+## Available Commands
+
+| Command | Description |
+|---------|-------------|
+| `make loadtest` | Default load test: 50 VUs for 5 minutes |
+| `make loadtest-quick` | Quick test: 10 VUs for 1 minute |
+| `make loadtest-stress` | Stress test: 200 VUs for 10 minutes |
+| `make loadtest-spike` | Spike test only: ramp 0 -> 500 -> 0 VUs |
+| `make loadtest-leaderboard` | Leaderboard stress: 100 requests/second |
+| `make loadtest-gen` | Generate tokens only (1000 users) |
+| `make loadtest-gen-all` | Generate tokens for all users (up to 10k) |
+
+## Test Scenarios
+
+### 1. Steady Load (`steady_load`)
+Simulates typical user traffic with weighted distribution:
+- 30% ChallengesPage
+- 20% ProfilePage
+- 20% StandingsGlobalPage
+- 15% StandingsLocalPage
+- 15% StandingsUnitPage
+
+### 2. Spike Test (`spike_test`)
+Simulates sudden traffic surges:
+- Ramps from 0 to 100 VUs in 30s
+- Peaks at 500 VUs for 1 minute
+- Ramps down to 0 over 1 minute
+
+### 3. Leaderboard Stress (`leaderboard_stress`)
+Focused testing of database-intensive leaderboard queries:
+- Constant 100 requests/second
+- 50% global standings, 30% local, 20% team
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `STEADY_VUS` | 50 | Virtual users for steady-state test |
+| `DURATION` | 5m | Duration of steady-state test |
+| `SPIKE_START` | 6m | When spike test starts |
+| `SPIKE_PEAK` | 500 | Peak VUs during spike |
+| `LEADERBOARD_START` | 0s | When leaderboard test starts |
+| `LEADERBOARD_DURATION` | 5m | Duration of leaderboard test |
+| `LEADERBOARD_RPS` | 100 | Requests per second |
+
+### Token Generator Flags
+
+```bash
+go run ./cmd/loadtest/tokengen \
+  -limit 1000 \           # Number of users
+  -output config.json \   # Output file
+  -base-url http://localhost:8080 \  # API URL
+  -valid-days 7 \         # Token validity
+  -secret "your-jwt-secret"  # Override JWT_SECRET
+```
+
+## Thresholds
+
+The test will fail if:
+- p95 response time > 500ms
+- p99 response time > 1000ms
+- Error rate > 1%
+- GraphQL error rate > 1%
+
+## Custom Test Runs
+
+```bash
+# Run with custom parameters
+k6 run --env STEADY_VUS=100 --env DURATION=10m ./cmd/loadtest/k6/scenarios.js
+
+# Run against a different target
+go run ./cmd/loadtest/tokengen -base-url https://staging.api.example.com -output ./cmd/loadtest/config.json
+k6 run ./cmd/loadtest/k6/scenarios.js
+
+# Output JSON results
+k6 run --out json=results.json ./cmd/loadtest/k6/scenarios.js
+```
+
+## Output Metrics
+
+Key metrics to watch:
+- `http_req_duration` - Request latency (p50, p95, p99)
+- `http_req_failed` - Failed request percentage
+- `graphql_errors` - GraphQL-specific errors
+- `http_reqs` - Total requests per second
+- `vus` - Active virtual users
+
+## Files
+
+```
+cmd/loadtest/
+    tokengen/
+        main.go          # Go tool to generate JWT tokens
+    k6/
+        scenarios.js     # Main test script
+        lib/
+            graphql.js   # GraphQL HTTP helpers
+        queries/
+            challenges.js
+            profile.js
+            standings-global.js
+            standings-local.js
+            standings-unit.js
+            challenge.js
+    config.json          # Generated tokens (gitignored)
+    README.md
+```

backend/cmd/loadtest/k6/leaderboard.js

@@ -0,0 +1,51 @@
+import { SharedArray } from 'k6/data';
+
+import { standingsGlobalPage } from './queries/standings-global.js';
+import { standingsLocalPage } from './queries/standings-local.js';
+import { standingsUnitPage } from './queries/standings-unit.js';
+
+const config = JSON.parse(open('../config.json'));
+const tokens = new SharedArray('tokens', function () {
+    return config.tokens;
+});
+const baseUrl = config.baseUrl;
+
+// Leaderboard stress: constant arrival rate
+export const options = {
+    scenarios: {
+        leaderboard_stress: {
+            executor: 'constant-arrival-rate',
+            rate: parseInt(__ENV.LEADERBOARD_RPS) || 100,
+            timeUnit: '1s',
+            duration: __ENV.LEADERBOARD_DURATION || '5m',
+            preAllocatedVUs: parseInt(__ENV.LEADERBOARD_RPS) || 100,
+            maxVUs: 1000,
+        },
+    },
+    thresholds: {
+        http_req_duration: ['p(95)<500', 'p(99)<1000'],
+        http_req_failed: ['rate<0.01'],
+        graphql_errors: ['rate<0.01'],
+    },
+};
+
+function getRandomToken() {
+    return tokens[Math.floor(Math.random() * tokens.length)];
+}
+
+export default function () {
+    const { token } = getRandomToken();
+    const rand = Math.random();
+
+    if (rand < 0.50) {
+        standingsGlobalPage(baseUrl, token);
+    } else if (rand < 0.80) {
+        standingsLocalPage(baseUrl, token);
+    } else {
+        standingsUnitPage(baseUrl, token);
+    }
+}
+
+export function setup() {
+    console.log(`Leaderboard stress: ${tokens.length} users, target ${baseUrl}`);
+}

backend/cmd/loadtest/k6/lib/graphql.js

@@ -0,0 +1,104 @@
+import http from 'k6/http';
+import { check } from 'k6';
+import { Counter, Trend } from 'k6/metrics';
+
+// Custom metrics for GraphQL-specific tracking
+export const graphqlErrors = new Counter('graphql_errors');
+export const graphqlDuration = new Trend('graphql_duration');
+
+/**
+ * Execute a GraphQL request
+ * @param {string} baseUrl - Base URL of the GraphQL API
+ * @param {string} query - GraphQL query string
+ * @param {object} variables - Query variables
+ * @param {string} token - JWT token for authorization
+ * @param {string} operationName - Optional operation name for tagging
+ * @returns {object} HTTP response
+ */
+export function graphqlRequest(baseUrl, query, variables, token, operationName) {
+    const url = `${baseUrl}/graphql`;
+    const payload = JSON.stringify({
+        query: query,
+        variables: variables || {},
+    });
+
+    const params = {
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+        tags: {
+            name: operationName || 'GraphQL',
+        },
+    };
+
+    const startTime = Date.now();
+    const response = http.post(url, payload, params);
+    graphqlDuration.add(Date.now() - startTime, { operation: operationName });
+
+    return response;
+}
+
+/**
+ * Check if a GraphQL response is successful
+ * @param {object} response - HTTP response object
+ * @param {string} queryName - Name of the query for logging
+ * @returns {boolean} Whether the response was successful
+ */
+export function checkGraphQLResponse(response, queryName) {
+    const checks = {
+        [`${queryName}: status is 200`]: (r) => r.status === 200,
+        [`${queryName}: has data`]: (r) => {
+            try {
+                const body = JSON.parse(r.body);
+                return body.data !== undefined && body.data !== null;
+            } catch {
+                return false;
+            }
+        },
+        [`${queryName}: no errors`]: (r) => {
+            try {
+                const body = JSON.parse(r.body);
+                return !body.errors || body.errors.length === 0;
+            } catch {
+                return false;
+            }
+        },
+    };
+
+    const success = check(response, checks);
+
+    if (!success) {
+        graphqlErrors.add(1, { operation: queryName });
+
+        // Log error details for debugging
+        if (response.status !== 200) {
+            console.error(`${queryName}: HTTP ${response.status}`);
+        } else {
+            try {
+                const body = JSON.parse(response.body);
+                if (body.errors) {
+                    console.error(`${queryName}: ${JSON.stringify(body.errors)}`);
+                }
+            } catch {
+                console.error(`${queryName}: Invalid JSON response`);
+            }
+        }
+    }
+
+    return success;
+}
+
+/**
+ * Parse GraphQL response body
+ * @param {object} response - HTTP response object
+ * @returns {object|null} Parsed response data or null on error
+ */
+export function parseResponse(response) {
+    try {
+        const body = JSON.parse(response.body);
+        return body.data;
+    } catch {
+        return null;
+    }
+}