lynkr 7.2.5 → 8.0.1

package/test/comprehensive-test-suite.js

@@ -1,928 +0,0 @@
-/**
- * Comprehensive Test Suite
- *
- * Tests all production hardening features:
- * - Option 1: Retries, budgets, rate limits, path allowlisting, sandboxing, safe commands (42 tests)
- * - Option 2 & 3: Metrics, health checks, shutdown, logging, errors, validation, load shedding, circuit breakers (38 tests)
- * - Total: 80 tests
- */
-
-const Database = require("better-sqlite3");
-const path = require("path");
-const fs = require("fs");
-
-// Test utilities
-function colorize(text, color) {
-  const colors = {
-    green: "\x1b[32m",
-    red: "\x1b[31m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    cyan: "\x1b[36m",
-    reset: "\x1b[0m",
-  };
-  return `${colors[color] || ""}${text}${colors.reset}`;
-}
-
-function formatResult(passed, total) {
-  const percentage = ((passed / total) * 100).toFixed(1);
-  const color = percentage === "100.0" ? "green" : percentage >= "80.0" ? "yellow" : "red";
-  return colorize(`${passed}/${total} (${percentage}%)`, color);
-}
-
-// Test results tracking
-const results = {
-  total: 0,
-  passed: 0,
-  failed: 0,
-  tests: [],
-  sections: [],
-};
-
-function test(name, fn) {
-  results.total++;
-  try {
-    fn();
-    results.passed++;
-    results.tests.push({ name, passed: true });
-    console.log(colorize("✓", "green"), name);
-    return true;
-  } catch (error) {
-    results.failed++;
-    results.tests.push({ name, passed: false, error: error.message });
-    console.log(colorize("✗", "red"), name);
-    console.log(colorize(`  Error: ${error.message}`, "red"));
-    return false;
-  }
-}
-
-async function asyncTest(name, fn) {
-  results.total++;
-  try {
-    await fn();
-    results.passed++;
-    results.tests.push({ name, passed: true });
-    console.log(colorize("✓", "green"), name);
-    return true;
-  } catch (error) {
-    results.failed++;
-    results.tests.push({ name, passed: false, error: error.message });
-    console.log(colorize("✗", "red"), name);
-    console.log(colorize(`  Error: ${error.message}`, "red"));
-    return false;
-  }
-}
-
-function section(name) {
-  console.log(colorize(`\n=== ${name} ===`, "blue"));
-  const sectionStart = results.total;
-  results.sections.push({ name, startIndex: sectionStart });
-}
-
-// =============================================================================
-// OPTION 1: CRITICAL PRODUCTION FEATURES
-// =============================================================================
-
-async function testOption1Features() {
-  console.log(colorize("\n╔═══════════════════════════════════════════════════╗", "cyan"));
-  console.log(colorize("║              OPTION 1: CRITICAL FEATURES          ║", "cyan"));
-  console.log(colorize("╚═══════════════════════════════════════════════════╝", "cyan"));
-
-  // Feature 1 & 2: Retry Logic and 429 Handling
-  section("Feature 1 & 2: Retry Logic and 429 Handling");
-
-  const { withRetry, calculateDelay, isRetryable, DEFAULT_CONFIG } = require("./src/clients/retry");
-
-  test("Retry config has required fields", () => {
-    if (!DEFAULT_CONFIG.maxRetries) throw new Error("Missing maxRetries");
-    if (!DEFAULT_CONFIG.initialDelay) throw new Error("Missing initialDelay");
-    if (!DEFAULT_CONFIG.maxDelay) throw new Error("Missing maxDelay");
-    if (!DEFAULT_CONFIG.retryableStatuses) throw new Error("Missing retryableStatuses");
-  });
-
-  test("Exponential backoff increases delays", () => {
-    const delay0 = calculateDelay(0, DEFAULT_CONFIG);
-    const delay1 = calculateDelay(1, DEFAULT_CONFIG);
-    const delay2 = calculateDelay(2, DEFAULT_CONFIG);
-
-    if (delay1 <= delay0) throw new Error(`Delay 1 (${delay1}) should be > delay 0 (${delay0})`);
-    if (delay2 <= delay1) throw new Error(`Delay 2 (${delay2}) should be > delay 1 (${delay1})`);
-  });
-
-  test("Delays have jitter applied", () => {
-    const delay1 = calculateDelay(1, DEFAULT_CONFIG);
-    const delay2 = calculateDelay(1, DEFAULT_CONFIG);
-    // Jitter means delays should vary slightly
-    if (delay1 === delay2) {
-      // This might occasionally be equal, but unlikely
-      console.log("  Note: Jitter caused same delay (rare but possible)");
-    }
-  });
-
-  test("429 status is retryable", () => {
-    const retryable = isRetryable(null, { status: 429 }, DEFAULT_CONFIG);
-    if (!retryable) throw new Error("429 should be retryable");
-  });
-
-  test("500 status is retryable", () => {
-    const retryable = isRetryable(null, { status: 500 }, DEFAULT_CONFIG);
-    if (!retryable) throw new Error("500 should be retryable");
-  });
-
-  test("200 status is not retryable", () => {
-    const retryable = isRetryable(null, { status: 200 }, DEFAULT_CONFIG);
-    if (retryable) throw new Error("200 should not be retryable");
-  });
-
-  test("ECONNRESET error is retryable", () => {
-    const retryable = isRetryable({ code: "ECONNRESET" }, null, DEFAULT_CONFIG);
-    if (!retryable) throw new Error("ECONNRESET should be retryable");
-  });
-
-  await asyncTest("withRetry succeeds on first attempt", async () => {
-    let attempts = 0;
-    const result = await withRetry(async () => {
-      attempts++;
-      return { status: 200, ok: true };
-    });
-    if (!result.ok) throw new Error("Should succeed");
-    if (attempts !== 1) throw new Error(`Expected 1 attempt, got ${attempts}`);
-  });
-
-  await asyncTest("withRetry retries on failure then succeeds", async () => {
-    let attempts = 0;
-    const result = await withRetry(async () => {
-      attempts++;
-      if (attempts === 1) {
-        return { status: 500, ok: false };
-      }
-      return { status: 200, ok: true };
-    }, { maxRetries: 2, initialDelay: 10 });
-
-    if (!result.ok) throw new Error("Should eventually succeed");
-    if (attempts !== 2) throw new Error(`Expected 2 attempts, got ${attempts}`);
-  });
-
-  // Feature 3: Budget and Rate Limiting
-  section("Feature 3: Budget and Rate Limiting");
-
-  const { getBudgetManager, BudgetManager } = require("./src/budget");
-
-  test("BudgetManager can be instantiated", () => {
-    const manager = new BudgetManager({ enabled: true });
-    if (!manager.db) throw new Error("Database not initialized");
-  });
-
-  test("getBudgetManager returns singleton", () => {
-    const manager1 = getBudgetManager();
-    const manager2 = getBudgetManager();
-    if (manager1 !== manager2) throw new Error("Should return same instance");
-  });
-
-  test("Rate limit allows first request", () => {
-    const manager = new BudgetManager({ enabled: true });
-    const result = manager.checkRateLimit("test-user-first");
-    if (!result.allowed) throw new Error("First request should be allowed");
-  });
-
-  test("Rate limit has per-minute window", () => {
-    const manager = new BudgetManager({ enabled: true });
-    const userId = "test-user-window";
-    const result = manager.checkRateLimit(userId);
-    if (!result.allowed) throw new Error("Should be allowed");
-  });
-
-  test("Budget check allows when no budget configured", () => {
-    const manager = new BudgetManager({ enabled: true });
-    const result = manager.checkBudget("test-user-no-budget");
-    if (!result.allowed) throw new Error("Should allow when no budget configured");
-  });
-
-  test("Can set user budget", () => {
-    const manager = new BudgetManager({ enabled: true });
-    manager.setBudget("test-user-budget-set", {
-      monthlyTokenLimit: 100000,
-      monthlyRequestLimit: 1000,
-      monthlyCostLimit: 10.0,
-    });
-
-    const result = manager.checkBudget("test-user-budget-set");
-    if (!result.allowed) throw new Error("Should allow within budget");
-  });
-
-  test("Can record usage", () => {
-    const manager = new BudgetManager({ enabled: true });
-    manager.recordUsage("test-user-usage", "session-123", {
-      tokensInput: 100,
-      tokensOutput: 50,
-      costUsd: 0.01,
-      model: "test-model",
-    });
-    // Should not throw
-  });
-
-  test("Can get usage summary", () => {
-    const manager = new BudgetManager({ enabled: true });
-    const summary = manager.getUsageSummary("test-user-summary", 30);
-    if (!summary) throw new Error("Should return summary");
-    if (!summary.usage) throw new Error("Summary should have usage");
-  });
-
-  test("Budget warnings work", () => {
-    const manager = new BudgetManager({ enabled: true });
-    const userId = "test-user-warnings-check";
-
-    manager.setBudget(userId, {
-      monthlyTokenLimit: 1000,
-      monthlyRequestLimit: 100,
-      monthlyCostLimit: 1.0,
-      alertThreshold: 0.8,
-    });
-
-    // Record usage at 85% (850 tokens)
-    manager.recordUsage(userId, "session-1", {
-      tokensInput: 850,
-      tokensOutput: 0,
-      costUsd: 0.85,
-    });
-
-    const result = manager.checkBudget(userId);
-    // Warnings may or may not trigger depending on database state
-    // Just check the structure exists
-    if (result.warnings === undefined) throw new Error("Should have warnings field");
-  });
-
-  // Feature 4: Path Allowlisting
-  section("Feature 4: Path Allowlisting");
-
-  const config = require("./src/config");
-
-  test("Config has fileAccess settings", () => {
-    if (!config.policy) throw new Error("Missing policy config");
-    if (!config.policy.fileAccess) throw new Error("Missing fileAccess config");
-  });
-
-  test("Default blocked paths include sensitive files", () => {
-    const blockedPaths = config.policy.fileAccess.blockedPaths || [];
-    const hasEnv = blockedPaths.some(p => p.includes(".env"));
-    const hasPasswd = blockedPaths.some(p => p.includes("passwd"));
-
-    if (!hasEnv) throw new Error("Should block .env files");
-    if (!hasPasswd) throw new Error("Should block /etc/passwd");
-  });
-
-  test("Policy module can be loaded", () => {
-    const policy = require("./src/policy");
-    if (!policy.evaluateToolCall) throw new Error("Missing evaluateToolCall");
-  });
-
-  test("File read tool is registered", () => {
-    const workspace = require("./src/tools/workspace");
-    if (!workspace.registerWorkspaceTools) {
-      throw new Error("registerWorkspaceTools not found");
-    }
-  });
-
-  // Feature 5: Container Sandboxing
-  section("Feature 5: Container Sandboxing");
-
-  test("Sandbox config exists", () => {
-    if (!config.mcp) throw new Error("Missing mcp config");
-    if (!config.mcp.sandbox) throw new Error("Missing sandbox config");
-  });
-
-  test("Security options are configured", () => {
-    const sandbox = config.mcp.sandbox;
-    if (sandbox.readOnlyRoot === undefined) throw new Error("Missing readOnlyRoot");
-    if (sandbox.noNewPrivileges === undefined) throw new Error("Missing noNewPrivileges");
-  });
-
-  test("Resource limits are configured", () => {
-    const sandbox = config.mcp.sandbox;
-    if (!sandbox.memoryLimit) throw new Error("Missing memoryLimit");
-    if (!sandbox.cpuLimit) throw new Error("Missing cpuLimit");
-    if (!sandbox.pidsLimit) throw new Error("Missing pidsLimit");
-  });
-
-  test("Capability management is configured", () => {
-    const sandbox = config.mcp.sandbox;
-    if (!sandbox.dropCapabilities) throw new Error("Missing dropCapabilities");
-    if (!sandbox.addCapabilities) throw new Error("Missing addCapabilities");
-  });
-
-  test("Default drops ALL capabilities", () => {
-    const sandbox = config.mcp.sandbox;
-    const dropsAll = sandbox.dropCapabilities.includes("ALL");
-    if (!dropsAll) throw new Error("Should drop ALL capabilities by default");
-  });
-
-  test("Sandbox module can be loaded", () => {
-    const sandbox = require("./src/mcp/sandbox");
-    if (!sandbox.isSandboxEnabled) throw new Error("Missing isSandboxEnabled");
-    if (!sandbox.runSandboxProcess) throw new Error("Missing runSandboxProcess");
-  });
-
-  test("Process module has sandbox integration", () => {
-    const process = require("./src/tools/process");
-    if (!process.runProcess) throw new Error("Missing runProcess");
-  });
-
-  // Feature 6: Safe Command DSL
-  section("Feature 6: Safe Command DSL");
-
-  const { SafeCommandDSL, getSafeCommandDSL, DEFAULT_SAFE_COMMANDS } = require("./src/policy/safe-commands");
-
-  test("SafeCommandDSL can be instantiated", () => {
-    const dsl = new SafeCommandDSL();
-    if (!dsl.evaluate) throw new Error("Missing evaluate method");
-  });
-
-  test("Default safe commands are defined", () => {
-    if (!DEFAULT_SAFE_COMMANDS.ls) throw new Error("Missing 'ls' command");
-    if (!DEFAULT_SAFE_COMMANDS.git) throw new Error("Missing 'git' command");
-    if (!DEFAULT_SAFE_COMMANDS.rm) throw new Error("Missing 'rm' command");
-  });
-
-  test("'ls' command is allowed", () => {
-    const dsl = new SafeCommandDSL();
-    const result = dsl.evaluate("ls -la");
-    if (!result.allowed) throw new Error("'ls -la' should be allowed");
-  });
-
-  test("'rm -rf /' is blocked", () => {
-    const dsl = new SafeCommandDSL();
-    const result = dsl.evaluate("rm -rf /");
-    if (result.allowed) throw new Error("'rm -rf /' should be blocked");
-  });
-
-  test("'git status' is allowed", () => {
-    const dsl = new SafeCommandDSL();
-    const result = dsl.evaluate("git status");
-    if (!result.allowed) throw new Error("'git status' should be allowed");
-  });
-
-  test("'git push --force' is blocked", () => {
-    const dsl = new SafeCommandDSL();
-    const result = dsl.evaluate("git push --force");
-    if (result.allowed) throw new Error("'git push --force' should be blocked");
-  });
-
-  test("Commands with disallowed flags are blocked", () => {
-    const dsl = new SafeCommandDSL();
-    const result = dsl.evaluate("find . -delete");
-    if (result.allowed) throw new Error("'find -delete' should be blocked");
-  });
-
-  test("Pattern matching works for blocked patterns", () => {
-    const dsl = new SafeCommandDSL();
-    const result = dsl.evaluate("cat /etc/passwd");
-    if (result.allowed) throw new Error("'cat /etc/passwd' should be blocked");
-  });
-
-  test("Can get list of allowed commands", () => {
-    const dsl = new SafeCommandDSL();
-    const allowed = dsl.getAllowedCommands();
-    if (!Array.isArray(allowed)) throw new Error("Should return array");
-    if (allowed.length === 0) throw new Error("Should have allowed commands");
-  });
-
-  test("Can get list of blocked commands", () => {
-    const dsl = new SafeCommandDSL();
-    const blocked = dsl.getBlockedCommands();
-    if (!Array.isArray(blocked)) throw new Error("Should return array");
-    if (blocked.length === 0) throw new Error("Should have blocked commands");
-  });
-
-  test("Can add custom rules", () => {
-    const dsl = new SafeCommandDSL();
-    dsl.addRule("mycmd", { allowed: true, description: "My custom command" });
-    const rule = dsl.getRule("mycmd");
-    if (!rule) throw new Error("Rule not added");
-    if (rule.description !== "My custom command") throw new Error("Wrong description");
-  });
-
-  test("getSafeCommandDSL returns singleton", () => {
-    const dsl1 = getSafeCommandDSL();
-    const dsl2 = getSafeCommandDSL();
-    if (dsl1 !== dsl2) throw new Error("Should return same instance");
-  });
-
-  test("Policy module uses Safe Command DSL", () => {
-    const policyCode = fs.readFileSync("./src/policy/index.js", "utf8");
-    const usesDSL = policyCode.includes("getSafeCommandDSL");
-    if (!usesDSL) throw new Error("Policy should use Safe Command DSL");
-  });
-}
-
-// =============================================================================
-// OPTION 2 & 3: IMPORTANT & NICE-TO-HAVE FEATURES
-// =============================================================================
-
-async function testOption2And3Features() {
-  console.log(colorize("\n╔═══════════════════════════════════════════════════╗", "cyan"));
-  console.log(colorize("║          OPTION 2 & 3: IMPORTANT FEATURES         ║", "cyan"));
-  console.log(colorize("╚═══════════════════════════════════════════════════╝", "cyan"));
-
-  // Feature 7: Observability/Metrics Export
-  section("Feature 7: Observability/Metrics Export");
-
-  const { MetricsCollector } = require("./src/observability/metrics");
-
-  test("MetricsCollector initializes correctly", () => {
-    const metrics = new MetricsCollector();
-    if (metrics.requestCount === undefined) throw new Error("Missing requestCount");
-    if (metrics.startTime === undefined) throw new Error("Missing startTime");
-  });
-
-  test("Can record HTTP requests", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordRequest("GET", "/test", 200, 100);
-    if (metrics.requestCount !== 1) throw new Error("Request not recorded");
-  });
-
-  test("Can record token usage", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordTokens(100, 50);
-    if (metrics.tokensInput !== 100) throw new Error("Input tokens not recorded");
-    if (metrics.tokensOutput !== 50) throw new Error("Output tokens not recorded");
-    if (metrics.tokensTotal !== 150) throw new Error("Total tokens wrong");
-  });
-
-  test("Can record API costs", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordCost(1.50);
-    if (metrics.totalCost !== 1.50) throw new Error("Cost not recorded");
-  });
-
-  test("Calculates latency statistics", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordRequest("GET", "/test", 200, 100);
-    metrics.recordRequest("GET", "/test", 200, 200);
-    metrics.recordRequest("GET", "/test", 200, 150);
-
-    const stats = metrics.calculateLatencyStats();
-    if (stats.min !== 100) throw new Error("Min latency wrong");
-    if (stats.max !== 200) throw new Error("Max latency wrong");
-    if (stats.mean !== 150) throw new Error("Mean latency wrong");
-  });
-
-  test("Can get metrics snapshot", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordRequest("GET", "/test", 200, 100);
-    const snapshot = metrics.getMetrics();
-
-    if (!snapshot.requests_total) throw new Error("Missing requests_total");
-    if (!snapshot.latency_ms) throw new Error("Missing latency_ms");
-  });
-
-  test("Can export Prometheus format", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordRequest("GET", "/test", 200, 100);
-    const prom = metrics.toPrometheus();
-
-    if (!prom.includes("http_requests_total")) throw new Error("Missing counter");
-    if (!prom.includes("# HELP")) throw new Error("Missing help text");
-    if (!prom.includes("# TYPE")) throw new Error("Missing type text");
-  });
-
-  test("Tracks requests by status code", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordRequest("GET", "/test", 200, 100);
-    metrics.recordRequest("GET", "/test", 404, 50);
-    metrics.recordRequest("GET", "/test", 200, 75);
-
-    const snapshot = metrics.getMetrics();
-    if (snapshot.status_codes[200] !== 2) throw new Error("Wrong 200 count");
-    if (snapshot.status_codes[404] !== 1) throw new Error("Wrong 404 count");
-  });
-
-  test("Tracks requests by endpoint", () => {
-    const metrics = new MetricsCollector();
-    metrics.recordRequest("GET", "/v1/messages", 200, 100);
-    metrics.recordRequest("POST", "/v1/messages", 200, 200);
-    metrics.recordRequest("GET", "/v1/messages", 200, 150);
-
-    const snapshot = metrics.getMetrics();
-    if (snapshot.endpoints["GET /v1/messages"] !== 2) throw new Error("Wrong GET count");
-    if (snapshot.endpoints["POST /v1/messages"] !== 1) throw new Error("Wrong POST count");
-  });
-
-  // Feature 8: Health Check Endpoints
-  section("Feature 8: Health Check Endpoints");
-
-  const { livenessCheck, readinessCheck } = require("./src/api/health");
-
-  await asyncTest("Liveness check returns 200", async () => {
-    const req = {};
-    const res = {
-      status: (code) => {
-        if (code !== 200) throw new Error(`Expected 200, got ${code}`);
-        return res;
-      },
-      json: (body) => {
-        if (body.status !== "alive") throw new Error("Expected status: alive");
-      },
-    };
-
-    livenessCheck(req, res);
-  });
-
-  await asyncTest("Readiness check has correct structure", async () => {
-    const req = { query: {} };
-    const res = {
-      statusCode: null,
-      status: function (code) {
-        this.statusCode = code;
-        return this;
-      },
-      json: (body) => {
-        if (!body.status) throw new Error("Missing status");
-        if (!body.timestamp) throw new Error("Missing timestamp");
-        if (!body.checks) throw new Error("Missing checks");
-      },
-    };
-
-    await readinessCheck(req, res);
-  });
-
-  test("Memory check detects usage", () => {
-    const memUsage = process.memoryUsage();
-    if (!memUsage.heapUsed) throw new Error("No heap usage data");
-    if (!memUsage.heapTotal) throw new Error("No heap total data");
-  });
-
-  // Feature 9: Graceful Shutdown
-  section("Feature 9: Graceful Shutdown");
-
-  const { ShutdownManager } = require("./src/server/shutdown");
-
-  test("ShutdownManager can be instantiated", () => {
-    const manager = new ShutdownManager();
-    if (!manager.timeout) throw new Error("Missing timeout");
-  });
-
-  test("Tracks connections", () => {
-    const manager = new ShutdownManager();
-    const mockConn = {
-      on: () => {},
-    };
-
-    const mockServer = {
-      on: (event, handler) => {
-        if (event === "connection") {
-          handler(mockConn);
-        }
-      },
-    };
-
-    manager.registerServer(mockServer);
-    if (manager.connections.size !== 1) throw new Error("Connection not tracked");
-  });
-
-  test("Shutdown not started by default", () => {
-    const manager = new ShutdownManager();
-    if (manager.isShuttingDown) throw new Error("Should not be shutting down");
-  });
-
-  // Feature 10: Structured Request Logging
-  section("Feature 10: Structured Request Logging");
-
-  test("Generates unique request IDs", () => {
-    const crypto = require("crypto");
-    const id1 = crypto.randomBytes(16).toString("hex");
-    const id2 = crypto.randomBytes(16).toString("hex");
-    if (id1 === id2) throw new Error("IDs should be unique");
-    if (id1.length !== 32) throw new Error("ID should be 32 chars");
-  });
-
-  test("Request ID is hex string", () => {
-    const crypto = require("crypto");
-    const id = crypto.randomBytes(16).toString("hex");
-    if (!/^[0-9a-f]+$/.test(id)) throw new Error("ID should be hex");
-  });
-
-  // Feature 11: Consistent Error Handling
-  section("Feature 11: Consistent Error Handling");
-
-  const {
-    AppError,
-    BadRequestError,
-    NotFoundError,
-  } = require("./src/api/middleware/error-handling");
-
-  test("AppError has required fields", () => {
-    const err = new AppError("Test error", 400, "test_error");
-    if (err.statusCode !== 400) throw new Error("Wrong status code");
-    if (err.code !== "test_error") throw new Error("Wrong error code");
-    if (!err.isOperational) throw new Error("Should be operational");
-  });
-
-  test("BadRequestError sets correct defaults", () => {
-    const err = new BadRequestError("Invalid input");
-    if (err.statusCode !== 400) throw new Error("Wrong status code");
-    if (err.code !== "bad_request") throw new Error("Wrong error code");
-  });
-
-  test("NotFoundError sets correct defaults", () => {
-    const err = new NotFoundError("Resource not found");
-    if (err.statusCode !== 404) throw new Error("Wrong status code");
-    if (err.code !== "not_found") throw new Error("Wrong error code");
-  });
-
-  test("Errors can include details", () => {
-    const details = { field: "email", message: "Invalid format" };
-    const err = new BadRequestError("Validation failed", details);
-    if (!err.details) throw new Error("Missing details");
-    if (err.details.field !== "email") throw new Error("Wrong details");
-  });
-
-  // Feature 12: Input Validation
-  section("Feature 12: Input Validation");
-
-  const { validateObject } = require("./src/api/middleware/validation");
-
-  test("Validates required fields", () => {
-    const schema = {
-      required: ["name", "email"],
-      properties: {
-        name: { type: "string" },
-        email: { type: "string" },
-      },
-    };
-
-    const errors = validateObject({}, schema);
-    if (errors.length < 2) throw new Error(`Expected at least 2 errors, got ${errors.length}`);
-  });
-
-  test("Validates field types", () => {
-    const schema = {
-      properties: {
-        age: { type: "number" },
-      },
-    };
-
-    const errors = validateObject({ age: "twenty" }, schema);
-    if (errors.length === 0) throw new Error("Should have type error");
-  });
-
-  test("Validates string length", () => {
-    const schema = {
-      properties: {
-        name: { type: "string", minLength: 3, maxLength: 10 },
-      },
-    };
-
-    const errors1 = validateObject({ name: "AB" }, schema);
-    if (errors1.length === 0) throw new Error("Should fail minLength");
-
-    const errors2 = validateObject({ name: "ABCDEFGHIJK" }, schema);
-    if (errors2.length === 0) throw new Error("Should fail maxLength");
-
-    const errors3 = validateObject({ name: "ABCDE" }, schema);
-    if (errors3.length !== 0) throw new Error("Should pass validation");
-  });
-
-  test("Validates enum values", () => {
-    const schema = {
-      properties: {
-        role: { type: "string", enum: ["user", "admin", "guest"] },
-      },
-    };
-
-    const errors = validateObject({ role: "superuser" }, schema);
-    if (errors.length === 0) throw new Error("Should fail enum validation");
-  });
-
-  test("Validates number ranges", () => {
-    const schema = {
-      properties: {
-        age: { type: "number", minimum: 0, maximum: 120 },
-      },
-    };
-
-    const errors1 = validateObject({ age: -1 }, schema);
-    if (errors1.length === 0) throw new Error("Should fail minimum");
-
-    const errors2 = validateObject({ age: 150 }, schema);
-    if (errors2.length === 0) throw new Error("Should fail maximum");
-  });
-
-  // Feature 14: Load Shedding
-  section("Feature 14: Load Shedding");
-
-  const { LoadShedder } = require("./src/api/middleware/load-shedding");
-
-  test("LoadShedder can be instantiated", () => {
-    const shedder = new LoadShedder();
-    if (!shedder.heapThreshold) throw new Error("Missing heapThreshold");
-    if (!shedder.activeRequestsThreshold) throw new Error("Missing activeRequestsThreshold");
-  });
-
-  test("System not overloaded by default", () => {
-    const shedder = new LoadShedder();
-    if (shedder.isOverloaded()) throw new Error("Should not be overloaded");
-  });
-
-  test("Tracks active requests", () => {
-    const shedder = new LoadShedder();
-    shedder.activeRequests = 500;
-    if (shedder.activeRequests !== 500) throw new Error("Not tracking correctly");
-  });
-
-  test("Overload detection works", () => {
-    const shedder = new LoadShedder({ activeRequestsThreshold: 100 });
-    shedder.activeRequests = 150;
-    shedder.lastCheck = 0; // Force recheck
-    // Detection may vary based on actual system state
-    const isOverloaded = shedder.isOverloaded();
-    // Just check it returns a boolean
-    if (typeof isOverloaded !== "boolean") throw new Error("Should return boolean");
-  });
-
-  test("Provides load shedding metrics", () => {
-    const shedder = new LoadShedder();
-    const metrics = shedder.getMetrics();
-    if (metrics.activeRequests === undefined) throw new Error("Missing activeRequests");
-    if (metrics.totalShed === undefined) throw new Error("Missing totalShed");
-  });
-
-  // Feature 15: Circuit Breakers
-  section("Feature 15: Circuit Breakers");
-
-  const { CircuitBreaker, STATE } = require("./src/clients/circuit-breaker");
-
-  test("CircuitBreaker can be instantiated", () => {
-    const breaker = new CircuitBreaker("test");
-    if (breaker.state !== STATE.CLOSED) throw new Error("Should start CLOSED");
-  });
-
-  await asyncTest("Executes function successfully", async () => {
-    const breaker = new CircuitBreaker("test");
-    const result = await breaker.execute(async () => {
-      return "success";
-    });
-    if (result !== "success") throw new Error("Wrong result");
-  });
-
-  await asyncTest("Tracks failures", async () => {
-    const breaker = new CircuitBreaker("test", { failureThreshold: 3 });
-
-    try {
-      await breaker.execute(async () => {
-        throw new Error("Test failure");
-      });
-    } catch (err) {
-      // Expected
-    }
-
-    if (breaker.failureCount !== 1) throw new Error("Failure not tracked");
-  });
-
-  await asyncTest("Opens circuit after failure threshold", async () => {
-    const breaker = new CircuitBreaker("test", { failureThreshold: 2 });
-
-    // First failure
-    try {
-      await breaker.execute(async () => {
-        throw new Error("Fail 1");
-      });
-    } catch (err) {}
-
-    // Second failure
-    try {
-      await breaker.execute(async () => {
-        throw new Error("Fail 2");
-      });
-    } catch (err) {}
-
-    if (breaker.state !== STATE.OPEN) throw new Error("Should be OPEN");
-  });
-
-  await asyncTest("Fails fast when circuit is open", async () => {
-    const breaker = new CircuitBreaker("test", { failureThreshold: 1, timeout: 60000 });
-
-    // Cause failure to open circuit
-    try {
-      await breaker.execute(async () => {
-        throw new Error("Fail");
-      });
-    } catch (err) {}
-
-    // Should fail fast
-    let failedFast = false;
-    try {
-      await breaker.execute(async () => {
-        return "should not reach";
-      });
-    } catch (err) {
-      if (err.code === "circuit_breaker_open") {
-        failedFast = true;
-      }
-    }
-
-    if (!failedFast) throw new Error("Should fail fast");
-  });
-
-  test("Can get circuit breaker state", () => {
-    const breaker = new CircuitBreaker("test");
-    const state = breaker.getState();
-
-    if (!state.name) throw new Error("Missing name");
-    if (!state.state) throw new Error("Missing state");
-    if (!state.stats) throw new Error("Missing stats");
-  });
-
-  test("Can manually reset circuit breaker", () => {
-    const breaker = new CircuitBreaker("test");
-    breaker.failureCount = 5;
-    breaker.state = STATE.OPEN;
-
-    breaker.reset();
-
-    if (breaker.state !== STATE.CLOSED) throw new Error("Should be CLOSED");
-    if (breaker.failureCount !== 0) throw new Error("Failure count should be reset");
-  });
-}
-
-// =============================================================================
-// Main Test Runner
-// =============================================================================
-
-async function runAllTests() {
-  console.log(colorize("\n╔═══════════════════════════════════════════════════╗", "blue"));
-  console.log(colorize("║      Comprehensive Production Hardening Tests    ║", "blue"));
-  console.log(colorize("║           80 Tests: Options 1, 2 & 3              ║", "blue"));
-  console.log(colorize("╚═══════════════════════════════════════════════════╝", "blue"));
-
-  try {
-    await testOption1Features();
-    await testOption2And3Features();
-
-    // Summary
-    console.log(colorize("\n" + "=".repeat(60), "blue"));
-    console.log(colorize("FINAL TEST SUMMARY", "blue"));
-    console.log(colorize("=".repeat(60), "blue"));
-    console.log(`Total tests:  ${results.total}`);
-    console.log(`Passed:       ${colorize(results.passed.toString(), "green")}`);
-    console.log(`Failed:       ${colorize(results.failed.toString(), results.failed > 0 ? "red" : "green")}`);
-    console.log(`Success rate: ${formatResult(results.passed, results.total)}`);
-
-    // Section breakdown
-    console.log(colorize("\n" + "=".repeat(60), "blue"));
-    console.log(colorize("Breakdown by Feature", "blue"));
-    console.log(colorize("=".repeat(60), "blue"));
-
-    let currentSection = null;
-    let sectionPassed = 0;
-    let sectionTotal = 0;
-
-    results.tests.forEach((test, index) => {
-      const section = results.sections.find(
-        (s, i) =>
-          index >= s.startIndex &&
-          (i === results.sections.length - 1 || index < results.sections[i + 1].startIndex)
-      );
-
-      if (section && section !== currentSection) {
-        if (currentSection) {
-          console.log(`  ${formatResult(sectionPassed, sectionTotal)}`);
-        }
-        currentSection = section;
-        sectionPassed = 0;
-        sectionTotal = 0;
-        console.log(`\n${section.name}`);
-      }
-
-      sectionTotal++;
-      if (test.passed) sectionPassed++;
-    });
-
-    if (currentSection) {
-      console.log(`  ${formatResult(sectionPassed, sectionTotal)}`);
-    }
-
-    if (results.failed > 0) {
-      console.log(colorize("\n" + "=".repeat(60), "red"));
-      console.log(colorize("Failed Tests:", "red"));
-      console.log(colorize("=".repeat(60), "red"));
-      results.tests
-        .filter((t) => !t.passed)
-        .forEach((t) => {
-          console.log(colorize(`  ✗ ${t.name}`, "red"));
-          console.log(colorize(`    ${t.error}`, "red"));
-        });
-    }
-
-    console.log(colorize("\n" + "=".repeat(60), "blue"));
-
-    // Exit with appropriate code
-    process.exit(results.failed > 0 ? 1 : 0);
-  } catch (error) {
-    console.error(colorize("\nFatal error running tests:", "red"));
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-// Run tests
-runAllTests();