@friggframework/devtools 2.0.0-next.45 → 2.0.0-next.47

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 };

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

@@ -1,194 +0,0 @@
-/**
- * Prisma Mock Utilities
- * Standardized mocking for Prisma Client in CLI tests
- * Following official Prisma testing patterns with jest-mock-extended
- */
-
-/**
- * Creates a mock Prisma client with common operations
- * @returns {object} Mock Prisma client
- */
-function createMockPrismaClient() {
-    return {
-        $connect: jest.fn().mockResolvedValue(undefined),
-        $disconnect: jest.fn().mockResolvedValue(undefined),
-        $queryRaw: jest.fn().mockResolvedValue([{ result: 1 }]),
-        $executeRaw: jest.fn().mockResolvedValue(1),
-        $runCommandRaw: jest.fn().mockResolvedValue({ ok: 1 }), // MongoDB command support
-        $transaction: jest.fn().mockImplementation(async (fn) => fn(createMockPrismaClient())),
-        // Common model operations
-        user: {
-            findMany: jest.fn().mockResolvedValue([]),
-            findUnique: jest.fn().mockResolvedValue(null),
-            create: jest.fn().mockResolvedValue({}),
-            update: jest.fn().mockResolvedValue({}),
-            delete: jest.fn().mockResolvedValue({}),
-        },
-        credential: {
-            findMany: jest.fn().mockResolvedValue([]),
-            findUnique: jest.fn().mockResolvedValue(null),
-            create: jest.fn().mockResolvedValue({}),
-            update: jest.fn().mockResolvedValue({}),
-            delete: jest.fn().mockResolvedValue({}),
-        },
-    };
-}
-
-/**
- * Creates a mock for successful Prisma connection
- * @param {object} mockClient - Optional pre-configured mock client
- * @returns {jest.Mock} Mock connectPrisma function
- */
-function createMockConnectPrisma(mockClient = null) {
-    const client = mockClient || createMockPrismaClient();
-    return jest.fn().mockResolvedValue(client);
-}
-
-/**
- * Creates a mock for successful Prisma disconnection
- * @returns {jest.Mock} Mock disconnectPrisma function
- */
-function createMockDisconnectPrisma() {
-    return jest.fn().mockResolvedValue(undefined);
-}
-
-/**
- * Creates a mock for Prisma connection that fails
- * @param {string} errorMessage - Error message to throw
- * @returns {jest.Mock} Mock connectPrisma that throws error
- */
-function createMockConnectPrismaWithError(errorMessage = 'Connection failed') {
-    return jest.fn().mockRejectedValue(new Error(errorMessage));
-}
-
-/**
- * Creates a mock for Prisma query that times out
- * @param {number} timeout - Timeout in milliseconds
- * @returns {jest.Mock} Mock that times out
- */
-function createMockPrismaTimeout(timeout = 5000) {
-    return jest.fn().mockImplementation(() =>
-        new Promise((_, reject) =>
-            setTimeout(() => reject(new Error('Connection timeout')), timeout)
-        )
-    );
-}
-
-/**
- * Common Prisma error types for testing
- */
-const PrismaErrors = {
-    /**
-     * Connection error (P1001)
-     */
-    CONNECTION_ERROR: {
-        code: 'P1001',
-        message: 'Can\'t reach database server',
-        clientVersion: '5.0.0',
-    },
-
-    /**
-     * Authentication error (P1002)
-     */
-    AUTH_ERROR: {
-        code: 'P1002',
-        message: 'The database server was reached but timed out',
-        clientVersion: '5.0.0',
-    },
-
-    /**
-     * Database not found error (P1003)
-     */
-    DATABASE_NOT_FOUND: {
-        code: 'P1003',
-        message: 'Database does not exist',
-        clientVersion: '5.0.0',
-    },
-
-    /**
-     * Connection timeout (P1008)
-     */
-    TIMEOUT_ERROR: {
-        code: 'P1008',
-        message: 'Operations timed out',
-        clientVersion: '5.0.0',
-    },
-
-    /**
-     * Invalid credentials
-     */
-    INVALID_CREDENTIALS: {
-        code: 'P1000',
-        message: 'Authentication failed against database server',
-        clientVersion: '5.0.0',
-    },
-};
-
-/**
- * Creates a Prisma error object
- * @param {string} errorType - Error type from PrismaErrors
- * @param {object} customFields - Additional custom fields
- * @returns {Error} Prisma-style error object
- */
-function createPrismaError(errorType = 'CONNECTION_ERROR', customFields = {}) {
-    const baseError = PrismaErrors[errorType] || PrismaErrors.CONNECTION_ERROR;
-    const error = new Error(baseError.message);
-    error.code = baseError.code;
-    error.clientVersion = baseError.clientVersion;
-    Object.assign(error, customFields);
-    return error;
-}
-
-/**
- * Creates a mock for database validator functions
- * @param {object} overrides - Override specific mock behaviors
- * @returns {object} Mock database validator
- */
-function createMockDatabaseValidator(overrides = {}) {
-    return {
-        validateDatabaseUrl: jest.fn().mockReturnValue({
-            valid: true,
-            url: 'mongodb://localhost:27017/test'
-        }),
-        getDatabaseType: jest.fn().mockReturnValue({
-            dbType: 'mongodb'
-        }),
-        testDatabaseConnection: jest.fn().mockResolvedValue({
-            connected: true
-        }),
-        checkPrismaClientGenerated: jest.fn().mockReturnValue({
-            generated: true,
-            path: '/mock/path'
-        }),
-        ...overrides,
-    };
-}
-
-/**
- * Creates a mock for Prisma runner functions
- * @param {object} overrides - Override specific mock behaviors
- * @returns {object} Mock Prisma runner
- */
-function createMockPrismaRunner(overrides = {}) {
-    return {
-        getPrismaSchemaPath: jest.fn().mockReturnValue('/mock/schema.prisma'),
-        runPrismaGenerate: jest.fn().mockResolvedValue({ success: true }),
-        checkDatabaseState: jest.fn().mockResolvedValue({ upToDate: true }),
-        runPrismaMigrate: jest.fn().mockResolvedValue({ success: true }),
-        runPrismaDbPush: jest.fn().mockResolvedValue({ success: true }),
-        getMigrationCommand: jest.fn().mockReturnValue('dev'),
-        ...overrides,
-    };
-}
-
-module.exports = {
-    createMockPrismaClient,
-    createMockConnectPrisma,
-    createMockDisconnectPrisma,
-    createMockConnectPrismaWithError,
-    createMockPrismaTimeout,
-    createPrismaError,
-    PrismaErrors,
-    createMockDatabaseValidator,
-    createMockPrismaRunner,
-};