express-api-stress-tester 2.0.2 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-api-stress-tester",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "High-performance distributed API stress testing platform for Express.js APIs — simulate up to 10M concurrent virtual users",
   "type": "module",
   "main": "src/index.js",
@@ -11,7 +11,7 @@
     "express-api-stress-tester": "src/cli.js"
   },
   "scripts": {
-    "test": "node --experimental-vm-modules node_modules/.bin/jest --forceExit",
+    "test": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js --forceExit",
     "stress": "node src/cli.js"
   },
   "keywords": [

package/src/cli.js

@@ -48,6 +48,40 @@ function printSummary(summary) {
   console.log(`  Result:          ${resultColor(summary.result)}`);
   console.log(chalk.bold.cyan('═══════════════════════════════════════════'));
   console.log('');
+
+  if (summary.statusCodes && typeof summary.statusCodes === 'object') {
+    const codes = Object.entries(summary.statusCodes)
+      .filter(([, c]) => Number(c) > 0)
+      .sort((a, b) => Number(b[1]) - Number(a[1]))
+      .map(([code, count]) => `${code}:${count}`)
+      .join(' ');
+    if (codes) {
+      console.log(chalk.bold('Status Codes:'));
+      console.log(`  ${codes}`);
+      console.log('');
+    }
+  }
+
+  if (summary.perEndpoint && typeof summary.perEndpoint === 'object' && Object.keys(summary.perEndpoint).length > 0) {
+    console.log(chalk.bold('Per-Endpoint Metrics:'));
+    const entries = Object.entries(summary.perEndpoint).sort(
+      (a, b) => (b[1].requestsPerSec || 0) - (a[1].requestsPerSec || 0),
+    );
+    for (const [endpoint, m] of entries) {
+      const codes = m.statusCodes && typeof m.statusCodes === 'object'
+        ? Object.entries(m.statusCodes)
+            .filter(([, c]) => Number(c) > 0)
+            .sort((x, y) => Number(y[1]) - Number(x[1]))
+            .slice(0, 6)
+            .map(([code, count]) => `${code}:${count}`)
+            .join(' ')
+        : '';
+      console.log(
+        `  ${endpoint} | rps=${m.requestsPerSec ?? 0} avg=${m.avgResponseTime ?? 0}ms p95=${m.p95 ?? 0}ms err=${m.errorRate ?? 0}%${codes ? ` codes=${codes}` : ''}`,
+      );
+    }
+    console.log('');
+  }
 }
 
 async function runCommand(configPath, opts) {

package/src/core/worker.js

@@ -94,6 +94,24 @@ let maxLatency = -Infinity;
 const statusCodes = {};
 const perEndpoint = {};
 
+function normalizeBaseForRelativeUrlResolution(base, maybeRelativePath) {
+  if (!base || !maybeRelativePath) return base;
+  if (maybeRelativePath.startsWith('http://') || maybeRelativePath.startsWith('https://')) return base;
+  if (maybeRelativePath.startsWith('/')) return base;
+
+  try {
+    const parsedBase = new URL(base);
+    if (parsedBase.pathname && !parsedBase.pathname.endsWith('/')) {
+      parsedBase.pathname = `${parsedBase.pathname}/`;
+      return parsedBase.toString();
+    }
+  } catch {
+    // ignore
+  }
+
+  return base;
+}
+
 /**
  * Resolve the full URL for a route.
  */
@@ -102,7 +120,8 @@ function resolveUrl(route) {
   const path = route.path || route.url || '';
   try {
     if (path) {
-      return new URL(path, base).toString();
+      const normalizedBase = normalizeBaseForRelativeUrlResolution(base, path);
+      return new URL(path, normalizedBase).toString();
     }
     if (base) {
       return new URL(base).toString();
@@ -159,12 +178,13 @@ function getEndpointMetrics(endpoint) {
       maxLatency: -Infinity,
       responseTimes: [],
       sampleCount: 0,
+      statusCodes: {},
     };
   }
   return perEndpoint[endpoint];
 }
 
-function recordEndpoint(endpoint, elapsedMs, isError) {
+function recordEndpoint(endpoint, elapsedMs, isError, status) {
   const metrics = getEndpointMetrics(endpoint);
   metrics.totalRequests++;
   metrics.totalResponseTime += elapsedMs;
@@ -175,6 +195,9 @@ function recordEndpoint(endpoint, elapsedMs, isError) {
   } else {
     metrics.successCount++;
   }
+  if (status) {
+    metrics.statusCodes[status] = (metrics.statusCodes[status] || 0) + 1;
+  }
   metrics.sampleCount++;
   if (metrics.responseTimes.length < MAX_SAMPLE_SIZE) {
     metrics.responseTimes.push(elapsedMs);
@@ -203,7 +226,7 @@ function recordRequestMetrics({ endpointKey, elapsedMs, isError, status }) {
     successCount++;
   }
 
-  recordEndpoint(endpointKey, elapsedMs, isError);
+  recordEndpoint(endpointKey, elapsedMs, isError, status);
 }
 
 async function applyHeaderPlugins(headers) {
@@ -322,7 +345,9 @@ async function executeRequest(task) {
       parsed = new URL(targetUrl);
     } catch {
       try {
-        parsed = new URL(targetUrl, config.baseUrl || config.url);
+        const base = config.baseUrl || config.url;
+        const normalizedBase = normalizeBaseForRelativeUrlResolution(base, targetUrl);
+        parsed = new URL(targetUrl, normalizedBase);
       } catch (err) {
         throw new Error(
           `Failed to resolve URL "${targetUrl}" with base "${config.baseUrl || config.url}": ${err.message}`,

package/src/metrics/apiMetrics.js

@@ -13,6 +13,7 @@ export class ApiMetrics {
     this.maxLatency = -Infinity;
     this.responseTimes = [];
     this._sampleCount = 0;
+    this.statusCodes = {};
   }
 
   record(responseTimeMs, isError) {
@@ -55,6 +56,14 @@ export class ApiMetrics {
     if (partial.responseTimes) {
       this.mergeResponseTimes(partial.responseTimes);
     }
+
+    if (partial.statusCodes && typeof partial.statusCodes === 'object') {
+      for (const [code, count] of Object.entries(partial.statusCodes)) {
+        const n = Number(count) || 0;
+        if (!n) continue;
+        this.statusCodes[code] = (this.statusCodes[code] || 0) + n;
+      }
+    }
   }
 
   mergeResponseTimes(times) {
@@ -111,6 +120,7 @@ export class ApiMetrics {
       maxLatency: maxLat,
       errorRate: parseFloat(errorRate),
       successRate: parseFloat(successRate),
+      statusCodes: { ...this.statusCodes },
     };
   }
 }

package/src/metrics/metricsCollector.js

@@ -21,6 +21,9 @@ export class MetricsCollector {
     this.responseTimes = [];
     this._sampleCount = 0;
     this.perEndpoint = new Map();
+
+    // Best-effort aggregate status codes across all requests
+    this.statusCodes = {};
   }
 
   start() {
@@ -73,6 +76,14 @@ export class MetricsCollector {
       this.mergeResponseTimes(partial.responseTimes);
     }
 
+    if (partial.statusCodes && typeof partial.statusCodes === 'object') {
+      for (const [code, count] of Object.entries(partial.statusCodes)) {
+        const n = Number(count) || 0;
+        if (!n) continue;
+        this.statusCodes[code] = (this.statusCodes[code] || 0) + n;
+      }
+    }
+
     if (partial.perEndpoint) {
       for (const [endpoint, metrics] of Object.entries(partial.perEndpoint)) {
         this._getEndpointMetrics(endpoint).merge(metrics);
@@ -186,6 +197,7 @@ export class MetricsCollector {
       result: passed ? 'PASSED' : 'FAILED',
       elapsedSeconds: elapsed.toFixed(1),
       perEndpoint: this._buildEndpointSummaries(elapsed),
+      statusCodes: { ...this.statusCodes },
     };
   }
 

package/src/reporting/htmlReport.js

@@ -32,7 +32,7 @@ export function generateHtmlReport(config, summary) {
   ];
 
   const configRows = [
-    ['API URL', config.url || 'N/A'],
+    ['API URL', config.url || config.baseUrl || 'N/A'],
     ['Method', (config.method || 'GET').toUpperCase()],
     ['Concurrent Users', config.concurrency || 1],
     ...(config.duration ? [['Duration', `${config.duration}s`]] : []),

package/src/reporting/reportWriter.js

@@ -26,12 +26,29 @@ export function writeReport(config, summary, reportPath) {
 
 function buildTxtReport(config, summary) {
   const divider = '='.repeat(50);
+  const apiUrl = config.url || config.baseUrl || 'N/A';
+  const method = (() => {
+    if (config.method) return String(config.method).toUpperCase();
+    if (Array.isArray(config.routes) && config.routes.length === 1 && config.routes[0]?.method) {
+      return String(config.routes[0].method).toUpperCase();
+    }
+    if (Array.isArray(config.routes) && config.routes.length > 1) return 'MULTI';
+    return 'GET';
+  })();
+  const statusCodesLine = summary.statusCodes && typeof summary.statusCodes === 'object'
+    ? Object.entries(summary.statusCodes)
+        .filter(([, c]) => Number(c) > 0)
+        .sort((a, b) => Number(b[1]) - Number(a[1]))
+        .slice(0, 8)
+        .map(([code, c]) => `${code}:${c}`)
+        .join(' ')
+    : '';
   const lines = [
     divider,
     `  API Stress Test Report`,
     divider,
-    `API URL:            ${config.url}`,
-    `Method:             ${(config.method || 'GET').toUpperCase()}`,
+    `API URL:            ${apiUrl}`,
+    `Method:             ${method}`,
     `Concurrent Users:   ${config.concurrency || 1}`,
     `Duration (s):       ${summary.elapsedSeconds}`,
     `Total Requests:     ${summary.totalRequests}`,
@@ -45,6 +62,7 @@ function buildTxtReport(config, summary) {
     `Success Rate:       ${summary.successRate}%`,
     `CPU Usage:          ${summary.cpuPercent}%`,
     `Memory Usage:       ${summary.memoryMB}MB`,
+    ...(statusCodesLine ? [`Status Codes:       ${statusCodesLine}`] : []),
     `Result:             ${summary.result}`,
     divider,
     ...(buildEndpointLines(summary.perEndpoint) || []),