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

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

@@ -1,548 +0,0 @@
-// 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('../../../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');
-        });
-    });
-});