@friggframework/devtools 2.0.0-next.53 → 2.0.0-next.54

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

@@ -3,7 +3,7 @@ const mockValidator = {
     validateDatabaseUrl: jest.fn(),
     getDatabaseType: jest.fn(),
     testDatabaseConnection: jest.fn(),
-    checkPrismaClientGenerated: jest.fn()
+    checkPrismaClientGenerated: jest.fn(),
 };
 
 const mockRunner = {
@@ -11,7 +11,7 @@ const mockRunner = {
     checkDatabaseState: jest.fn(),
     runPrismaMigrate: jest.fn(),
     runPrismaDbPush: jest.fn(),
-    getMigrationCommand: jest.fn()
+    getMigrationCommand: jest.fn(),
 };
 
 const mockErrorMessages = {
@@ -19,18 +19,21 @@ const mockErrorMessages = {
     getDatabaseTypeNotConfiguredError: jest.fn(),
     getDatabaseConnectionError: jest.fn(),
     getPrismaCommandError: jest.fn(),
-    getDatabaseSetupSuccess: jest.fn()
+    getDatabaseSetupSuccess: jest.fn(),
 };
 
 jest.mock('../../../utils/database-validator', () => mockValidator);
-jest.mock('@friggframework/core/database/utils/prisma-runner', () => mockRunner);
+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
+    createMockPrismaRunner,
 } = require('../../utils/prisma-mock');
 
 const dotenv = require('dotenv');
@@ -46,16 +49,34 @@ describe('DB Setup Command', () => {
         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);
+        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();
@@ -66,11 +87,19 @@ describe('DB Setup Command', () => {
         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.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');
+        mockErrorMessages.getDatabaseSetupSuccess.mockReturnValue(
+            'Success message'
+        );
     });
 
     afterEach(() => {
@@ -82,87 +111,157 @@ describe('DB Setup Command', () => {
 
     describe('Success Cases', () => {
         it('should complete setup successfully for MongoDB', async () => {
-            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'mongodb' });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'mongodb',
+            });
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
-                generated: false // Client doesn't exist, will generate
+                generated: false, // Client doesn't exist, will generate
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
             });
-            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(
+                mockValidator.checkPrismaClientGenerated
+            ).toHaveBeenCalledWith('mongodb');
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith(
+                'mongodb',
+                false
+            );
             expect(mockRunner.runPrismaDbPush).toHaveBeenCalled();
             expect(mockProcessExit).not.toHaveBeenCalled();
         });
 
+        it('should treat DocumentDB as Mongo-compatible for schema pushes', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'documentdb',
+            });
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false,
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(
+                mockValidator.checkPrismaClientGenerated
+            ).toHaveBeenCalledWith('documentdb');
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith(
+                'mongodb',
+                false
+            );
+            expect(mockRunner.runPrismaDbPush).toHaveBeenCalled();
+            expect(mockConsoleLog).toHaveBeenCalledWith(
+                expect.stringContaining('AWS DocumentDB (MongoDB-compatible)')
+            );
+        });
+
         it('should complete setup successfully for PostgreSQL', async () => {
-            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
-                generated: false // Client doesn't exist, will generate
+                generated: false, // Client doesn't exist, will generate
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
             });
-            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
 
             await dbSetupCommand({ verbose: false, stage: 'development' });
 
-            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('postgresql');
-            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
+            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' });
+            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'));
+            expect(mockConsoleLog).toHaveBeenCalledWith(
+                expect.stringContaining('already up-to-date')
+            );
         });
 
         it('should use migrate dev in development stage', async () => {
-            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
             mockRunner.getMigrationCommand.mockReturnValue('dev');
-            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
 
             await dbSetupCommand({ verbose: false, stage: 'development' });
 
-            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('development');
-            expect(mockRunner.runPrismaMigrate).toHaveBeenCalledWith('dev', false);
+            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' });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
             mockRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
 
             await dbSetupCommand({ verbose: false, stage: 'production' });
 
-            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('production');
-            expect(mockRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', false);
+            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
+                generated: false, // Client doesn't exist, will generate
             });
 
             await dbSetupCommand({ verbose: true, stage: 'development' });
 
-            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', true);
+            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')
-            }));
+            expect(dotenv.config).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    path: expect.stringContaining('.env'),
+                })
+            );
         });
     });
 
@@ -171,17 +270,17 @@ describe('DB Setup Command', () => {
             // Client exists
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
                 generated: true,
-                path: '/path/to/client'
+                path: '/path/to/client',
             });
 
             await dbSetupCommand({ verbose: false, stage: 'development' });
 
             // Should check if client exists
