@friggframework/devtools 2.0.0--canary.400.bed3308.0 → 2.0.0--canary.400.545e7a8.0

package/frigg-cli/__tests__/utils/command-tester.js

@@ -1,170 +0,0 @@
-const { Command } = require('commander');
-
-/**
- * CommandTester - Utility class for testing CLI commands
- * Provides a fluent interface for setting up mocks and executing commands
- */
-class CommandTester {
-  constructor(commandDefinition) {
-    this.commandDefinition = commandDefinition;
-    this.mocks = new Map();
-    this.originalEnv = process.env;
-    this.capturedLogs = {
-      info: [],
-      error: [],
-      debug: [],
-      warn: []
-    };
-  }
-
-  /**
-   * Set up a mock for a module
-   * @param {string} modulePath - Path to the module to mock
-   * @param {object} implementation - Mock implementation
-   * @returns {CommandTester} - Fluent interface
-   */
-  mock(modulePath, implementation) {
-    this.mocks.set(modulePath, implementation);
-    return this;
-  }
-
-  /**
-   * Set environment variables for the test
-   * @param {object} env - Environment variables to set
-   * @returns {CommandTester} - Fluent interface
-   */
-  withEnv(env) {
-    process.env = { ...process.env, ...env };
-    return this;
-  }
-
-  /**
-   * Capture console output during test execution
-   * @returns {CommandTester} - Fluent interface
-   */
-  captureOutput() {
-    const originalConsole = { ...console };
-    
-    console.log = (...args) => {
-      this.capturedLogs.info.push(args.join(' '));
-      originalConsole.log(...args);
-    };
-    
-    console.error = (...args) => {
-      this.capturedLogs.error.push(args.join(' '));
-      originalConsole.error(...args);
-    };
-    
-    console.warn = (...args) => {
-      this.capturedLogs.warn.push(args.join(' '));
-      originalConsole.warn(...args);
-    };
-    
-    console.debug = (...args) => {
-      this.capturedLogs.debug.push(args.join(' '));
-      originalConsole.debug(...args);
-    };
-    
-    return this;
-  }
-
-  /**
-   * Execute the command with given arguments
-   * @param {string[]} args - Command arguments
-   * @param {object} options - Command options
-   * @returns {Promise<object>} - Execution result
-   */
-  async execute(args = [], options = {}) {
-    // Set up mocks
-    for (const [path, impl] of this.mocks) {
-      jest.mock(path, () => impl, { virtual: true });
-    }
-
-    try {
-      const program = new Command();
-      
-      // Set up the command
-      const cmd = program
-        .command(this.commandDefinition.name)
-        .description(this.commandDefinition.description);
-      
-      // Add options if defined
-      if (this.commandDefinition.options) {
-        this.commandDefinition.options.forEach(option => {
-          cmd.option(option.flags, option.description, option.defaultValue);
-        });
-      }
-      
-      // Add action
-      cmd.action(this.commandDefinition.action);
-      
-      // Mock process.exit to prevent actual exit
-      const originalExit = process.exit;
-      let exitCode = 0;
-      process.exit = (code) => {
-        exitCode = code;
-        throw new Error(`Process exited with code ${code}`);
-      };
-      
-      try {
-        await program.parseAsync(['node', 'cli', ...args]);
-        
-        return {
-          success: true,
-          exitCode: 0,
-          logs: this.capturedLogs,
-          args,
-          options
-        };
-      } catch (error) {
-        if (error.message.includes('Process exited with code')) {
-          return {
-            success: false,
-            exitCode,
-            error: error.message,
-            logs: this.capturedLogs,
-            args,
-            options
-          };
-        }
-        throw error;
-      } finally {
-        process.exit = originalExit;
-      }
-    } finally {
-      // Clean up mocks
-      for (const [path] of this.mocks) {
-        jest.unmock(path);
-      }
-      
-      // Restore environment
-      process.env = this.originalEnv;
-    }
-  }
-
-  /**
-   * Get captured logs
-   * @returns {object} - Captured logs by type
-   */
-  getLogs() {
-    return this.capturedLogs;
-  }
-
-  /**
-   * Reset the tester state
-   * @returns {CommandTester} - Fluent interface
-   */
-  reset() {
-    this.mocks.clear();
-    this.capturedLogs = {
-      info: [],
-      error: [],
-      debug: [],
-      warn: []
-    };
-    process.env = this.originalEnv;
-    return this;
-  }
-}
-
-module.exports = { CommandTester };

