@friggframework/devtools 2.0.0-next.41 → 2.0.0-next.43

package/frigg-cli/__tests__/unit/utils/prisma-runner.test.js

@@ -0,0 +1,486 @@
+// Mock dependencies BEFORE requiring modules
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+    spawn: jest.fn()
+}));
+jest.mock('fs', () => ({
+    existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+    writeFileSync: jest.fn()
+}));
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const {
+    getPrismaSchemaPath,
+    runPrismaGenerate,
+    checkDatabaseState,
+    runPrismaMigrate,
+    runPrismaDbPush,
+    getMigrationCommand
+} = require('../../../utils/prisma-runner');
+
+describe('Prisma Runner Utility', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        delete process.env.STAGE;
+        delete process.env.PRISMA_HIDE_UPDATE_MESSAGE;
+    });
+
+    afterEach(() => {
+        delete process.env.STAGE;
+        delete process.env.PRISMA_HIDE_UPDATE_MESSAGE;
+    });
+
+    describe('getPrismaSchemaPath()', () => {
+        it('should return correct path for MongoDB', () => {
+            fs.existsSync.mockReturnValue(true);
+
+            const path = getPrismaSchemaPath('mongodb');
+
+            expect(path).toContain('prisma-mongodb');
+            expect(path).toContain('schema.prisma');
+            expect(path).toContain('@friggframework/core');
+        });
+
+        it('should return correct path for PostgreSQL', () => {
+            fs.existsSync.mockReturnValue(true);
+
+            const path = getPrismaSchemaPath('postgresql');
+
+            expect(path).toContain('prisma-postgresql');
+            expect(path).toContain('schema.prisma');
+            expect(path).toContain('@friggframework/core');
+        });
+
+        it('should throw error when schema file does not exist', () => {
+            fs.existsSync.mockReturnValue(false);
+
+            expect(() => getPrismaSchemaPath('mongodb')).toThrow('Prisma schema not found');
+        });
+
+        it('should include helpful error message when schema missing', () => {
+            fs.existsSync.mockReturnValue(false);
+
+            expect(() => getPrismaSchemaPath('mongodb')).toThrow('@friggframework/core');
+        });
+
+        it('should use process.cwd() for base path', () => {
+            fs.existsSync.mockReturnValue(true);
+            const originalCwd = process.cwd();
+
+            const path = getPrismaSchemaPath('mongodb');
+
+            expect(path).toContain(originalCwd);
+        });
+
+        it('should accept custom project root', () => {
+            fs.existsSync.mockReturnValue(true);
+            const customRoot = '/custom/project';
+
+            const path = getPrismaSchemaPath('mongodb', customRoot);
+
+            expect(path).toContain(customRoot);
+        });
+    });
+
+    describe('runPrismaGenerate()', () => {
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+        });
+
+        it('should execute prisma generate successfully', async () => {
+            execSync.mockReturnValue('Generated successfully');
+
+            const result = await runPrismaGenerate('mongodb');
+
+            expect(result.success).toBe(true);
+            expect(execSync).toHaveBeenCalled();
+        });
+
+        it('should use correct schema path for MongoDB', async () => {
+            execSync.mockReturnValue('');
+
+            await runPrismaGenerate('mongodb');
+
+            const call = execSync.mock.calls[0][0];
+            expect(call).toContain('prisma generate');
+            expect(call).toContain('--schema');
+            expect(call).toContain('prisma-mongodb');
+        });
+
+        it('should use correct schema path for PostgreSQL', async () => {
+            execSync.mockReturnValue('');
+
+            await runPrismaGenerate('postgresql');
+
+            const call = execSync.mock.calls[0][0];
+            expect(call).toContain('prisma-postgresql');
+        });
+
+        it('should suppress telemetry when verbose false', async () => {
+            execSync.mockReturnValue('');
+
+            await runPrismaGenerate('mongodb', false);
+
+            const options = execSync.mock.calls[0][1];
+            expect(options.env.PRISMA_HIDE_UPDATE_MESSAGE).toBe('1');
+        });
+
+        it('should show output when verbose true', async () => {
+            execSync.mockReturnValue('Generated successfully');
+
+            await runPrismaGenerate('mongodb', true);
+
+            const options = execSync.mock.calls[0][1];
+            expect(options.stdio).toBe('inherit');
+        });
+
+        it('should hide output when verbose false', async () => {
+            execSync.mockReturnValue('');
+
+            await runPrismaGenerate('mongodb', false);
+
+            const options = execSync.mock.calls[0][1];
+            expect(options.stdio).toBe('pipe');
+        });
+
+        it('should handle generation failures with error details', async () => {
+            const error = new Error('Generation failed');
+            error.stdout = 'Schema validation error';
+            execSync.mockImplementation(() => {
+                throw error;
+            });
+
+            const result = await runPrismaGenerate('mongodb');
+
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Generation failed');
+        });
+
+        it('should include stdout in error output', async () => {
+            const error = new Error('Failed');
+            error.stdout = Buffer.from('Detailed error info');
+            execSync.mockImplementation(() => {
+                throw error;
+            });
+
+            const result = await runPrismaGenerate('mongodb');
+
+            expect(result.output).toContain('Detailed error info');
+        });
+
+        it('should handle schema syntax errors', async () => {
+            execSync.mockImplementation(() => {
+                throw new Error('Schema parsing failed');
+            });
+
+            const result = await runPrismaGenerate('mongodb');
+
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+
+    describe('checkDatabaseState()', () => {
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+        });
+
+        it('should return upToDate: true when migrations current (PostgreSQL)', async () => {
+            execSync.mockReturnValue('Database schema is up to date');
+
+            const result = await checkDatabaseState('postgresql');
+
+            expect(result.upToDate).toBe(true);
+        });
+
+        it('should return upToDate: true for MongoDB (N/A)', async () => {
+            const result = await checkDatabaseState('mongodb');
+
+            expect(result.upToDate).toBe(true);
+        });
+
+        it('should return pendingMigrations count when migrations pending', async () => {
+            execSync.mockReturnValue('3 migrations have not been applied');
+
+            const result = await checkDatabaseState('postgresql');
+
+            expect(result.upToDate).toBe(false);
+            expect(result.pendingMigrations).toBe(3);
+        });
+
+        it('should handle uninitialized database', async () => {
+            execSync.mockImplementation(() => {
+                throw new Error('No migrations found');
+            });
+
+            const result = await checkDatabaseState('postgresql');
+
+            expect(result.upToDate).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+
+        it('should handle migrate status command errors', async () => {
+            execSync.mockImplementation(() => {
+                throw new Error('Migration status failed');
+            });
+
+            const result = await checkDatabaseState('postgresql');
+
+            expect(result.upToDate).toBe(false);
+            expect(result.error).toContain('Migration status failed');
+        });
+
+        it('should not run migrate status for MongoDB', async () => {
+            await checkDatabaseState('mongodb');
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('runPrismaMigrate()', () => {
+        let mockChildProcess;
+
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+            mockChildProcess = {
+                on: jest.fn((event, callback) => {
+                    if (event === 'close') {
+                        callback(0);
+                    }
+                }),
+                stdout: { on: jest.fn() },
+                stderr: { on: jest.fn() }
+            };
+            spawn.mockReturnValue(mockChildProcess);
+        });
+
+        it('should run migrate dev successfully', async () => {
+            const result = await runPrismaMigrate('dev');
+
+            expect(result.success).toBe(true);
+            expect(spawn).toHaveBeenCalled();
+        });
+
+        it('should run migrate deploy successfully', async () => {
+            const result = await runPrismaMigrate('deploy');
+
+            expect(result.success).toBe(true);
+            expect(spawn).toHaveBeenCalled();
+        });
+
+        it('should use correct command for dev mode', async () => {
+            await runPrismaMigrate('dev');
+
+            const args = spawn.mock.calls[0][1];
+            expect(args).toContain('migrate');
+            expect(args).toContain('dev');
+        });
+
+        it('should use correct command for deploy mode', async () => {
+            await runPrismaMigrate('deploy');
+
+            const args = spawn.mock.calls[0][1];
+            expect(args).toContain('migrate');
+            expect(args).toContain('deploy');
+        });
+
+        it('should handle migration failures with error', async () => {
+            mockChildProcess.on.mockImplementation((event, callback) => {
+                if (event === 'close') {
+                    callback(1); // Exit code 1
+                }
+            });
+
+            const result = await runPrismaMigrate('dev');
+
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('exited with code 1');
+        });
+
+        it('should respect verbose flag', async () => {
+            await runPrismaMigrate('dev', true);
+
+            const options = spawn.mock.calls[0][2];
+            expect(options.stdio).toBe('inherit');
+        });
+
+        it('should handle process spawn errors', async () => {
+            mockChildProcess.on.mockImplementation((event, callback) => {
+                if (event === 'error') {
+                    callback(new Error('Spawn failed'));
+                }
+            });
+
+            const result = await runPrismaMigrate('dev');
+
+            expect(result.success).toBe(false);
+        });
+
+        it('should hide telemetry messages', async () => {
+            await runPrismaMigrate('dev');
+
+            const options = spawn.mock.calls[0][2];
+            expect(options.env.PRISMA_HIDE_UPDATE_MESSAGE).toBe('1');
+        });
+    });
+
+    describe('runPrismaDbPush()', () => {
+        let mockChildProcess;
+
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+            mockChildProcess = {
+                on: jest.fn((event, callback) => {
+                    if (event === 'close') {
+                        callback(0);
+                    }
+                }),
+                stdout: { on: jest.fn() },
+                stderr: { on: jest.fn() }
+            };
+            spawn.mockReturnValue(mockChildProcess);
+        });
+
+        it('should push schema successfully for MongoDB', async () => {
+            const result = await runPrismaDbPush();
+
+            expect(result.success).toBe(true);
+            expect(spawn).toHaveBeenCalled();
+        });
+
+        it('should use --skip-generate flag', async () => {
+            await runPrismaDbPush();
+
+            const args = spawn.mock.calls[0][1];
+            expect(args).toContain('--skip-generate');
+        });
+
+        it('should use db push command', async () => {
+            await runPrismaDbPush();
+
+            const args = spawn.mock.calls[0][1];
+            expect(args).toContain('db');
+            expect(args).toContain('push');
+        });
+
+        it('should handle push failures with error', async () => {
+            mockChildProcess.on.mockImplementation((event, callback) => {
+                if (event === 'close') {
+                    callback(1);
+                }
+            });
+
+            const result = await runPrismaDbPush();
+
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('exited with code 1');
+        });
+
+        it('should respect verbose flag', async () => {
+            await runPrismaDbPush(true);
+
+            const options = spawn.mock.calls[0][2];
+            expect(options.stdio).toBe('inherit');
+        });
+
+        it('should use interactive mode (stdio: inherit)', async () => {
+            await runPrismaDbPush();
+
+            const options = spawn.mock.calls[0][2];
+            expect(options.stdio).toBe('inherit');
+        });
+
+        it('should handle schema validation errors', async () => {
+            mockChildProcess.on.mockImplementation((event, callback) => {
+                if (event === 'close') {
+                    callback(1);
+                }
+            });
+
+            const result = await runPrismaDbPush();
+
+            expect(result.success).toBe(false);
+        });
+    });
+
+    describe('getMigrationCommand()', () => {
+        it('should return dev for development stage', () => {
+            const command = getMigrationCommand('development');
+
+            expect(command).toBe('dev');
+        });
+
+        it('should return dev for dev stage', () => {
+            const command = getMigrationCommand('dev');
+
+            expect(command).toBe('dev');
+        });
+
+        it('should return dev for local stage', () => {
+            const command = getMigrationCommand('local');
+
+            expect(command).toBe('dev');
+        });
+
+        it('should return dev for test stage', () => {
+            const command = getMigrationCommand('test');
+
+            expect(command).toBe('dev');
+        });
+
+        it('should return deploy for production stage', () => {
+            const command = getMigrationCommand('production');
+
+            expect(command).toBe('deploy');
+        });
+
+        it('should return deploy for prod stage', () => {
+            const command = getMigrationCommand('prod');
+
+            expect(command).toBe('deploy');
+        });
+
+        it('should return deploy for staging stage', () => {
+            const command = getMigrationCommand('staging');
+
+            expect(command).toBe('deploy');
+        });
+
+        it('should default to dev when stage undefined', () => {
+            const command = getMigrationCommand();
+
+            expect(command).toBe('dev');
+        });
+
+        it('should read from STAGE environment variable when no argument', () => {
+            process.env.STAGE = 'production';
+
+            const command = getMigrationCommand();
+
+            expect(command).toBe('deploy');
+        });
+
+        it('should prioritize argument over STAGE env var', () => {
+            process.env.STAGE = 'production';
+
+            const command = getMigrationCommand('development');
+
+            expect(command).toBe('dev');
+        });
+
+        it('should handle case-insensitive stage names', () => {
+            expect(getMigrationCommand('DEVELOPMENT')).toBe('dev');
+            expect(getMigrationCommand('PRODUCTION')).toBe('deploy');
+            expect(getMigrationCommand('Dev')).toBe('dev');
+            expect(getMigrationCommand('Prod')).toBe('deploy');
+        });
+
+        it('should return deploy for unknown stages', () => {
+            const command = getMigrationCommand('unknown-stage');
+
+            expect(command).toBe('deploy');
+        });
+    });
+});

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