-            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            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();
         });
 
@@ -189,15 +288,20 @@ describe('DB Setup Command', () => {
             // Client does NOT exist
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
                 generated: false,
-                error: 'Client not found'
+                error: 'Client not found',
             });
 
             await dbSetupCommand({ verbose: false, stage: 'development' });
 
             // Should check if client exists
-            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            expect(
+                mockValidator.checkPrismaClientGenerated
+            ).toHaveBeenCalledWith('mongodb');
             // Should call generate
-            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith(
+                'mongodb',
+                false
+            );
             // Should complete setup
             expect(mockProcessExit).not.toHaveBeenCalled();
         });
@@ -206,15 +310,24 @@ describe('DB Setup Command', () => {
             // Client exists
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
                 generated: true,
-                path: '/path/to/client'
+                path: '/path/to/client',
             });
 
-            await dbSetupCommand({ verbose: false, stage: 'development', force: true });
+            await dbSetupCommand({
+                verbose: false,
+                stage: 'development',
+                force: true,
+            });
 
             // Should check if client exists
-            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            expect(
+                mockValidator.checkPrismaClientGenerated
+            ).toHaveBeenCalledWith('mongodb');
             // Should STILL call generate because of --force
-            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith(
+                'mongodb',
+                false
+            );
             // Should complete setup
             expect(mockProcessExit).not.toHaveBeenCalled();
         });
@@ -222,7 +335,7 @@ describe('DB Setup Command', () => {
         it('should show client location in verbose mode when skipping generation', async () => {
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
                 generated: true,
-                path: '/path/to/prisma/client'
+                path: '/path/to/prisma/client',
             });
 
             await dbSetupCommand({ verbose: true, stage: 'development' });
@@ -236,16 +349,25 @@ describe('DB Setup Command', () => {
 
         it('should generate for different database types', async () => {
             // Test PostgreSQL
-            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
-                generated: false
+                generated: false,
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
             });
-            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
 
             await dbSetupCommand({ verbose: false, stage: 'development' });
 
-            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('postgresql');
-            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
+            expect(
+                mockValidator.checkPrismaClientGenerated
+            ).toHaveBeenCalledWith('postgresql');
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith(
+                'postgresql',
+                false
+            );
         });
     });
 
