@optimizely/ocp-cli 1.2.13 → 1.2.14

package/src/test/e2e/lib/base-test.ts

@@ -0,0 +1,150 @@
+import { CLIExecutor, CLIExecutionResult, CLIExecutionOptions } from '../utils/cli-executor';
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { BaselineNormalizer } from '../utils/baseline-normalizer';
+
+export abstract class BaseE2ETest {
+  protected cliExecutor: CLIExecutor;
+  protected testConfig: any;
+
+  constructor() {
+    this.cliExecutor = new CLIExecutor();
+    this.testConfig = (global as any).TEST_CONFIG;
+  }
+
+  /**
+   * Cleanup method to be called after tests
+   */
+  async cleanup(): Promise<void> {
+    if (this.cliExecutor) {
+      await this.cliExecutor.destroy();
+    }
+  }
+
+  /**
+   * Execute a CLI command and return the result
+   */
+  protected async executeCommand(command: string, options: CLIExecutionOptions = {}): Promise<CLIExecutionResult> {
+    return this.cliExecutor.executeCommand(command, options);
+  }
+
+  /**
+   * Execute CLI command with arguments array
+   */
+  protected async execute(args: string[], options: CLIExecutionOptions = {}): Promise<CLIExecutionResult> {
+    return this.cliExecutor.execute(args, options);
+  }
+
+  /**
+   * Load test fixture data
+   */
+  protected loadFixture(fixturePath: string): string {
+    const fullPath = join(this.testConfig.FIXTURES_PATH, fixturePath);
+    if (!existsSync(fullPath)) {
+      throw new Error(`Fixture not found: ${fullPath}`);
+    }
+    return readFileSync(fullPath, 'utf-8');
+  }
+
+  /**
+   * Load JSON fixture data
+   */
+  protected loadJsonFixture<T = any>(fixturePath: string): T {
+    const content = this.loadFixture(fixturePath);
+    return JSON.parse(content);
+  }
+
+  /**
+   * Load baseline data for comparison
+   */
+  protected loadBaseline(baselinePath: string): string {
+    const fullPath = join(this.testConfig.BASELINES_PATH, baselinePath);
+    if (!existsSync(fullPath)) {
+      throw new Error(`Baseline not found: ${fullPath}`);
+    }
+    return readFileSync(fullPath, 'utf-8');
+  }
+
+  /**
+   * Save baseline data (for baseline generation/updates)
+   */
+  protected saveBaseline(baselinePath: string, content: string): void {
+    const fullPath = join(this.testConfig.BASELINES_PATH, baselinePath);
+    const dir = dirname(fullPath);
+    
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    
+    writeFileSync(fullPath, content, 'utf-8');
+  }
+
+  /**
+   * Assert command executed successfully
+   */
+  protected assertSuccess(result: CLIExecutionResult, message?: string): void {
+    expect(result.exitCode).toBe(0);
+    if (message) {
+      expect(result.stderr).toBe('');
+    }
+  }
+
+  /**
+   * Assert command failed with expected exit code
+   */
+  protected assertFailure(result: CLIExecutionResult, expectedExitCode?: number): void {
+    if (expectedExitCode !== undefined) {
+      expect(result.exitCode).toBe(expectedExitCode);
+    } else {
+      expect(result.exitCode).not.toBe(0);
+    }
+  }
+
+  /**
+   * Assert output contains expected text
+   */
+  protected assertOutputContains(result: CLIExecutionResult, expectedText: string): void {
+    expect(result.stdout).toContain(expectedText);
+  }
+
+  /**
+   * Assert output matches baseline with normalization
+   */
+  protected assertOutputMatchesBaseline(result: CLIExecutionResult, baselinePath: string, maxLines?: number): void {
+    const baseline = this.loadBaseline(baselinePath);
+    let actualOutput = result.stdout;
+    
+    // If maxLines is specified, truncate both actual and baseline to first N lines
+    if (maxLines) {
+      actualOutput = this.truncateToLines(actualOutput, maxLines);
+    }
+    
+    const normalizedActual = BaselineNormalizer.normalize(actualOutput);
+    const normalizedBaseline = BaselineNormalizer.normalize(baseline);
+    
+    if (normalizedActual !== normalizedBaseline) {
+      console.log('Expected (baseline):');
+      console.log(normalizedBaseline);
+      console.log('\nActual:');
+      console.log(normalizedActual);
+    }
+    
+    expect(normalizedActual).toBe(normalizedBaseline);
+  }
+
+  /**
+   * Truncate output to first N lines for baseline comparison
+   */
+  private truncateToLines(output: string, maxLines: number): string {
+    const lines = output.split('\n');
+    return lines.slice(0, maxLines).join('\n');
+  }
+
+  /**
+   * Generate or update a baseline file (for development/maintenance)
+   */
+  protected updateBaseline(result: CLIExecutionResult, baselinePath: string): void {
+    const normalizedOutput = BaselineNormalizer.normalize(result.stdout);
+    this.saveBaseline(baselinePath, normalizedOutput);
+  }
+}

