@optimizely/ocp-cli 1.2.13 → 1.2.14

package/src/test/e2e/utils/cli-executor.ts

@@ -0,0 +1,349 @@
+import { execa } from 'execa';
+import { join } from 'path';
+import { EventEmitter } from 'events';
+
+export interface CLIExecutionResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  executionTime: number;
+  timedOut: boolean;
+  isTerminated: boolean;
+  signal?: string;
+}
+
+export interface CLIExecutionOptions {
+  timeout?: number;
+  env?: Record<string, string>;
+  cwd?: string;
+  input?: string;
+  killSignal?: NodeJS.Signals;
+  maxBuffer?: number;
+  encoding?: BufferEncoding;
+}
+
+export interface ProcessInfo {
+  pid?: number;
+  command: string;
+  args: string[];
+  startTime: number;
+  status: 'running' | 'completed' | 'killed' | 'timeout' | 'error';
+  endTime?: number;
+  duration?: number;
+}
+
+export class CLIExecutionError extends Error {
+  constructor(
+    message: string,
+    public readonly result: CLIExecutionResult,
+    public readonly processInfo: ProcessInfo
+  ) {
+    super(message);
+    this.name = 'CLIExecutionError';
+  }
+}
+
+export class CLIExecutor extends EventEmitter {
+  private readonly cliPath: string;
+  private readonly activeProcesses: Map<number, any> = new Map();
+  private readonly processInfoMap: Map<number, ProcessInfo> = new Map();
+  private processCounter = 0;
+  private readonly maxConcurrentProcesses: number;
+
+  constructor(cliPath?: string, maxConcurrentProcesses: number = 10) {
+    super();
+    this.cliPath = cliPath || (global as any).TEST_CONFIG?.CLI_PATH || join(__dirname, '../../../../bin/ocp.js');
+    this.maxConcurrentProcesses = maxConcurrentProcesses;
+  }
+
+  async execute(args: string[], options: CLIExecutionOptions = {}): Promise<CLIExecutionResult> {
+    // Check process limit
+    if (this.activeProcesses.size >= this.maxConcurrentProcesses) {
+      throw new Error(`Maximum concurrent processes limit reached (${this.maxConcurrentProcesses})`);
+    }
+
+    const processId = ++this.processCounter;
+    const startTime = Date.now();
+    const timeout = options.timeout || (global as any).TEST_CONFIG?.DEFAULT_TIMEOUT || 10000;
+
+    const processInfo: ProcessInfo = {
+      command: 'node',
+      args: [this.cliPath, ...args],
+      startTime,
+      status: 'running'
+    };
+
+    try {
+      // Prepare environment variables
+      const processEnv = this.prepareEnvironment(options.env);
+
+      const execaOptions = {
+        env: processEnv,
+        cwd: options.cwd || process.cwd(),
+        timeout,
+        input: options.input,
+        maxBuffer: options.maxBuffer || 1024 * 1024, // 1MB default
+        encoding: 'utf8' as const,
+        killSignal: options.killSignal || 'SIGTERM',
+        reject: false, // Don't throw on non-zero exit codes
+      };
+
+      const subprocess = execa('node', [this.cliPath, ...args], execaOptions);
+      processInfo.pid = subprocess.pid;
+
+      if (subprocess.pid) {
+        this.activeProcesses.set(processId, subprocess);
+        this.processInfoMap.set(processId, processInfo);
+      }
+
+      this.emit('processStarted', { ...processInfo });
+
+      const result = await subprocess;
+      
+      // Clean up
+      this.activeProcesses.delete(processId);
+
+      const cliResult: CLIExecutionResult = {
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+        exitCode: result.exitCode != null ? result.exitCode : 0,
+        executionTime: Math.round(result.durationMs || 0),
+        timedOut: result.timedOut || false,
+        isTerminated: result.isTerminated || false,
+        signal: result.signal
+      };
+
+      // Update process info
+      processInfo.status = 'completed';
+      processInfo.endTime = Date.now();
+      processInfo.duration = Math.round(result.durationMs || 0);
+
+      this.emit('processCompleted', { processInfo: { ...processInfo }, result: cliResult });
+
+      return cliResult;
+
+    } catch (error: any) {
+      // Clean up
+      this.activeProcesses.delete(processId);
+      
+      const executionTime = error.durationMs ? Math.round(error.durationMs) : Date.now() - startTime;
+      processInfo.status = 'error';
+
+      let cliResult: CLIExecutionResult;
+      
+      if (error.stdout !== undefined) {
+        // This is an ExecaError with process results
+        cliResult = {
+          stdout: error.stdout || '',
+          stderr: error.stderr || '',
+          exitCode: error.exitCode != null ? error.exitCode : -1,
+          executionTime,
+          timedOut: error.timedOut || false,
+          isTerminated: error.isTerminated || false,
+          signal: error.signal
+        };
+      } else {
+        // This is a different kind of error
+        cliResult = {
+          stdout: '',
+          stderr: error.message || '',
+          exitCode: -1,
+          executionTime,
+          timedOut: false,
+          isTerminated: false
+        };
+      }
+
+      // Update process info
+      processInfo.endTime = Date.now();
+      processInfo.duration = executionTime;
+
+      const cliError = new CLIExecutionError(
+        `Process execution failed: ${error.message}`,
+        cliResult,
+        processInfo
+      );
+
+      this.emit('processError', { processInfo: { ...processInfo }, error: cliError });
+      
+      // For compatibility, return the result instead of throwing
+      return cliResult;
+    }
+  }
+
+  async executeCommand(command: string, options: CLIExecutionOptions = {}): Promise<CLIExecutionResult> {
+    const args = this.parseCommand(command);
+    return this.execute(args, options);
+  }
+
+  private prepareEnvironment(customEnv?: Record<string, string>): Record<string, string> {
+    // Start with current process environment, filtering out undefined values
+    const baseEnv = Object.fromEntries(
+      Object.entries(process.env).filter(([_, value]) => value !== undefined)
+    ) as Record<string, string>;
+    
+    // Apply test-specific environment variables
+    const testEnv = {
+      NODE_ENV: 'test',
+      OCP_ENV: 'test',
+      // Disable colors for consistent output in tests
+      NO_COLOR: '1',
+      FORCE_COLOR: '0',
+      // Disable interactive prompts
+      CI: '1',
+      // Set consistent locale for predictable output
+      LC_ALL: 'C',
+      LANG: 'C'
+    };
+
+    // Merge environments with custom taking precedence
+    const mergedEnv = {
+      ...baseEnv,
+      ...testEnv,
+      ...customEnv
+    };
+
+    // Filter out any undefined or null values
+    return Object.fromEntries(
+      Object.entries(mergedEnv).filter(([_, value]) => 
+        value !== undefined && value !== null
+      )
+    );
+  }
+
+  private parseCommand(command: string): string[] {
+    // Simple command parsing - handles quoted arguments
+    const args: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = '';
+
+    for (let i = 0; i < command.length; i++) {
+      const char = command[i];
+      
+      if ((char === '"' || char === "'") && !inQuotes) {
+        inQuotes = true;
+        quoteChar = char;
+      } else if (char === quoteChar && inQuotes) {
+        inQuotes = false;
+        quoteChar = '';
+      } else if (char === ' ' && !inQuotes) {
+        if (current.length > 0) {
+          args.push(current);
+          current = '';
+        }
+      } else {
+        current += char;
+      }
+    }
+
+    if (current.length > 0) {
+      args.push(current);
+    }
+
+    return args;
+  }
+
+  async killAllProcesses(signal: NodeJS.Signals = 'SIGTERM'): Promise<void> {
+    if (this.activeProcesses.size === 0) {
+      return;
+    }
+
+    const killPromises = Array.from(this.activeProcesses.values()).map((subprocess: any) =>
+      subprocess.kill(signal).catch((error: any) => {
+        this.emit('warning', `Failed to kill process: ${error}`);
+      })
+    );
+    
+    await Promise.all(killPromises);
+    this.activeProcesses.clear();
+    
+    // Update all remaining process info to killed status
+    for (const processInfo of this.processInfoMap.values()) {
+      if (processInfo.status === 'running') {
+        processInfo.status = 'killed';
+        processInfo.endTime = Date.now();
+        processInfo.duration = processInfo.endTime - processInfo.startTime;
+      }
+    }
+  }
+
+  getActiveProcessCount(): number {
+    return this.activeProcesses.size;
+  }
+
+  getProcessInfo(): ProcessInfo[] {
+    return Array.from(this.processInfoMap.values()).filter(info => 
+      info.status === 'running'
+    );
+  }
+
+  getAllProcessInfo(): ProcessInfo[] {
+    return Array.from(this.processInfoMap.values());
+  }
+
+  getCompletedProcessInfo(): ProcessInfo[] {
+    return Array.from(this.processInfoMap.values()).filter(info => 
+      info.status !== 'running'
+    );
+  }
+
+  isProcessRunning(processId: number): boolean {
+    const processInfo = this.processInfoMap.get(processId);
+    return processInfo?.status === 'running' && this.activeProcesses.has(processId);
+  }
+
+  async waitForProcessCompletion(processId: number, timeoutMs: number = 30000): Promise<ProcessInfo | null> {
+    return new Promise((resolve) => {
+      const processInfo = this.processInfoMap.get(processId);
+      if (!processInfo || processInfo.status !== 'running') {
+        resolve(processInfo || null);
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        resolve(null);
+      }, timeoutMs);
+
+      const checkCompletion = () => {
+        const currentInfo = this.processInfoMap.get(processId);
+        if (currentInfo && currentInfo.status !== 'running') {
+          clearTimeout(timeout);
+          resolve(currentInfo);
+        }
+      };
+
+      // Check periodically
+      const interval = setInterval(checkCompletion, 100);
+      
+      setTimeout(() => {
+        clearInterval(interval);
+      }, timeoutMs);
+    });
+  }
+
+  clearProcessHistory(): void {
+    // Remove completed process info to free memory
+    const completedIds = Array.from(this.processInfoMap.entries())
+      .filter(([_, info]) => info.status !== 'running')
+      .map(([id]) => id);
+    
+    completedIds.forEach(id => this.processInfoMap.delete(id));
+  }
+
+  async destroy(): Promise<void> {
+    // Kill all active processes using the simplified method
+    await this.killAllProcesses('SIGTERM');
+    
+    // Clear all maps
+    this.activeProcesses.clear();
+    this.processInfoMap.clear();
+    
+    // Remove all listeners
+    this.removeAllListeners();
+  }
+
+  getMaxConcurrentProcesses(): number {
+    return this.maxConcurrentProcesses;
+  }
+}