package/frigg-cli/__tests__/utils/mock-factory.js

@@ -1,270 +0,0 @@
-/**
- * MockFactory - Factory for creating standardized mocks
- * Provides consistent mock implementations across all CLI tests
- */
-class MockFactory {
-  /**
-   * Create a file system mock
-   * @returns {object} - Mock fs implementation
-   */
-  static createFileSystem() {
-    return {
-      existsSync: jest.fn().mockReturnValue(true),
-      readFileSync: jest.fn().mockReturnValue('{}'),
-      writeFileSync: jest.fn(),
-      mkdirSync: jest.fn(),
-      readdirSync: jest.fn().mockReturnValue([]),
-      statSync: jest.fn().mockReturnValue({
-        isDirectory: () => false,
-        isFile: () => true
-      }),
-      copyFileSync: jest.fn(),
-      unlinkSync: jest.fn(),
-      rmdirSync: jest.fn(),
-      constants: {
-        F_OK: 0,
-        R_OK: 4,
-        W_OK: 2,
-        X_OK: 1
-      }
-    };
-  }
-
-  /**
-   * Create a logger mock
-   * @returns {object} - Mock logger implementation
-   */
-  static createLogger() {
-    return {
-      info: jest.fn(),
-      error: jest.fn(),
-      debug: jest.fn(),
-      warn: jest.fn(),
-      logInfo: jest.fn(),
-      logError: jest.fn(),
-      logDebug: jest.fn(),
-      logWarn: jest.fn()
-    };
-  }
-
-  /**
-   * Create a package manager mock
-   * @returns {object} - Mock package manager implementation
-   */
-  static createPackageManager() {
-    return {
-      install: jest.fn().mockResolvedValue({ success: true }),
-      list: jest.fn().mockResolvedValue([]),
-      exists: jest.fn().mockResolvedValue(true),
-      getInfo: jest.fn().mockResolvedValue({
-        name: 'test-package',
-        version: '1.0.0'
-      }),
-      search: jest.fn().mockResolvedValue([])
-    };
-  }
-
-  /**
-   * Create a child process mock
-   * @returns {object} - Mock child_process implementation
-   */
-  static createChildProcess() {
-    return {
-      execSync: jest.fn().mockReturnValue(''),
-      exec: jest.fn(),
-      spawn: jest.fn().mockReturnValue({
-        stdout: { on: jest.fn() },
-        stderr: { on: jest.fn() },
-        on: jest.fn((event, callback) => {
-          if (event === 'close') {
-            callback(0);
-          }
-        })
-      }),
-      fork: jest.fn()
-    };
-  }
-
-  /**
-   * Create a git mock
-   * @returns {object} - Mock git implementation
-   */
-  static createGit() {
-    return {
-      init: jest.fn(),
-      add: jest.fn(),
-      commit: jest.fn(),
-      status: jest.fn().mockReturnValue({
-        clean: true,
-        files: []
-      }),
-      branch: jest.fn().mockReturnValue('main'),
-      remote: jest.fn().mockReturnValue('origin'),
-      isRepo: jest.fn().mockReturnValue(true)
-    };
-  }
-
-  /**
-   * Create a config loader mock
-   * @returns {object} - Mock config loader implementation
-   */
-  static createConfigLoader() {
-    return {
-      load: jest.fn().mockReturnValue({
-        stage: 'dev',
-        region: 'us-east-1',
-        profile: 'default'
-      }),
-      validate: jest.fn().mockReturnValue(true),
-      save: jest.fn(),
-      merge: jest.fn()
-    };
-  }
-
-  /**
-   * Create an app resolver mock
-   * @returns {object} - Mock app resolver implementation
-   */
-  static createAppResolver() {
-    return {
-      resolveAppPath: jest.fn().mockReturnValue('/mock/app/path'),
-      findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-      validateBackendPath: jest.fn().mockReturnValue(true),
-      getProjectRoot: jest.fn().mockReturnValue('/mock/project'),
-      findConfigFile: jest.fn().mockReturnValue('/mock/config.json')
-    };
-  }
-
-  /**
-   * Create a network mock
-   * @returns {object} - Mock network implementation
-   */
-  static createNetwork() {
-    return {
-      get: jest.fn().mockResolvedValue({
-        status: 200,
-        data: {}
-      }),
-      post: jest.fn().mockResolvedValue({
-        status: 200,
-        data: {}
-      }),
-      put: jest.fn().mockResolvedValue({
-        status: 200,
-        data: {}
-      }),
-      delete: jest.fn().mockResolvedValue({
-        status: 200,
-        data: {}
-      })
-    };
-  }
-
-  /**
-   * Create a comprehensive mock environment
-   * @returns {object} - Complete mock environment
-   */
-  static createMockEnvironment() {
-    return {
-      fs: this.createFileSystem(),
-      logger: this.createLogger(),
-      packageManager: this.createPackageManager(),
-      childProcess: this.createChildProcess(),
-      git: this.createGit(),
-      config: this.createConfigLoader(),
-      appResolver: this.createAppResolver(),
-      network: this.createNetwork()
-    };
-  }
-
-  /**
-   * Create a mock for process.env
-   * @param {object} customEnv - Custom environment variables
-   * @returns {object} - Mock environment
-   */
-  static createProcessEnv(customEnv = {}) {
-    return {
-      NODE_ENV: 'test',
-      HOME: '/mock/home',
-      PATH: '/mock/path',
-      ...customEnv
-    };
-  }
-
-  /**
-   * Create success response mock
-   * @param {any} data - Response data
-   * @returns {object} - Success response
-   */
-  static createSuccessResponse(data = {}) {
-    return {
-      success: true,
-      data,
-      message: 'Operation completed successfully'
-    };
-  }
-
-  /**
-   * Create error response mock
-   * @param {string} message - Error message
-   * @param {string} code - Error code
-   * @returns {object} - Error response
-   */
-  static createErrorResponse(message = 'An error occurred', code = 'GENERIC_ERROR') {
-    return {
-      success: false,
-      error: {
-        message,
-        code,
-        stack: 'Mock stack trace'
-      }
-    };
-  }
-
-  /**
-   * Create package.json mock
-   * @param {object} overrides - Custom package.json properties
-   * @returns {object} - Mock package.json
-   */
-  static createPackageJson(overrides = {}) {
-    return {
-      name: 'test-package',
-      version: '1.0.0',
-      description: 'Test package',
-      main: 'index.js',
-      scripts: {
-        test: 'jest',
-        start: 'node index.js'
-      },
-      dependencies: {},
-      devDependencies: {},
-      ...overrides
-    };
-  }
-
-  /**
-   * Create frigg config mock
-   * @param {object} overrides - Custom config properties
-   * @returns {object} - Mock frigg config
-   */
-  static createFriggConfig(overrides = {}) {
-    return {
-      stage: 'dev',
-      region: 'us-east-1',
-      profile: 'default',
-      backend: {
-        runtime: 'nodejs18.x',
-        timeout: 30,
-        memory: 128
-      },
-      frontend: {
-        framework: 'react',
-        buildCommand: 'npm run build',
-        outputDir: 'dist'
-      },
-      ...overrides
-    };
-  }
-}
-
-module.exports = { MockFactory };