@@ -253,7 +375,7 @@ describe('DB Setup Command', () => {
         it('should fail when DATABASE_URL missing', async () => {
             mockValidator.validateDatabaseUrl.mockReturnValue({
                 valid: false,
-                error: 'DATABASE_URL not found'
+                error: 'DATABASE_URL not found',
             });
 
             await dbSetupCommand({});
@@ -265,68 +387,33 @@ describe('DB Setup Command', () => {
         it('should fail when DATABASE_URL is empty', async () => {
             mockValidator.validateDatabaseUrl.mockReturnValue({
                 valid: false,
-                error: 'DATABASE_URL is empty'
+                error: 'DATABASE_URL is empty',
             });
 
             await dbSetupCommand({});
 
-            expect(mockErrorMessages.getDatabaseUrlMissingError).toHaveBeenCalled();
+            expect(
+                mockErrorMessages.getDatabaseUrlMissingError
+            ).toHaveBeenCalled();
             expect(mockProcessExit).toHaveBeenCalledWith(1);
         });
 
         it('should fail when database type not configured', async () => {
             mockValidator.getDatabaseType.mockReturnValue({
-                error: 'Database not configured'
+                error: 'Database not configured',
             });
 
             await dbSetupCommand({});
 
-            expect(mockErrorMessages.getDatabaseTypeNotConfiguredError).toHaveBeenCalled();
+            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'
+                error: 'Backend not found',
             });
 
             await dbSetupCommand({});
@@ -338,47 +425,53 @@ describe('DB Setup Command', () => {
     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
+                generated: false, // Client doesn't exist, will attempt generation
             });
             mockRunner.runPrismaGenerate.mockResolvedValue({
                 success: false,
-                error: 'Generation failed'
+                error: 'Generation failed',
             });
 
             await dbSetupCommand({});
 
-            expect(mockErrorMessages.getPrismaCommandError).toHaveBeenCalledWith(
-                'generate',
-                'Generation failed'
-            );
+            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' });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
             mockRunner.getMigrationCommand.mockReturnValue('dev');
-            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
             mockRunner.runPrismaMigrate.mockResolvedValue({
                 success: false,
-                error: 'Migration failed'
+                error: 'Migration failed',
             });
 
             await dbSetupCommand({ stage: 'development' });
 
-            expect(mockErrorMessages.getPrismaCommandError).toHaveBeenCalledWith(
-                'migrate',
-                'Migration failed'
-            );
+            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' });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
             mockRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
             mockRunner.runPrismaMigrate.mockResolvedValue({
                 success: false,
-                error: 'Deploy failed'
+                error: 'Deploy failed',
             });
 
             await dbSetupCommand({ stage: 'production' });
@@ -389,25 +482,24 @@ describe('DB Setup Command', () => {
         it('should fail when db push fails (MongoDB)', async () => {
             mockRunner.runPrismaDbPush.mockResolvedValue({
                 success: false,
-                error: 'Push failed'
+                error: 'Push failed',
             });
 
             await dbSetupCommand({});
 
-            expect(mockErrorMessages.getPrismaCommandError).toHaveBeenCalledWith(
-                'db push',
-                'Push failed'
-            );
+            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
+                generated: false, // Client doesn't exist, will attempt generation
             });
             mockRunner.runPrismaGenerate.mockResolvedValue({
                 success: false,
-                error: 'Schema not found'
+                error: 'Schema not found',
             });
 
             await dbSetupCommand({});
@@ -420,36 +512,24 @@ describe('DB Setup Command', () => {
         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'
+                error: 'Not found',
             });
 
             await dbSetupCommand({});
 
-            expect(mockErrorMessages.getDatabaseConnectionError).toHaveBeenCalledWith(
-                'Network error',
-                expect.any(String)
-            );
+            expect(
+                mockErrorMessages.getDatabaseUrlMissingError
+            ).toHaveBeenCalled();
         });
 
         it('should display helpful error for Prisma failures', async () => {
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
-                generated: false // Client doesn't exist, will attempt generation
+                generated: false, // Client doesn't exist, will attempt generation
             });
             mockRunner.runPrismaGenerate.mockResolvedValue({
                 success: false,
                 error: 'Some error',
-                output: 'Detailed output'
+                output: 'Detailed output',
             });
 
             await dbSetupCommand({});
@@ -459,7 +539,7 @@ describe('DB Setup Command', () => {
 
         it('should exit with code 1 on failure', async () => {
             mockValidator.validateDatabaseUrl.mockReturnValue({
-                valid: false
+                valid: false,
             });
 
             await dbSetupCommand({});
@@ -469,7 +549,7 @@ describe('DB Setup Command', () => {
 
         it('should not exit with code 0 on failure', async () => {
             mockValidator.validateDatabaseUrl.mockReturnValue({
-                valid: false
+                valid: false,
             });
 
             await dbSetupCommand({});
@@ -480,10 +560,9 @@ describe('DB Setup Command', () => {
         it('should display success message on completion', async () => {
             await dbSetupCommand({ stage: 'development' });
 
-            expect(mockErrorMessages.getDatabaseSetupSuccess).toHaveBeenCalledWith(
-                'mongodb',
-                'development'
-            );
+            expect(
+                mockErrorMessages.getDatabaseSetupSuccess
+            ).toHaveBeenCalledWith('mongodb', 'development');
         });
     });
 
@@ -497,39 +576,55 @@ describe('DB Setup Command', () => {
 
         it('should pass verbose flag to Prisma commands', async () => {
             mockValidator.checkPrismaClientGenerated.mockReturnValue({
-                generated: false // Client doesn't exist, will generate
+                generated: false, // Client doesn't exist, will generate
             });
 
             await dbSetupCommand({ verbose: true });
 
-            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', 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
+                generated: false, // Client doesn't exist, will generate
             });
 
             await dbSetupCommand({ verbose: false });
 
-            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', 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 });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
 
             await dbSetupCommand({ stage: 'production' });
 
-            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('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 });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
 
             await dbSetupCommand({});
 
@@ -537,12 +632,18 @@ describe('DB Setup Command', () => {
         });
 
         it('should handle different stage values', async () => {
-            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
-            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+            mockValidator.getDatabaseType.mockReturnValue({
+                dbType: 'postgresql',
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({
+                upToDate: false,
+            });
 
             await dbSetupCommand({ stage: 'staging' });
 
-            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith('staging');
+            expect(mockRunner.getMigrationCommand).toHaveBeenCalledWith(
+                'staging'
+            );
         });
     });
 });