package/src/test/e2e/utils/command-registry.ts

@@ -0,0 +1,99 @@
+import { CommandDiscoveryService, CommandRegistry } from '../lib/command-discovery';
+
+/**
+ * Utility class for working with the command registry
+ */
+export class CommandRegistryUtil {
+  private static instance: CommandRegistryUtil;
+  private registry: CommandRegistry | null = null;
+  private discoveryService: CommandDiscoveryService;
+
+  private constructor() {
+    this.discoveryService = new CommandDiscoveryService();
+  }
+
+  public static getInstance(): CommandRegistryUtil {
+    if (!CommandRegistryUtil.instance) {
+      CommandRegistryUtil.instance = new CommandRegistryUtil();
+    }
+    return CommandRegistryUtil.instance;
+  }
+
+  /**
+   * Get the command registry (cached after first call)
+   */
+  public getRegistry(): CommandRegistry {
+    if (!this.registry) {
+      this.registry = this.discoveryService.discoverCommands();
+    }
+    return this.registry;
+  }
+
+  /**
+   * Get all read-only commands for testing
+   */
+  public getReadOnlyCommands() {
+    return this.getRegistry().readOnlyCommands;
+  }
+
+  /**
+   * Get all state-changing commands
+   */
+  public getStateChangingCommands() {
+    return this.getRegistry().stateChangingCommands;
+  }
+
+  /**
+   * Get commands for a specific namespace
+   */
+  public getCommandsForNamespace(namespace: string) {
+    return this.discoveryService.getCommandsForNamespace(namespace);
+  }
+
+  /**
+   * Get a specific command
+   */
+  public getCommand(namespace: string, commandName: string) {
+    return this.discoveryService.getCommand(namespace, commandName);
+  }
+
+  /**
+   * Generate command signature for CLI execution
+   */
+  public generateCommandSignature(namespace: string, commandName: string): string | null {
+    const command = this.getCommand(namespace, commandName);
+    if (!command) {
+      return null;
+    }
+    return this.discoveryService.generateCommandSignature(command);
+  }
+
+  /**
+   * Get all available namespaces
+   */
+  public getNamespaces(): string[] {
+    return this.getRegistry().namespaces;
+  }
+
+  /**
+   * Print registry statistics
+   */
+  public printStats(): void {
+    const registry = this.getRegistry();
+    console.log('Command Registry Statistics:');
+    console.log(`  Total commands: ${registry.commands.length}`);
+    console.log(`  Namespaces: ${registry.namespaces.length} (${registry.namespaces.join(', ')})`);
+    console.log(`  Read-only commands: ${registry.readOnlyCommands.length}`);
+    console.log(`  State-changing commands: ${registry.stateChangingCommands.length}`);
+  }
+
+  /**
+   * Refresh the registry (re-discover commands)
+   */
+  public refresh(): void {
+    this.registry = null;
+  }
+}
+
+// Export a singleton instance for convenience
+export const commandRegistry = CommandRegistryUtil.getInstance();