@friggframework/devtools 2.0.0-next.6 → 2.0.0-next.61

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

@@ -0,0 +1,270 @@
+/**
+ * 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

@@ -0,0 +1,194 @@
+/**
+ * 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,
+};