@cnrai/pave 0.3.32 → 0.3.34

package/test/run-tests.js

@@ -0,0 +1,643 @@
+/**
+ * Simple test runner for Jest-style tests in Node.js environment
+ * Provides basic describe/test/expect functionality with Jest compatibility
+ *
+ * NOTE: This runner works in sandboxed environments by mocking module requires
+ */
+
+// Track hooks and test state
+let currentSuiteHooks = { beforeEach: [], afterEach: [] };
+let currentSuiteTests = [];
+let isDefiningTests = false; // eslint-disable-line no-unused-vars
+
+// Jest mock implementation
+global.jest = {
+  spyOn(obj, method) {
+    const original = obj[method];
+    const calls = [];
+    const mockFn = function (...args) {
+      calls.push(args);
+      if (mockFn._mockImplementation) {
+        return mockFn._mockImplementation(...args);
+      }
+      return original ? original.apply(obj, args) : undefined;
+    };
+
+    mockFn.mock = { calls };
+    mockFn.mockImplementation = function (impl) {
+      mockFn._mockImplementation = impl;
+      return mockFn;
+    };
+    mockFn.mockRestore = function () {
+      obj[method] = original;
+    };
+    mockFn.mockClear = function () {
+      calls.length = 0;
+      return mockFn;
+    };
+
+    obj[method] = mockFn;
+    return mockFn;
+  },
+  fn(impl) {
+    const calls = [];
+    const mockFn = function (...args) {
+      calls.push(args);
+      if (impl) return impl(...args);
+      return undefined;
+    };
+    mockFn.mock = { calls };
+    mockFn.mockImplementation = function (newImpl) {
+      impl = newImpl;
+      return mockFn;
+    };
+    mockFn.mockClear = function () {
+      calls.length = 0;
+      return mockFn;
+    };
+    return mockFn;
+  },
+};
+
+// beforeEach hook
+global.beforeEach = function (fn) {
+  currentSuiteHooks.beforeEach.push(fn);
+};
+
+// afterEach hook
+global.afterEach = function (fn) {
+  currentSuiteHooks.afterEach.push(fn);
+};
+
+global.describe = function (suiteName, suiteFunction) {
+  // Reset hooks for new suite
+  const previousHooks = { ...currentSuiteHooks };
+  currentSuiteHooks = { beforeEach: [], afterEach: [] };
+  currentSuiteTests = [];
+
+  console.log(`\n📋 ${suiteName}`);
+
+  // Set flag to indicate we're in definition phase
+  isDefiningTests = true;
+
+  // Collect tests
+  try {
+    suiteFunction();
+  } catch (error) {
+    console.log(`❌ ${suiteName} - Setup failed: ${error.message}`);
+    isDefiningTests = false;
+    currentSuiteHooks = previousHooks;
+    throw error;
+  }
+
+  isDefiningTests = false;
+
+  // Run tests with hooks
+  let passed = 0;
+  let failed = 0;
+
+  for (const { testName, testFunction } of currentSuiteTests) {
+    try {
+      // Run beforeEach hooks
+      for (const hook of currentSuiteHooks.beforeEach) {
+        hook();
+      }
+
+      // Run the test
+      testFunction();
+
+      // Run afterEach hooks
+      for (const hook of currentSuiteHooks.afterEach) {
+        try { hook(); } catch (e) { /* ignore cleanup errors */ }
+      }
+
+      console.log(`  ✓ ${testName}`);
+      passed++;
+    } catch (error) {
+      // Still try to run afterEach even on failure
+      for (const hook of currentSuiteHooks.afterEach) {
+        try { hook(); } catch (e) { /* ignore cleanup errors */ }
+      }
+
+      console.log(`  ✗ ${testName} - ${error.message}`);
+      failed++;
+    }
+  }
+
+  // Restore previous hooks (for nested describes)
+  currentSuiteHooks = previousHooks;
+
+  if (failed > 0) {
+    console.log(`❌ ${suiteName} - ${failed} test(s) failed`);
+    throw new Error(`Suite "${suiteName}" had ${failed} failing test(s)`);
+  } else if (passed > 0) {
+    console.log(`✅ ${suiteName} - All ${passed} tests passed`);
+  }
+};
+
+global.test = function (testName, testFunction) {
+  currentSuiteTests.push({ testName, testFunction });
+};
+
+// Alias for test
+global.it = global.test;
+
+global.expect = function (actual) {
+  const matchers = {
+    toBe(expected) {
+      if (actual !== expected) {
+        throw new Error(`Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toEqual(expected) {
+      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        throw new Error(`Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toContain(expected) {
+      const arr = Array.isArray(actual) ? actual : String(actual);
+      if (!arr.includes(expected)) {
+        throw new Error(`Expected "${JSON.stringify(actual)}" to contain "${expected}"`);
+      }
+    },
+    toHaveLength(expected) {
+      if (actual.length !== expected) {
+        throw new Error(`Expected length ${expected}, but got ${actual.length}`);
+      }
+    },
+    toHaveProperty(prop) {
+      if (!actual || !Object.prototype.hasOwnProperty.call(actual, prop)) {
+        throw new Error(`Expected object to have property "${prop}"`);
+      }
+    },
+    toBeGreaterThan(expected) {
+      if (actual <= expected) {
+        throw new Error(`Expected ${actual} to be greater than ${expected}`);
+      }
+    },
+    toBeLessThan(expected) {
+      if (actual >= expected) {
+        throw new Error(`Expected ${actual} to be less than ${expected}`);
+      }
+    },
+    toMatch(regex) {
+      if (typeof regex === 'string') {
+        regex = new RegExp(regex);
+      }
+      if (!regex.test(actual)) {
+        throw new Error(`Expected "${actual}" to match ${regex}`);
+      }
+    },
+    toBeDefined() {
+      if (actual === undefined) {
+        throw new Error('Expected value to be defined');
+      }
+    },
+    toBeUndefined() {
+      if (actual !== undefined) {
+        throw new Error(`Expected undefined, but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toBeTruthy() {
+      if (!actual) {
+        throw new Error(`Expected truthy value, but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toBeFalsy() {
+      if (actual) {
+        throw new Error(`Expected falsy value, but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toBeNull() {
+      if (actual !== null) {
+        throw new Error(`Expected null, but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toBeInstanceOf(expected) {
+      if (!(actual instanceof expected)) {
+        throw new Error(`Expected instance of ${expected.name}`);
+      }
+    },
+    toThrow(expected) {
+      let threw = false;
+      let error = null;
+      try {
+        actual();
+      } catch (e) {
+        threw = true;
+        error = e;
+      }
+      if (!threw) {
+        throw new Error('Expected function to throw');
+      }
+      if (expected && !String(error.message).includes(expected)) {
+        throw new Error(`Expected error message to contain "${expected}", got "${error.message}"`);
+      }
+    },
+    toHaveBeenCalled() {
+      if (!actual || !actual.mock || actual.mock.calls.length === 0) {
+        throw new Error('Expected function to have been called');
+      }
+    },
+    toHaveBeenCalledWith(...expectedArgs) {
+      if (!actual || !actual.mock) {
+        throw new Error('Expected a mock function');
+      }
+      const found = actual.mock.calls.some((call) => {
+        return expectedArgs.every((arg, i) => {
+          if (arg && typeof arg.asymmetricMatch === 'function') {
+            return arg.asymmetricMatch(call[i]);
+          }
+          return JSON.stringify(call[i]) === JSON.stringify(arg);
+        });
+      });
+      if (!found) {
+        throw new Error(`Expected to have been called with ${JSON.stringify(expectedArgs)}, calls: ${JSON.stringify(actual.mock.calls)}`);
+      }
+    },
+    toHaveBeenCalledTimes(expected) {
+      if (!actual || !actual.mock) {
+        throw new Error('Expected a mock function');
+      }
+      if (actual.mock.calls.length !== expected) {
+        throw new Error(`Expected to have been called ${expected} times, but was called ${actual.mock.calls.length} times`);
+      }
+    },
+    not: {
+      toBe(expected) {
+        if (actual === expected) {
+          throw new Error(`Expected ${JSON.stringify(actual)} not to be ${JSON.stringify(expected)}`);
+        }
+      },
+      toEqual(expected) {
+        if (JSON.stringify(actual) === JSON.stringify(expected)) {
+          throw new Error(`Expected ${JSON.stringify(actual)} not to equal ${JSON.stringify(expected)}`);
+        }
+      },
+      toContain(expected) {
+        const arr = Array.isArray(actual) ? actual : String(actual);
+        if (arr.includes(expected)) {
+          throw new Error(`Expected "${JSON.stringify(actual)}" not to contain "${expected}"`);
+        }
+      },
+      toHaveProperty(prop) {
+        if (actual && Object.prototype.hasOwnProperty.call(actual, prop)) {
+          throw new Error(`Expected object not to have property "${prop}"`);
+        }
+      },
+      toHaveBeenCalled() {
+        if (actual && actual.mock && actual.mock.calls.length > 0) {
+          throw new Error(`Expected function not to have been called, but was called ${actual.mock.calls.length} times`);
+        }
+      },
+      toHaveBeenCalledWith(...expectedArgs) {
+        if (!actual || !actual.mock) {
+          throw new Error('Expected a mock function');
+        }
+        const found = actual.mock.calls.some((call) => {
+          return expectedArgs.every((arg, i) => {
+            if (arg && typeof arg.asymmetricMatch === 'function') {
+              return arg.asymmetricMatch(call[i]);
+            }
+            return JSON.stringify(call[i]) === JSON.stringify(arg);
+          });
+        });
+        if (found) {
+          throw new Error(`Expected not to have been called with ${JSON.stringify(expectedArgs)}`);
+        }
+      },
+      toBeDefined() {
+        if (actual !== undefined) {
+          throw new Error(`Expected undefined, but got ${JSON.stringify(actual)}`);
+        }
+      },
+      toBeNull() {
+        if (actual === null) {
+          throw new Error('Expected value not to be null');
+        }
+      },
+    },
+  };
+
+  return matchers;
+};
+
+// Static method for asymmetric string matching
+global.expect.stringContaining = function (expected) {
+  return {
+    asymmetricMatch(actual) {
+      return typeof actual === 'string' && actual.includes(expected);
+    },
+    toString() {
+      return `StringContaining "${expected}"`;
+    },
+  };
+};
+
+// ========================================
+// Mock implementations for local modules
+// ========================================
+
+// Mock parseArgs (from ../lib/args-parser)
+// Default: showTools is true (tool output shown by default)
+// Use --no-tools to disable tool output
+function mockParseArgs(args) {
+  return {
+    command: args[0] || '',
+    commandArgs: args.slice(1).filter((arg) => !arg.startsWith('--') && !arg.startsWith('-')),
+    showTools: !args.includes('--no-tools'), // Default true, --no-tools disables
+    json: args.includes('--json'),
+    verbose: args.includes('--verbose') || args.includes('-v'),
+    noStream: args.includes('--no-stream'),
+  };
+}
+
+function mockShowHelp() {
+  console.log('PAVE - Personal AI Virtual Environment');
+  console.log('');
+  console.log('Usage: pave [command] [options]');
+  console.log('');
+  console.log('Options:');
+  console.log('  --no-tools           Hide tool execution progress/results (default: shown)');
+  console.log('  --json               Output as JSON');
+  console.log('  --verbose, -v        Verbose output');
+  console.log('  --no-stream          Disable streaming output');
+  console.log('');
+  console.log('Examples:');
+  console.log('  pave chat "run bash ls"');
+  console.log('  pave chat --no-tools "summarize files"');
+}
+
+// Mock extractToolCommand (from tool-display-utils)
+function mockExtractToolCommand(toolName, input) {
+  if (!input || typeof input !== 'string') {
+    return toolName;
+  }
+  try {
+    const parsed = JSON.parse(input);
+    if (parsed.command) {
+      return `${toolName} ${parsed.command}`;
+    }
+    return toolName;
+  } catch {
+    return toolName;
+  }
+}
+
+// Mock formatToolOutput
+function mockFormatToolOutput(options) {
+  const { toolName, status, input: _input, output: _output, duration, error: _error, showTools } = options;
+  if (!showTools) return '';
+
+  let result = '';
+  const statusIcon = {
+    running: '🔧',
+    completed: '✅',
+    error: '❌',
+  }[status] || '🔧';
+
+  result += `${statusIcon} ${toolName} ${status}`;
+  if (duration) result += ` (${duration}ms)`;
+  result += '\n';
+
+  return result;
+}
+
+// Mock escapeForShellBox
+function mockEscapeForShellBox(text) {
+  if (!text) return '';
+  return String(text).replace(/[<>&"']/g, (c) => ({
+    '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&#39;',
+  })[c] || c);
+}
+
+// Mock TOOL_COLORS
+const mockToolColors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+// Mock BOX characters
+const mockBOX = {
+  topLeft: '┌',
+  topRight: '┐',
+  bottomLeft: '└',
+  bottomRight: '┘',
+  horizontal: '─',
+  vertical: '│',
+};
+
+// Make mocks available globally for tests
+global.mockModules = {
+  parseArgs: mockParseArgs,
+  showHelp: mockShowHelp,
+  extractToolCommand: mockExtractToolCommand,
+  formatToolOutput: mockFormatToolOutput,
+  escapeForShellBox: mockEscapeForShellBox,
+  TOOL_COLORS: mockToolColors,
+  BOX: mockBOX,
+};
+
+// Module mocking setup
+const path = require('path');
+const fs = require('fs');
+
+// Handle Module requirement for mocking, but only if available
+let Module; let
+  originalLoad;
+try {
+  Module = require('module');
+  originalLoad = Module._load;
+} catch (e) {
+  // Module not available in sandbox, skip mocking
+  // Only log in debug mode to avoid test output noise
+  if (process.env.DEBUG) {
+    console.log('[INFO] Module mocking not available in sandbox environment');
+  }
+}
+
+// Only override Module._load if Module is available
+if (Module && originalLoad) {
+  Module._load = function (request, parent, isMain) {
+    // Check if this is a local module require from a test file
+    // Use path.sep for cross-platform compatibility (Windows uses \test\, Unix uses /test/)
+    if (parent && parent.filename && parent.filename.includes(`${path.sep}test${path.sep}`)) {
+      // Allow certain test files to use the real args-parser (for agent command testing)
+      // Explicitly check for known test file patterns that need real modules
+      const filename = path.basename(parent.filename);
+      const realArgsParserTests = [
+        'args-parser.test.js', // Tests agent command parsing with real parser
+        'agent-parsing.test.js', // Tests agent command parsing
+        'agent-lifecycle.test.js', // Tests agent lifecycle (stop/logs/daemon) parsing
+        'agent-inbox.test.js', // Tests -a/--agent flag parsing with real parser
+        'real-args-parser.test.js', // Any future tests needing real parser
+        'soul-reinject.test.js', // Tests --reinject-interval parsing with real parser
+        'agent-update.test.js', // Tests pave agent update parsing and logic (#279)
+      ];
+      const useRealModules = realArgsParserTests.includes(filename);
+
+      // Handle relative paths to lib modules
+      if (request === '../lib/args-parser' || request === '../lib/args-parser.js') {
+        if (useRealModules) {
+          // Use the real args-parser for agent command tests
+          return originalLoad.apply(this, arguments);
+        }
+        return {
+          parseArgs: mockParseArgs,
+          showHelp: mockShowHelp,
+        };
+      }
+      if (request === '../lib/tool-output-formatter' || request === '../lib/tool-output-formatter.js') {
+        return {
+          formatToolOutput: mockFormatToolOutput,
+          extractToolCommand: mockExtractToolCommand,
+          TOOL_COLORS: mockToolColors,
+          BOX: mockBOX,
+        };
+      }
+      if (request === '../../tui/lib/tool-display-utils' || request === '../../tui/lib/tool-display-utils.js') {
+        return {
+          extractToolCommand: mockExtractToolCommand,
+          escapeForShellBox: mockEscapeForShellBox,
+        };
+      }
+    }
+
+    // For all other requires, use the original
+    return originalLoad.apply(this, arguments);
+  };
+}
+
+// ========================================
+// Run tests
+// ========================================
+
+// Create local aliases for test globals so they're accessible in eval scope.
+// In the sandbox, global.describe is set but 'describe' as a bare identifier isn't
+// accessible inside eval'd code. These locals fix that.
+const describe = global.describe;
+const it = global.it;
+const test = global.test;
+const expect = global.expect;
+const jest = global.jest;
+const beforeEach = global.beforeEach;
+const afterEach = global.afterEach;
+
+console.log('🧪 Running PAVE Test Suite with Jest compatibility...\n');
+if (Module && originalLoad) {
+  console.log('Note: Using mocked modules for sandboxed environment');
+} else {
+  console.log('Note: Module mocking unavailable, using real modules');
+}
+
+const testDir = __dirname;
+const testFiles = fs.readdirSync(testDir)
+  .filter((file) => file.endsWith('.test.js') && file !== 'run-tests.js')
+  .sort();
+
+console.log(`Found ${testFiles.length} test file(s): ${testFiles.join(', ')}\n`);
+
+let totalPassed = 0;
+let totalFailed = 0;
+const failedFiles = [];
+
+// Detect sandbox environment: if Module._load override isn't available,
+// the sandbox's require() wraps modules in an IIFE where global.describe etc.
+// aren't accessible as bare identifiers. In that case for files that fail,
+// we retry by reading the file and eval'ing with globals injected.
+const useSandboxFallback = !Module;
+
+for (const testFile of testFiles) {
+  try {
+    console.log(`\n${'─'.repeat(50)}`);
+    console.log(`🔍 Running ${testFile}...`);
+
+    const testPath = path.join(testDir, testFile);
+
+    // Clear the module from cache if it exists
+    if (require.cache && require.cache[testPath]) {
+      delete require.cache[testPath];
+    }
+
+    // Reset process.exitCode before each test file to prevent leaking
+    // between tests that use process.exitCode for their own failure tracking.
+    const _savedExitCode = process.exitCode;
+    process.exitCode = 0;
+
+    try {
+      require(testPath);
+    } catch (requireError) {
+      // In sandbox mode, if describe/it/expect/test aren't visible as bare identifiers,
+      // retry by reading the file and eval'ing with those globals injected as locals.
+      if (useSandboxFallback && /\b(describe|it|test|expect|jest|beforeEach|afterEach)\b.* is not defined/.test(requireError.message)) {
+        let testContent = fs.readFileSync(testPath, 'utf8');
+        // Strip shebang if present
+        if (testContent.substring(0, 2) === '#!') {
+          const nlIdx = testContent.indexOf('\n');
+          testContent = nlIdx !== -1 ? testContent.substring(nlIdx + 1) : '';
+        }
+        // Create a function with test globals as parameters
+        const fn = new Function(
+          'describe', 'it', 'test', 'expect', 'jest', 'beforeEach', 'afterEach',
+          'require', '__dirname', '__filename', 'module', 'exports',
+          'console', 'process', 'global', 'setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Buffer',
+          testContent,
+        );
+        const modObj = { exports: {} };
+        fn(
+          describe, it, test, expect, jest, beforeEach, afterEach,
+          require, path.dirname(testPath), testPath, modObj, modObj.exports,
+          console, process, global, setTimeout, clearTimeout, setInterval, clearInterval,
+          typeof Buffer !== 'undefined' ? Buffer : undefined,
+        );
+      } else {
+        throw requireError;
+      }
+    }
+
+    // Check if the test file itself signaled failure via process.exitCode
+    if (process.exitCode === 1) {
+      process.exitCode = 0; // Reset so it doesn't affect the runner
+      throw new Error(`${testFile} signaled failure via process.exitCode`);
+    }
+
+    totalPassed++;
+  } catch (error) {
+    console.error(`[ERROR] ❌ ${testFile} failed:`, error.message);
+    if (process.env.VERBOSE) {
+      console.error(error.stack);
+    }
+    failedFiles.push(testFile);
+    totalFailed++;
+  }
+
+  // Always ensure process.exitCode is clean for the next file
+  process.exitCode = 0;
+}
+
+// Restore original Module._load implementation
+if (Module && originalLoad) {
+  Module._load = originalLoad;
+}
+
+console.log(`\n${'═'.repeat(50)}`);
+console.log(`📊 Test Results:`);
+console.log(`   Passed: \x1b[32m${totalPassed}\x1b[0m file(s)`);
+console.log(`   Failed: \x1b[31m${totalFailed}\x1b[0m file(s)`);
+
+if (failedFiles.length > 0) {
+  console.log(`\n   Failed files:`);
+  failedFiles.forEach((f) => console.log(`     - ${f}`));
+}
+
+if (totalFailed > 0) {
+  process.exit(1);
+} else {
+  console.log('\n🎉 All tests passed!');
+}