@friggframework/devtools 2.0.0--canary.520.6641121.0 → 2.0.0--canary.522.cbd3d5a.0

package/frigg-cli/__tests__/unit/commands/repair.test.js

@@ -0,0 +1,275 @@
+/**
+ * Unit tests for frigg repair command
+ * Tests repair workflow orchestration and output usage
+ */
+
+// Mock all external dependencies
+jest.mock('../../../utils/output');
+jest.mock('../../../repair-command/index.js', () => {
+    const actualModule = jest.requireActual('../../../repair-command/index.js');
+    return actualModule;
+}, { virtual: false });
+
+const output = require('../../../utils/output');
+
+describe('Repair Command - Output Integration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        // Setup output mocks
+        output.success = jest.fn();
+        output.error = jest.fn();
+        output.info = jest.fn();
+        output.warn = jest.fn();
+        output.log = jest.fn();
+        output.confirm = jest.fn();
+    });
+
+    describe('Output method usage', () => {
+        test('should use output.success for successful operations', () => {
+            // Test that success messages use output.success
+            output.success(' No orphaned resources to import');
+
+            expect(output.success).toHaveBeenCalledWith(
+                expect.stringContaining('No orphaned resources')
+            );
+        });
+
+        test('should use output.error for error messages', () => {
+            // Test that errors use output.error
+            const error = new Error('Stack not found');
+            output.error('An error occurred:', error);
+
+            expect(output.error).toHaveBeenCalledWith('An error occurred:', error);
+        });
+
+        test('should use output.info for informational messages', () => {
+            // Test that info messages use output.info with emoji
+            output.info('🔍 Analyzing stack health...');
+
+            expect(output.info).toHaveBeenCalledWith(
+                expect.stringContaining('Analyzing stack')
+            );
+        });
+
+        test('should use output.warn for warnings', () => {
+            // Test that warnings use output.warn
+            output.warn('️  Build template not found');
+
+            expect(output.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Build template not found')
+            );
+        });
+
+        test('should use output.log for general messages', () => {
+            // Test that general messages use output.log
+            output.log('  • serverless package');
+
+            expect(output.log).toHaveBeenCalledWith(
+                expect.stringContaining('serverless package')
+            );
+        });
+
+        test('should use output.confirm for user confirmations', async () => {
+            // Test that confirmations use output.confirm
+            output.confirm.mockResolvedValue(true);
+
+            const result = await output.confirm('Import 5 orphaned resource(s)?');
+
+            expect(output.confirm).toHaveBeenCalledWith(
+                expect.stringContaining('Import')
+            );
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('Error handling scenarios', () => {
+        test('should handle and report stack not found errors', () => {
+            const error = new Error('Stack does not exist');
+            output.error('An error occurred:', error);
+
+            expect(output.error).toHaveBeenCalledWith('An error occurred:', error);
+        });
+
+        test('should handle and report import validation errors', () => {
+            output.log('\nValidation errors:');
+            output.log('  • Resource1: Invalid property');
+
+            expect(output.log).toHaveBeenCalledWith('\nValidation errors:');
+            expect(output.log).toHaveBeenCalledWith(expect.stringContaining('Invalid property'));
+        });
+
+        test('should handle and report AWS API errors', () => {
+            const error = new Error('AccessDenied: Insufficient permissions');
+            output.error('An error occurred:', error);
+
+            expect(output.error).toHaveBeenCalledWith('An error occurred:', error);
+        });
+    });
+
+    describe('User workflow scenarios', () => {
+        test('should report when no orphaned resources are found', () => {
+            output.success(' No orphaned resources to import');
+
+            expect(output.success).toHaveBeenCalled();
+            expect(output.success).toHaveBeenCalledWith(
+                expect.stringContaining('No orphaned resources')
+            );
+        });
+
+        test('should list orphaned resources before import', () => {
+            output.info('📦 Found 3 orphaned resource(s) to import:');
+            output.log('  1. AWS::Lambda::Function - my-function');
+            output.log('  2. AWS::S3::Bucket - my-bucket');
+            output.log('  3. AWS::DynamoDB::Table - my-table');
+
+            expect(output.info).toHaveBeenCalledWith(
+                expect.stringMatching(/Found \d+ orphaned/)
+            );
+            expect(output.log).toHaveBeenCalledTimes(3);
+        });
+
+        test('should warn when build template is missing', () => {
+            output.warn('️  Build template not found. Generating sequential logical IDs (not recommended).');
+            output.log('   Run one of the following to generate build template:');
+            output.log('     • serverless package');
+
+            expect(output.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Build template not found')
+            );
+            expect(output.log).toHaveBeenCalledWith(
+                expect.stringContaining('serverless package')
+            );
+        });
+
+        test('should confirm before performing import', async () => {
+            output.confirm.mockResolvedValue(true);
+
+            const confirmed = await output.confirm('Import 5 orphaned resource(s) with sequential IDs?');
+
+            expect(output.confirm).toHaveBeenCalled();
+            expect(confirmed).toBe(true);
+        });
+
+        test('should handle user cancellation gracefully', async () => {
+            output.confirm.mockResolvedValue(false);
+
+            const confirmed = await output.confirm('Import resources?');
+            if (!confirmed) {
+                output.log('Import cancelled');
+            }
+
+            expect(output.confirm).toHaveBeenCalled();
+            expect(output.log).toHaveBeenCalledWith('Import cancelled');
+        });
+
+        test('should report successful import results', () => {
+            output.success(' Successfully imported 5 resource(s)');
+
+            expect(output.success).toHaveBeenCalledWith(
+                expect.stringMatching(/Successfully imported \d+/)
+            );
+        });
+    });
+
+    describe('Repair workflow stages', () => {
+        test('should progress through health check stage', () => {
+            output.info('🏥 Running health check on stack...');
+
+            expect(output.info).toHaveBeenCalledWith(
+                expect.stringContaining('health check')
+            );
+        });
+
+        test('should progress through import stage', () => {
+            output.info('🔧 Importing resources with sequential IDs...');
+
+            expect(output.info).toHaveBeenCalledWith(
+                expect.stringContaining('Importing resources')
+            );
+        });
+
+        test('should progress through reconciliation stage', () => {
+            output.info('🔄 Reconciling property drift...');
+
+            expect(output.info).toHaveBeenCalledWith(
+                expect.stringContaining('Reconciling')
+            );
+        });
+
+        test('should report completion with summary', () => {
+            output.success(' Repair completed successfully');
+            output.log('\nSummary:');
+            output.log('  • Imported: 5 resources');
+            output.log('  • Reconciled: 3 properties');
+
+            expect(output.success).toHaveBeenCalledWith(
+                expect.stringContaining('completed successfully')
+            );
+            expect(output.log).toHaveBeenCalledWith('\nSummary:');
+        });
+    });
+
+    describe('Output consistency', () => {
+        test('should not use console.log directly', () => {
+            // Verify that all logging goes through output module
+            const consoleLogSpy = jest.spyOn(console, 'log');
+
+            output.log('Test message');
+
+            // output.log may call console.log internally, but command code shouldn't
+            expect(output.log).toHaveBeenCalled();
+
+            consoleLogSpy.mockRestore();
+        });
+
+        test('should not use console.error directly', () => {
+            // Verify that all errors go through output module
+            const consoleErrorSpy = jest.spyOn(console, 'error');
+
+            const error = new Error('Test error');
+            output.error('An error occurred:', error);
+
+            // output.error may call console.error internally, but command code shouldn't
+            expect(output.error).toHaveBeenCalled();
+
+            consoleErrorSpy.mockRestore();
+        });
+
+        test('should use consistent emoji patterns', () => {
+            // Verify emoji usage follows patterns
+            output.success(' Success message'); // ✓ or ✅
+            output.error(' Error message'); // ✗ or ❌
+            output.warn('️ Warning message'); // ⚠️
+            output.info('🔍 Info message'); // Various info emojis
+
+            expect(output.success).toHaveBeenCalled();
+            expect(output.error).toHaveBeenCalled();
+            expect(output.warn).toHaveBeenCalled();
+            expect(output.info).toHaveBeenCalled();
+        });
+    });
+
+    describe('Migration verification', () => {
+        test('should have migrated all console.log calls', () => {
+            // This test verifies the migration was complete
+            // In the actual command file, there should be 0 console.log references
+            expect(output.log).toBeDefined();
+            expect(output.info).toBeDefined();
+            expect(output.success).toBeDefined();
+        });
+
+        test('should have migrated all console.error calls', () => {
+            // This test verifies the migration was complete
+            // In the actual command file, there should be 0 console.error references
+            expect(output.error).toBeDefined();
+            expect(output.warn).toBeDefined();
+        });
+
+        test('should have migrated readline confirm to output.confirm', () => {
+            // This test verifies readline was replaced with output.confirm
+            expect(output.confirm).toBeDefined();
+            expect(typeof output.confirm).toBe('function');
+        });
+    });
+});

package/frigg-cli/__tests__/unit/start-command/application/RunPreflightChecksUseCase.test.js

@@ -0,0 +1,411 @@
+/**
+ * RunPreflightChecksUseCase Tests
+ * Orchestrates pre-flight checks before starting Frigg
+ *
+ * Tests follow TDD pattern - written BEFORE implementation
+ */
+
+const { RunPreflightChecksUseCase } = require('../../../../start-command/application/RunPreflightChecksUseCase');
+
+describe('RunPreflightChecksUseCase', () => {
+    let useCase;
+    let mockDockerAdapter;
+    let mockDatabaseAdapter;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        // Reset environment
+        delete process.env.DATABASE_URL;
+
+        mockDockerAdapter = {
+            isDockerInstalled: jest.fn(),
+            isDockerRunning: jest.fn(),
+            findDockerComposeFile: jest.fn(),
+            startDockerDesktop: jest.fn(),
+            startDockerCompose: jest.fn(),
+            waitForDockerReady: jest.fn(),
+            waitForLocalStack: jest.fn()
+        };
+
+        mockDatabaseAdapter = {
+            getDatabaseType: jest.fn(),
+            isDatabaseReachable: jest.fn(),
+            getConnectionDetails: jest.fn()
+        };
+
+        useCase = new RunPreflightChecksUseCase({
+            dockerAdapter: mockDockerAdapter,
+            databaseAdapter: mockDatabaseAdapter
+        });
+    });
+
+    describe('execute() - All checks pass', () => {
+        beforeEach(() => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(true);
+            mockDockerAdapter.findDockerComposeFile.mockResolvedValue('/test/docker-compose.yml');
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: true });
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({ reachable: true });
+            mockDatabaseAdapter.getConnectionDetails.mockReturnValue({
+                type: 'mongodb',
+                host: 'localhost',
+                port: 27017,
+                database: 'frigg'
+            });
+        });
+
+        it('should return all checks passed when everything is ready', async () => {
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            expect(result.allPassed).toBe(true);
+            // 5 checks: DATABASE_URL, docker_installed, docker_running, database_reachable, localstack_reachable
+            expect(result.checks).toHaveLength(5);
+        });
+
+        it('should include DATABASE_URL check result', async () => {
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbUrlCheck = result.checks.find(c => c.name === 'database_url');
+            expect(dbUrlCheck.status).toBe('passed');
+        });
+
+        it('should include Docker installed check result', async () => {
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerCheck = result.checks.find(c => c.name === 'docker_installed');
+            expect(dockerCheck.status).toBe('passed');
+        });
+
+        it('should include Docker running check result', async () => {
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerRunningCheck = result.checks.find(c => c.name === 'docker_running');
+            expect(dockerRunningCheck.status).toBe('passed');
+        });
+
+        it('should include database reachable check result', async () => {
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbCheck = result.checks.find(c => c.name === 'database_reachable');
+            expect(dbCheck.status).toBe('passed');
+        });
+    });
+
+    describe('execute() - DATABASE_URL check', () => {
+        it('should fail when DATABASE_URL is not set', async () => {
+            delete process.env.DATABASE_URL;
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            expect(result.allPassed).toBe(false);
+            const dbUrlCheck = result.checks.find(c => c.name === 'database_url');
+            expect(dbUrlCheck.status).toBe('failed');
+            expect(dbUrlCheck.message).toContain('DATABASE_URL');
+        });
+
+        it('should provide resolution option for missing DATABASE_URL', async () => {
+            delete process.env.DATABASE_URL;
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbUrlCheck = result.checks.find(c => c.name === 'database_url');
+            expect(dbUrlCheck.canResolve).toBe(true);
+            expect(dbUrlCheck.resolution.type).toBe('create_env');
+        });
+
+        it('should pass when DATABASE_URL is set', async () => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbUrlCheck = result.checks.find(c => c.name === 'database_url');
+            expect(dbUrlCheck.status).toBe('passed');
+        });
+    });
+
+    describe('execute() - Docker installed check', () => {
+        beforeEach(() => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+        });
+
+        it('should fail when Docker is not installed', async () => {
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(false);
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerCheck = result.checks.find(c => c.name === 'docker_installed');
+            expect(dockerCheck.status).toBe('failed');
+            expect(dockerCheck.message).toContain('Docker is not installed');
+        });
+
+        it('should not provide auto-resolution for Docker not installed', async () => {
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(false);
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerCheck = result.checks.find(c => c.name === 'docker_installed');
+            expect(dockerCheck.canResolve).toBe(false);
+            expect(dockerCheck.resolution.type).toBe('manual');
+            expect(dockerCheck.resolution.instructions).toBeDefined();
+        });
+
+        it('should pass when Docker is installed', async () => {
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(true);
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: true });
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({ reachable: true });
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerCheck = result.checks.find(c => c.name === 'docker_installed');
+            expect(dockerCheck.status).toBe('passed');
+        });
+    });
+
+    describe('execute() - Docker running check', () => {
+        beforeEach(() => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: true });
+        });
+
+        it('should fail when Docker daemon is not running', async () => {
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(false);
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerRunningCheck = result.checks.find(c => c.name === 'docker_running');
+            expect(dockerRunningCheck.status).toBe('failed');
+            expect(dockerRunningCheck.message).toContain('Docker is not running');
+        });
+
+        it('should provide resolution option to start Docker', async () => {
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(false);
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerRunningCheck = result.checks.find(c => c.name === 'docker_running');
+            expect(dockerRunningCheck.canResolve).toBe(true);
+            expect(dockerRunningCheck.resolution.type).toBe('start_docker');
+        });
+
+        it('should pass when Docker is running', async () => {
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(true);
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: true });
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({ reachable: true });
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dockerRunningCheck = result.checks.find(c => c.name === 'docker_running');
+            expect(dockerRunningCheck.status).toBe('passed');
+        });
+    });
+
+    describe('execute() - Database reachable check', () => {
+        beforeEach(() => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(true);
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: true });
+        });
+
+        it('should fail when database is not reachable', async () => {
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({
+                reachable: false,
+                error: 'ECONNREFUSED'
+            });
+            mockDockerAdapter.findDockerComposeFile.mockResolvedValue('/test/docker-compose.yml');
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbCheck = result.checks.find(c => c.name === 'database_reachable');
+            expect(dbCheck.status).toBe('failed');
+            expect(dbCheck.message).toContain('Database is not reachable');
+        });
+
+        it('should provide docker-compose resolution when file exists', async () => {
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({
+                reachable: false,
+                error: 'ECONNREFUSED'
+            });
+            mockDockerAdapter.findDockerComposeFile.mockResolvedValue('/test/docker-compose.yml');
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbCheck = result.checks.find(c => c.name === 'database_reachable');
+            expect(dbCheck.canResolve).toBe(true);
+            expect(dbCheck.resolution.type).toBe('start_docker_compose');
+            expect(dbCheck.resolution.composePath).toBe('/test/docker-compose.yml');
+        });
+
+        it('should suggest manual setup when no docker-compose exists', async () => {
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({
+                reachable: false,
+                error: 'ECONNREFUSED'
+            });
+            mockDockerAdapter.findDockerComposeFile.mockResolvedValue(null);
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbCheck = result.checks.find(c => c.name === 'database_reachable');
+            expect(dbCheck.canResolve).toBe(false);
+            expect(dbCheck.resolution.type).toBe('manual');
+        });
+
+        it('should pass when database is reachable', async () => {
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({ reachable: true });
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const dbCheck = result.checks.find(c => c.name === 'database_reachable');
+            expect(dbCheck.status).toBe('passed');
+        });
+    });
+
+    describe('execute() - LocalStack reachable check', () => {
+        beforeEach(() => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(true);
+            mockDatabaseAdapter.isDatabaseReachable.mockResolvedValue({ reachable: true });
+        });
+
+        it('should fail when LocalStack is not reachable', async () => {
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: false });
+            mockDockerAdapter.findDockerComposeFile.mockResolvedValue('/test/docker-compose.yml');
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const localstackCheck = result.checks.find(c => c.name === 'localstack_reachable');
+            expect(localstackCheck.status).toBe('failed');
+            expect(localstackCheck.message).toContain('LocalStack is not reachable');
+        });
+
+        it('should provide docker-compose resolution when LocalStack is not reachable', async () => {
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: false });
+            mockDockerAdapter.findDockerComposeFile.mockResolvedValue('/test/docker-compose.yml');
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const localstackCheck = result.checks.find(c => c.name === 'localstack_reachable');
+            expect(localstackCheck.canResolve).toBe(true);
+            expect(localstackCheck.resolution.type).toBe('start_docker_compose');
+        });
+
+        it('should pass when LocalStack is reachable', async () => {
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: true });
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const localstackCheck = result.checks.find(c => c.name === 'localstack_reachable');
+            expect(localstackCheck.status).toBe('passed');
+        });
+
+        it('should skip LocalStack check when AWS_ENDPOINT points to real AWS', async () => {
+            process.env.AWS_ENDPOINT = 'https://sqs.us-east-1.amazonaws.com';
+            mockDockerAdapter.waitForLocalStack.mockResolvedValue({ ready: true });
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            // Should not include LocalStack check when using real AWS
+            const localstackCheck = result.checks.find(c => c.name === 'localstack_reachable');
+            expect(localstackCheck).toBeUndefined();
+
+            delete process.env.AWS_ENDPOINT;
+        });
+    });
+
+    describe('execute() - Short-circuit behavior', () => {
+        it('should skip Docker checks if DATABASE_URL is missing', async () => {
+            delete process.env.DATABASE_URL;
+
+            await useCase.execute({ projectPath: '/test/project' });
+
+            // Docker checks should not be called since DATABASE_URL failed
+            expect(mockDockerAdapter.isDockerInstalled).not.toHaveBeenCalled();
+        });
+
+        it('should skip Docker running check if Docker not installed', async () => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(false);
+
+            await useCase.execute({ projectPath: '/test/project' });
+
+            expect(mockDockerAdapter.isDockerRunning).not.toHaveBeenCalled();
+        });
+
+        it('should skip database reachable check if Docker not running', async () => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(false);
+
+            await useCase.execute({ projectPath: '/test/project' });
+
+            expect(mockDatabaseAdapter.isDatabaseReachable).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('getFailedChecks()', () => {
+        it('should return only failed checks', async () => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(false);
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+            const failed = useCase.getFailedChecks(result);
+
+            expect(failed).toHaveLength(1);
+            expect(failed[0].name).toBe('docker_running');
+        });
+    });
+
+    describe('getResolvableChecks()', () => {
+        it('should return only checks that can be auto-resolved', async () => {
+            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg';
+            mockDatabaseAdapter.getDatabaseType.mockReturnValue('mongodb');
+            mockDockerAdapter.isDockerInstalled.mockResolvedValue(true);
+            mockDockerAdapter.isDockerRunning.mockResolvedValue(false);
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+            const resolvable = useCase.getResolvableChecks(result);
+
+            expect(resolvable).toHaveLength(1);
+            expect(resolvable[0].canResolve).toBe(true);
+        });
+    });
+
+    describe('Check result structure', () => {
+        it('should include all required fields in check results', async () => {
+            delete process.env.DATABASE_URL;
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const check = result.checks[0];
+            expect(check).toHaveProperty('name');
+            expect(check).toHaveProperty('status');
+            expect(check).toHaveProperty('message');
+            expect(check).toHaveProperty('canResolve');
+            expect(check).toHaveProperty('resolution');
+        });
+
+        it('should include resolution details for failed checks', async () => {
+            delete process.env.DATABASE_URL;
+
+            const result = await useCase.execute({ projectPath: '/test/project' });
+
+            const check = result.checks.find(c => c.name === 'database_url');
+            expect(check.resolution).toHaveProperty('type');
+        });
+    });
+});