@friggframework/devtools 2.0.0-next.5 → 2.0.0-next.50

package/frigg-cli/__tests__/unit/commands/db-setup.test.js

@@ -0,0 +1,548 @@
+// Mock all dependencies BEFORE importing dbSetupCommand
+const mockValidator = {
+    validateDatabaseUrl: jest.fn(),
+    getDatabaseType: jest.fn(),
+    testDatabaseConnection: jest.fn(),
+    checkPrismaClientGenerated: jest.fn()
+};
+
+const mockRunner = {
+    runPrismaGenerate: jest.fn(),
+    checkDatabaseState: jest.fn(),
+    runPrismaMigrate: jest.fn(),
+    runPrismaDbPush: jest.fn(),
+    getMigrationCommand: jest.fn()
+};
+
+const mockErrorMessages = {
+    getDatabaseUrlMissingError: jest.fn(),
+    getDatabaseTypeNotConfiguredError: jest.fn(),
+    getDatabaseConnectionError: jest.fn(),
+    getPrismaCommandError: jest.fn(),
+    getDatabaseSetupSuccess: jest.fn()
+};
+
+jest.mock('../../../utils/database-validator', () => mockValidator);
+jest.mock('@friggframework/core/database/utils/prisma-runner', () => mockRunner);
+jest.mock('../../../utils/error-messages', () => mockErrorMessages);
+jest.mock('dotenv');
+
+const { dbSetupCommand } = require('../../../db-setup-command');
+const {
+    createMockDatabaseValidator,
+    createMockPrismaRunner
+} = require('../../utils/prisma-mock');
+
+const dotenv = require('dotenv');
+
+describe('DB Setup Command', () => {
+    let mockConsoleLog;
+    let mockConsoleError;
+    let mockProcessExit;
+
+    beforeEach(() => {
+        // Set up default mock return values using the factory utilities
+        const defaultValidator = createMockDatabaseValidator();
+        const defaultRunner = createMockPrismaRunner();
+
+        // Apply default implementations
+        mockValidator.validateDatabaseUrl.mockImplementation(defaultValidator.validateDatabaseUrl);
+        mockValidator.getDatabaseType.mockImplementation(defaultValidator.getDatabaseType);
+        mockValidator.testDatabaseConnection.mockImplementation(defaultValidator.testDatabaseConnection);
+        mockValidator.checkPrismaClientGenerated.mockImplementation(defaultValidator.checkPrismaClientGenerated);
+
+        mockRunner.runPrismaGenerate.mockImplementation(defaultRunner.runPrismaGenerate);
+        mockRunner.checkDatabaseState.mockImplementation(defaultRunner.checkDatabaseState);
+        mockRunner.runPrismaMigrate.mockImplementation(defaultRunner.runPrismaMigrate);
+        mockRunner.runPrismaDbPush.mockImplementation(defaultRunner.runPrismaDbPush);
+        mockRunner.getMigrationCommand.mockImplementation(defaultRunner.getMigrationCommand);
+
+        // Mock dotenv
+        dotenv.config = jest.fn();
+
+        // Mock console and process.exit
+        mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
+        mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
+        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation();
+
+        // Mock error message functions with default return values
+        mockErrorMessages.getDatabaseUrlMissingError.mockReturnValue('DATABASE_URL missing error');
+        mockErrorMessages.getDatabaseTypeNotConfiguredError.mockReturnValue('DB type error');
+        mockErrorMessages.getDatabaseConnectionError.mockReturnValue('Connection error');
+        mockErrorMessages.getPrismaCommandError.mockReturnValue('Prisma error');
+        mockErrorMessages.getDatabaseSetupSuccess.mockReturnValue('Success message');
+    });
+
+    afterEach(() => {
+        mockConsoleLog.mockRestore();
+        mockConsoleError.mockRestore();
+        mockProcessExit.mockRestore();
+        jest.clearAllMocks();
+    });
+
+    describe('Success Cases', () => {
+        it('should complete setup successfully for MongoDB', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'mongodb' });
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(mockValidator.validateDatabaseUrl).toHaveBeenCalled();
+            expect(mockValidator.getDatabaseType).toHaveBeenCalled();
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            expect(mockValidator.testDatabaseConnection).toHaveBeenCalled();
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+            expect(mockRunner.runPrismaDbPush).toHaveBeenCalled();
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should complete setup successfully for PostgreSQL', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('postgresql');
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
+            expect(mockRunner.runPrismaMigrate).toHaveBeenCalled();
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should skip migrations when already up-to-date (PostgreSQL)', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: true });
+            mockRunner.getMigrationCommand.mockReturnValue('deploy');
+
+            await dbSetupCommand({ verbose: false, stage: 'production' });
+
+            expect(mockRunner.runPrismaMigrate).not.toHaveBeenCalled();
+            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('already up-to-date'));
+        });
+
+        it('should use migrate dev in development stage', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.getMigrationCommand.mockReturnValue('dev');
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('development');
+            expect(mockRunner.runPrismaMigrate).toHaveBeenCalledWith('dev', false);
+        });
+
+        it('should use migrate deploy in production stage', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.getMigrationCommand.mockReturnValue('deploy');
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'production' });
+
+            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('production');
+            expect(mockRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', false);
+        });
+
+        it('should respect --verbose flag', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+
+            await dbSetupCommand({ verbose: true, stage: 'development' });
+
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', true);
+        });
+
+        it('should load .env file from project root', async () => {
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(dotenv.config).toHaveBeenCalledWith(expect.objectContaining({
+                path: expect.stringContaining('.env')
+            }));
+        });
+    });
+
+    describe('Conditional Client Generation', () => {
+        it('should skip generation when client already exists', async () => {
+            // Client exists
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: true,
+                path: '/path/to/client'
+            });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            // Should check if client exists
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            // Should NOT call generate
+            expect(mockRunner.runPrismaGenerate).not.toHaveBeenCalled();
+            // Should still test connection and complete setup
+            expect(mockValidator.testDatabaseConnection).toHaveBeenCalled();
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should generate client when it does not exist', async () => {
+            // Client does NOT exist
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false,
+                error: 'Client not found'
+            });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            // Should check if client exists
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            // Should call generate
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+            // Should complete setup
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should regenerate client when --force flag is provided', async () => {
+            // Client exists
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: true,
+                path: '/path/to/client'
+            });
+
+            await dbSetupCommand({ verbose: false, stage: 'development', force: true });
+
+            // Should check if client exists
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            // Should STILL call generate because of --force
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+            // Should complete setup
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should show client location in verbose mode when skipping generation', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: true,
+                path: '/path/to/prisma/client'
+            });
+
+            await dbSetupCommand({ verbose: true, stage: 'development' });
+
+            // Should log the client path
+            expect(mockConsoleLog).toHaveBeenCalledWith(
+                expect.stringContaining('/path/to/prisma/client')
+            );
+            expect(mockRunner.runPrismaGenerate).not.toHaveBeenCalled();
+        });
+
+        it('should generate for different database types', async () => {
+            // Test PostgreSQL
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('postgresql');
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
+        });
+    });
+
+    describe('Failure Cases - Validation', () => {
+        it('should fail when DATABASE_URL missing', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false,
+                error: 'DATABASE_URL not found'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockConsoleError).toHaveBeenCalled();
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when DATABASE_URL is empty', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false,
+                error: 'DATABASE_URL is empty'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getDatabaseUrlMissingError).toHaveBeenCalled();
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when database type not configured', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({
+                error: 'Database not configured'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getDatabaseTypeNotConfiguredError).toHaveBeenCalled();
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when backend definition not found', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({
+                error: 'Backend not found'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('Failure Cases - Connection', () => {
+        it('should fail when database connection times out', async () => {
+            mockValidator.testDatabaseConnection.mockResolvedValue({
+                connected: false,
+                error: 'Connection timeout'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getDatabaseConnectionError).toHaveBeenCalledWith(
+                'Connection timeout',
+                'mongodb'
+            );
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when database credentials invalid', async () => {
+            mockValidator.testDatabaseConnection.mockResolvedValue({
+                connected: false,
+                error: 'Authentication failed'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when database not accessible', async () => {
+            mockValidator.testDatabaseConnection.mockResolvedValue({
+                connected: false,
+                error: 'Connection refused'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('Failure Cases - Prisma Operations', () => {
+        it('should fail when prisma generate fails', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will attempt generation
+            });
+            mockRunner.runPrismaGenerate.mockResolvedValue({
+                success: false,
+                error: 'Generation failed'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getPrismaCommandError).toHaveBeenCalledWith(
+                'generate',
+                'Generation failed'
+            );
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when migrate dev fails (PostgreSQL)', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.getMigrationCommand.mockReturnValue('dev');
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+            mockRunner.runPrismaMigrate.mockResolvedValue({
+                success: false,
+                error: 'Migration failed'
+            });
+
+            await dbSetupCommand({ stage: 'development' });
+
+            expect(mockErrorMessages.getPrismaCommandError).toHaveBeenCalledWith(
+                'migrate',
+                'Migration failed'
+            );
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when migrate deploy fails (PostgreSQL)', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.getMigrationCommand.mockReturnValue('deploy');
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+            mockRunner.runPrismaMigrate.mockResolvedValue({
+                success: false,
+                error: 'Deploy failed'
+            });
+
+            await dbSetupCommand({ stage: 'production' });
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when db push fails (MongoDB)', async () => {
+            mockRunner.runPrismaDbPush.mockResolvedValue({
+                success: false,
+                error: 'Push failed'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getPrismaCommandError).toHaveBeenCalledWith(
+                'db push',
+                'Push failed'
+            );
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should fail when schema file missing', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will attempt generation
+            });
+            mockRunner.runPrismaGenerate.mockResolvedValue({
+                success: false,
+                error: 'Schema not found'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('Error Message Validation', () => {
+        it('should display helpful error for missing DATABASE_URL', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false,
+                error: 'Not found'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getDatabaseUrlMissingError).toHaveBeenCalled();
+        });
+
+        it('should display helpful error for connection failure', async () => {
+            mockValidator.testDatabaseConnection.mockResolvedValue({
+                connected: false,
+                error: 'Network error'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getDatabaseConnectionError).toHaveBeenCalledWith(
+                'Network error',
+                expect.any(String)
+            );
+        });
+
+        it('should display helpful error for Prisma failures', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will attempt generation
+            });
+            mockRunner.runPrismaGenerate.mockResolvedValue({
+                success: false,
+                error: 'Some error',
+                output: 'Detailed output'
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockErrorMessages.getPrismaCommandError).toHaveBeenCalled();
+        });
+
+        it('should exit with code 1 on failure', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should not exit with code 0 on failure', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false
+            });
+
+            await dbSetupCommand({});
+
+            expect(mockProcessExit).not.toHaveBeenCalledWith(0);
+        });
+
+        it('should display success message on completion', async () => {
+            await dbSetupCommand({ stage: 'development' });
+
+            expect(mockErrorMessages.getDatabaseSetupSuccess).toHaveBeenCalledWith(
+                'mongodb',
+                'development'
+            );
+        });
+    });
+
+    describe('Verbose Output', () => {
+        it('should show verbose output when flag enabled', async () => {
+            await dbSetupCommand({ verbose: true });
+
+            // Verbose calls should show console output
+            expect(mockConsoleLog).toHaveBeenCalled();
+        });
+
+        it('should pass verbose flag to Prisma commands', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+
+            await dbSetupCommand({ verbose: true });
+
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', true);
+            expect(mockRunner.runPrismaDbPush).toHaveBeenCalledWith(true);
+        });
+
+        it('should not show verbose output when flag disabled', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+
+            await dbSetupCommand({ verbose: false });
+
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+        });
+    });
+
+    describe('Stage Handling', () => {
+        it('should use provided stage option', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ stage: 'production' });
+
+            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('production');
+        });
+
+        it('should default to development when no stage provided', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({});
+
+            expect(mockRunner.getMigrationCommand).toHaveBeenCalled();
+        });
+
+        it('should handle different stage values', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ stage: 'staging' });
+
+            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('staging');
+        });
+    });
+});