@friggframework/devtools 2.0.0--canary.395.f03dc2b.0 → 2.0.0--canary.395.495dc7d.0

package/frigg-cli/__tests__/jest.config.js

@@ -57,6 +57,30 @@ module.exports = {
       functions: 90,
       lines: 90,
       statements: 90
+    },
+    '../db-setup-command/index.js': {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    },
+    '../utils/database-validator.js': {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
+    },
+    '../utils/prisma-runner.js': {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
+    },
+    '../utils/error-messages.js': {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
     }
   },
   setupFilesAfterEnv: [

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

@@ -0,0 +1,436 @@
+// 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' });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(mockValidator.validateDatabaseUrl).toHaveBeenCalled();
+            expect(mockValidator.getDatabaseType).toHaveBeenCalled();
+            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' });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            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 () => {
+            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('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 () => {
+            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 () => {
+            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 () => {
+            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 () => {
+            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 () => {
+            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');
+        });
+    });
+});