package/src/test/e2e/lib/command-discovery.ts

@@ -0,0 +1,324 @@
+import { readdirSync, statSync, readFileSync } from 'fs';
+import { join, extname } from 'path';
+
+export interface CommandParameter {
+  name: string;
+  type: 'param' | 'option' | 'flag';
+  required: boolean;
+  help?: string;
+  shortFlag?: string;
+}
+
+export interface CommandMetadata {
+  namespace: string;
+  commandName: string;
+  methodName: string;
+  help?: string;
+  parameters: CommandParameter[];
+  filePath: string;
+  className: string;
+  isReadOnly: boolean;
+}
+
+export interface CommandRegistry {
+  commands: CommandMetadata[];
+  namespaces: string[];
+  readOnlyCommands: CommandMetadata[];
+  stateChangingCommands: CommandMetadata[];
+}
+
+export class CommandDiscoveryService {
+  private readonly commandsPath: string;
+  private readonly readOnlyPatterns = [
+    // Method name patterns that indicate read-only operations
+    /^(list|get|show|info|status|whoami|whois|search|find|view|display)$/i,
+    // Help-related patterns
+    /help/i,
+    // Status/info patterns
+    /^(runtime)?status$/i
+  ];
+
+  private readonly stateChangingPatterns = [
+    // Method name patterns that indicate state-changing operations
+    /^(create|init|add|update|edit|modify|delete|remove|destroy|terminate|trigger|install|uninstall|publish|unpublish|register|abandon|prepare|package|upgrade|set)$/i
+  ];
+
+  constructor(commandsPath: string = 'src/commands') {
+    this.commandsPath = commandsPath;
+  }
+
+  /**
+   * Discover all commands in the commands directory
+   */
+  public discoverCommands(): CommandRegistry {
+    const commands: CommandMetadata[] = [];
+    
+    this.scanDirectory(this.commandsPath, commands);
+    
+    const namespaces = [...new Set(commands.map(cmd => cmd.namespace))].sort();
+    const readOnlyCommands = commands.filter(cmd => cmd.isReadOnly);
+    const stateChangingCommands = commands.filter(cmd => !cmd.isReadOnly);
+
+    return {
+      commands,
+      namespaces,
+      readOnlyCommands,
+      stateChangingCommands
+    };
+  }
+
+  /**
+   * Get commands for a specific namespace
+   */
+  public getCommandsForNamespace(namespace: string): CommandMetadata[] {
+    const registry = this.discoverCommands();
+    return registry.commands.filter(cmd => cmd.namespace === namespace);
+  }
+
+  /**
+   * Get command by namespace and command name
+   */
+  public getCommand(namespace: string, commandName: string): CommandMetadata | undefined {
+    const registry = this.discoverCommands();
+    return registry.commands.find(cmd => 
+      cmd.namespace === namespace && cmd.commandName === commandName
+    );
+  }
+
+  /**
+   * Recursively scan directory for TypeScript command files
+   */
+  private scanDirectory(dirPath: string, commands: CommandMetadata[]): void {
+    try {
+      const entries = readdirSync(dirPath);
+      
+      for (const entry of entries) {
+        const fullPath = join(dirPath, entry);
+        const stat = statSync(fullPath);
+        
+        if (stat.isDirectory()) {
+          this.scanDirectory(fullPath, commands);
+        } else if (stat.isFile() && extname(entry) === '.ts') {
+          const commandMetadata = this.parseCommandFile(fullPath);
+          if (commandMetadata) {
+            commands.push(commandMetadata);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not scan directory ${dirPath}:`, error);
+    }
+  }
+
+  /**
+   * Parse a TypeScript file to extract command metadata
+   */
+  private parseCommandFile(filePath: string): CommandMetadata | null {
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      
+      // Extract namespace from @namespace decorator
+      const namespaceMatch = content.match(/@namespace\(['"`]([^'"`]+)['"`]\)/);
+      if (!namespaceMatch) {
+        return null; // Not a command file if no namespace
+      }
+      
+      const namespace = namespaceMatch[1];
+      
+      // Extract class name
+      const classMatch = content.match(/export\s+class\s+(\w+)/);
+      if (!classMatch) {
+        return null;
+      }
+      
+      const className = classMatch[1];
+      
+      // Find method with @command decorator
+      const commandMethodMatch = content.match(/@command[\s\S]*?public\s+async\s+(\w+)\s*\(/);
+      if (!commandMethodMatch) {
+        return null;
+      }
+      
+      const methodName = commandMethodMatch[1];
+      const commandName = methodName;
+      
+      // Extract help text for the command method (look for @help before the @command method)
+      const commandMethodStart = content.indexOf(`public async ${methodName}`);
+      const commandSection = content.substring(0, commandMethodStart);
+      const lastHelpMatch = commandSection.match(/@help\(['"`]([^'"`]+)['"`]\)(?![\s\S]*@help)/);
+      const help = lastHelpMatch ? lastHelpMatch[1] : undefined;
+      
+      // Extract parameters
+      const parameters = this.extractParameters(content);
+      
+      // Determine if command is read-only
+      const isReadOnly = this.isReadOnlyCommand(methodName, help, content);
+      
+      return {
+        namespace,
+        commandName,
+        methodName,
+        help,
+        parameters,
+        filePath,
+        className,
+        isReadOnly
+      };
+    } catch (error) {
+      console.warn(`Warning: Could not parse command file ${filePath}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Extract parameter information from command file content
+   */
+  private extractParameters(content: string): CommandParameter[] {
+    const parameters: CommandParameter[] = [];
+    
+    // Find property declarations with their decorators
+    // Look for patterns like:
+    // @param
+    // @optional
+    // @help('...')
+    // private propertyName: type
+    
+    const propertyBlocks = content.split(/(?=@(?:param|option|flag)(?:\(['"`][^'"`]*['"`]\))?(?:\s|$))/);
+    
+    for (const block of propertyBlocks) {
+      if (!block.trim()) continue;
+      
+      // Extract decorator type - look for the first occurrence at the start of the block
+      const decoratorMatch = block.match(/^@(param|option|flag)(?:\(['"`]([^'"`]*)['"`]\))?/);
+      if (!decoratorMatch) continue;
+      
+      const [, decoratorType, shortFlag] = decoratorMatch;
+      
+      // Check for @optional
+      const isOptional = block.includes('@optional');
+      
+      // Extract help text
+      const helpMatch = block.match(/@help\(['"`]([^'"`]+)['"`]\)/);
+      const help = helpMatch ? helpMatch[1] : undefined;
+      
+      // Extract property name
+      const propMatch = block.match(/(private|public)\s+(\w+)(?:\?)?(?:!)?:\s*/);
+      if (!propMatch) continue;
+      
+      const [, , propertyName] = propMatch;
+      
+      parameters.push({
+        name: propertyName,
+        type: decoratorType as 'param' | 'option' | 'flag',
+        required: !isOptional && decoratorType !== 'flag',
+        help,
+        shortFlag
+      });
+    }
+    
+    return parameters;
+  }
+
+  /**
+   * Determine if a command is read-only based on method name, help text, and content analysis
+   */
+  private isReadOnlyCommand(methodName: string, help?: string, content?: string): boolean {
+    // Check method name against read-only patterns
+    if (this.readOnlyPatterns.some(pattern => pattern.test(methodName))) {
+      return true;
+    }
+    
+    // Check method name against state-changing patterns
+    if (this.stateChangingPatterns.some(pattern => pattern.test(methodName))) {
+      return false;
+    }
+    
+    // Check help text for read-only indicators
+    if (help) {
+      const readOnlyHelpPatterns = [
+        /^(list|show|display|get|view|info|status)/i,
+        /information/i,
+        /details/i
+      ];
+      
+      const stateChangingHelpPatterns = [
+        /^(create|add|update|delete|remove|set|install|publish)/i,
+        /modify/i,
+        /change/i
+      ];
+      
+      if (readOnlyHelpPatterns.some(pattern => pattern.test(help))) {
+        return true;
+      }
+      
+      if (stateChangingHelpPatterns.some(pattern => pattern.test(help))) {
+        return false;
+      }
+    }
+    
+    // Analyze content for API calls that suggest read-only vs state-changing
+    if (content) {
+      // Look for HTTP methods or API calls that suggest read-only operations
+      const readOnlyContentPatterns = [
+        /\.get\(/i,
+        /\.search\(/i,
+        /\.whoami\(/i,
+        /\.list\(/i,
+        /\.info\(/i,
+        /\.status\(/i
+      ];
+      
+      const stateChangingContentPatterns = [
+        /\.post\(/i,
+        /\.put\(/i,
+        /\.patch\(/i,
+        /\.delete\(/i,
+        /\.create\(/i,
+        /\.update\(/i,
+        /\.remove\(/i,
+        /\.install\(/i,
+        /\.publish\(/i
+      ];
+      
+      if (readOnlyContentPatterns.some(pattern => pattern.test(content))) {
+        return true;
+      }
+      
+      if (stateChangingContentPatterns.some(pattern => pattern.test(content))) {
+        return false;
+      }
+    }
+    
+    // Default to read-only if uncertain (safer for testing)
+    return true;
+  }
+
+  /**
+   * Generate a full command signature for CLI execution
+   */
+  public generateCommandSignature(command: CommandMetadata): string {
+    let signature = `${command.namespace} ${command.commandName}`;
+    
+    // Add required parameters
+    const requiredParams = command.parameters.filter(p => p.required && p.type === 'param');
+    for (const param of requiredParams) {
+      signature += ` <${param.name}>`;
+    }
+    
+    // Add optional parameters
+    const optionalParams = command.parameters.filter(p => !p.required && p.type === 'param');
+    for (const param of optionalParams) {
+      signature += ` [${param.name}]`;
+    }
+    
+    // Add options and flags
+    const options = command.parameters.filter(p => p.type === 'option');
+    const flags = command.parameters.filter(p => p.type === 'flag');
+    
+    if (options.length > 0 || flags.length > 0) {
+      signature += ' [OPTIONS]';
+    }
+    
+    return signature;
+  }
+}

package/src/test/e2e/utils/baseline-normalizer.ts

@@ -0,0 +1,79 @@
+/**
+ * Simple baseline normalization utility
+ * Replaces dynamic values with placeholders for consistent baseline comparison
+ */
+
+export class BaselineNormalizer {
+  /**
+   * Normalize CLI output by replacing dynamic values with placeholders
+   */
+  static normalize(output: string): string {
+    let result = output;
+    
+    // Replace deprecation warnings first
+    result = result.replace(/\(node:\d+\) \[DEP\d+\] DeprecationWarning: [^\n]+\n/g, '');
+    result = result.replace(/\(Use `node --trace-deprecation[^\n]+\n/g, '');
+    
+    // Replace environment
+    result = result.replace(/Active environment: \w+/g, 'Active environment: <ENVIRONMENT>');
+    
+    // Replace user-specific data
+    result = result.replace(/id: [a-f0-9-]{36}/g, 'id: <USER_ID>');
+    result = result.replace(/email: [^\s]+@[^\s]+/g, 'email: <USER_EMAIL>');
+    result = result.replace(/role: [^\n]+/g, 'role: <ROLE>');
+    result = result.replace(/githubUsername: [^\s]+/g, 'githubUsername: <GITHUB_USERNAME>');
+    result = result.replace(/createdAt: (?:'[^']+'|null)/g, "createdAt: <CREATED_DATE>");
+    result = result.replace(/vendor: [^\n]+/g, 'vendor: <VENDOR>');
+    
+    // Replace vendor_apps - keep structure but normalize to single entry
+    result = result.replace(/vendor_apps:\s*\n(?:  - id: [^\n]+\n?)+/g, 'vendor_apps:\n  - id: <APP_ID>');
+    
+    // Replace timestamps first (before other patterns)
+    result = result.replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z/g, '<TIMESTAMP>');
+    
+    // Replace job IDs (UUIDs)
+    result = result.replace(/[a-f0-9-]{36}/g, '<JOB_ID>');
+    
+    // Replace version numbers (semantic versions including dev/beta/alpha)
+    result = result.replace(/\d+\.\d+\.\d+(?:-(?:dev|beta|alpha)\.\d+)?/g, '<VERSION>');
+    
+    // Replace whois table data (normalize account info in table format)
+    // Match lines that start with digits followed by spaces (account ID)
+    result = result.replace(/^(\d+)(\s+)([A-Za-z0-9_-]+)(\s+)(.+?)(\s+)(\w+)$/gm, 
+      '<ACCOUNT_ID>$2<TRACKER_ID>$4<ACCOUNT_NAME>$6<TARGET_PRODUCT>');
+    
+    // Replace directory info fields
+    result = result.replace(/name\s+(.+)/g, 'name\t<APP_NAME>');
+    result = result.replace(/id\s+([a-zA-Z0-9_-]+)/g, 'id\t\t<APP_ID>');
+    result = result.replace(/created\s+<TIMESTAMP>/g, 'created\t<TIMESTAMP>');
+    
+    // Replace directory list table data (preserve table structure)
+    // Only replace app IDs at start of lines that look like directory entries
+    result = result.replace(/^([a-zA-Z0-9_-]+)(\s+<VERSION>\s+)/gm, '<APP_ID>$2');
+    
+    // Replace states and products
+    result = result.replace(/(PUBLISHED|UNPUBLISHED|BUILT|BUILD_FAILED|BUILDING)/g, '<STATE>');
+    result = result.replace(/(ODP|OCP|ZAIUS)(?=\s|$)/g, '<TARGET_PRODUCT>');
+    result = result.replace(/(NOT_REQUIRED|REQUIRED)/g, '<REQUIREMENT>');
+    
+    // Replace any remaining tracker IDs that look like Base64
+    result = result.replace(/[A-Za-z0-9_-]{22}/g, '<TRACKER_ID>');
+    
+    // Replace job statuses and review statuses
+    result = result.replace(/(COMPLETE|RUNNING|FAILED|PENDING|SUCCESS|ERROR|IN_REVIEW|APPROVED|REJECTED)/g, '<STATUS>');
+    
+    // Replace function names (words before tracker IDs in job tables)
+    result = result.replace(/\w+(?=\s+<TRACKER_ID>)/g, '<FUNCTION>');
+    
+    // Replace durations
+    result = result.replace(/\d+ms/g, '<DURATION>');
+    result = result.replace(/\d+s/g, '<DURATION>');
+    result = result.replace(/Duration: \d+/g, 'Duration: <DURATION>');
+    
+    // Normalize whitespace
+    result = result.replace(/\s+$/gm, ''); // Remove trailing whitespace
+    result = result.replace(/\n{3,}/g, '\n\n'); // Normalize multiple newlines
+    
+    return result.trim();
+  }
+}