Add performance tests

Author: pimterry

package.json

@@ -65,10 +65,11 @@
     "build:src": "tsc && chmod +x ./dist/admin/admin-bin.js",
     "build:doc": "typedoc src/main.ts",
     "postbuild:doc": "touch ./typedoc/.nojekyll",
-    "test": "npm run build && npm run test:node && npm run test:browser",
+    "test": "npm run build && npm run test:node && npm run test:browser && npm run test:perf",
     "test:node": "NODE_EXTRA_CA_CERTS=./test/fixtures/test-ca.pem TS_NODE_FILES=true mocha -r ts-node/register 'test/**/*.spec.ts'",
     "test:browser": "npm run with-admin -- karma start",
     "test:browser:debug": "npm run with-admin -- karma start --single-run=false --browsers ChromeWithCert",
+    "test:perf": "NODE_EXTRA_CA_CERTS=./test/fixtures/test-ca.pem TS_NODE_FILES=true mocha -r ts-node/register 'test/performance/*.perf.ts'",
     "admin": "TS_NODE_FILES=true ts-node -e 'require(\"./src/main\").getAdminServer({ debug: true }).start()'",
     "with-admin": "TS_NODE_FILES=true ts-node ./src/admin/admin-bin.ts -c ",
     "ci-tests": "npm run test && catch-uncommitted",
@@ -95,6 +96,7 @@
   },
   "homepage": "https://github.com/httptoolkit/mockttp#readme",
   "devDependencies": {
+    "@types/autocannon": "^7.12.7",
     "@types/base64-arraybuffer": "0.1.0",
     "@types/body-parser": "1.19.1",
     "@types/chai": "4.2.21",
@@ -112,6 +114,7 @@
     "@types/source-map-support": "0.4.2",
     "@types/ws": " 8.5.3",
     "assert": "^2.0.0",
+    "autocannon": "^8.0.0",
     "brotli-wasm": "^1.0.0",
     "browserify-zlib": "^0.2.0",
     "buffer": "^6.0.3",

test/performance/performance-test-helpers.ts

@@ -0,0 +1,127 @@
+import * as autocannon from 'autocannon';
+import { expect } from '../test-utils';
+
+export interface PerformanceResult {
+    throughput: number; // req/sec
+    latency: {
+        mean: number;
+        p50: number;
+        p75: number;
+        p90: number;
+        p99: number;
+        p99_9: number;
+    };
+    duration: number;
+    requests: {
+        total: number;
+        average: number;
+    };
+    errors: number;
+    timeouts: number;
+}
+
+export interface PerformanceTestOptions {
+    url: string;
+    duration?: number; // seconds
+    connections?: number;
+    pipelining?: number;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    body?: string | Buffer;
+    headers?: Record<string, string>;
+}
+
+/**
+ * Run a performance test and return formatted results
+ */
+export async function runPerformanceTest(
+    options: PerformanceTestOptions
+): Promise<PerformanceResult> {
+    const result = await autocannon({
+        url: options.url,
+        duration: options.duration || 10,
+        connections: options.connections || 10,
+        pipelining: options.pipelining || 1,
+        method: options.method || 'GET',
+        body: options.body,
+        headers: options.headers
+    });
+
+    return {
+        throughput: result.requests.average,
+        latency: {
+            mean: result.latency.mean,
+            p50: result.latency.p50,
+            p75: result.latency.p75,
+            p90: result.latency.p90,
+            p99: result.latency.p99,
+            p99_9: result.latency.p99_9
+        },
+        duration: result.duration,
+        requests: {
+            total: result.requests.total,
+            average: result.requests.average
+        },
+        errors: result.errors,
+        timeouts: result.timeouts
+    };
+}
+
+/**
+ * Print performance results in a readable format
+ */
+export function printResults(name: string, result: PerformanceResult): void {
+    console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${name}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Throughput:  ${result.throughput.toFixed(2)} req/sec
+Total Reqs:  ${result.requests.total}
+Duration:    ${result.duration}s
+
+Latency:
+  Mean:      ${result.latency.mean.toFixed(2)}ms
+  p50:       ${result.latency.p50.toFixed(2)}ms
+  p75:       ${result.latency.p75.toFixed(2)}ms
+  p90:       ${result.latency.p90.toFixed(2)}ms
+  p99:       ${result.latency.p99.toFixed(2)}ms
+  p99.9:     ${result.latency.p99_9.toFixed(2)}ms
+
+Errors:      ${result.errors}
+Timeouts:    ${result.timeouts}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    `);
+}
+
+/**
+ * Assert performance meets minimum thresholds
+ */
+export function assertPerformance(
+    result: PerformanceResult,
+    thresholds: {
+        minThroughput?: number;
+        maxP99Latency?: number;
+        maxErrors?: number;
+    }
+): void {
+    if (thresholds.minThroughput !== undefined) {
+        expect(result.throughput).to.be.greaterThan(
+            thresholds.minThroughput,
+            `Throughput ${result.throughput.toFixed(2)} req/sec is below threshold ${thresholds.minThroughput} req/sec`
+        );
+    }
+
+    if (thresholds.maxP99Latency !== undefined) {
+        expect(result.latency.p99).to.be.lessThan(
+            thresholds.maxP99Latency,
+            `P99 latency ${result.latency.p99.toFixed(2)}ms exceeds threshold ${thresholds.maxP99Latency}ms`
+        );
+    }
+
+    if (thresholds.maxErrors !== undefined) {
+        expect(result.errors).to.be.lessThanOrEqual(
+            thresholds.maxErrors,
+            `Errors ${result.errors} exceeds threshold ${thresholds.maxErrors}`
+        );
+    }
+}