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

package/frigg-cli/start-command/start-command.test.js

@@ -1,297 +0,0 @@
-/**
- * Test suite for the frigg start command
- *
- * These tests ensure that the start command properly:
- * 1. Sets FRIGG_SKIP_AWS_DISCOVERY=true in the parent process to skip AWS API calls
- * 2. Suppresses AWS SDK maintenance mode warnings
- * 3. Spawns serverless with correct configuration
- * 4. Validates database configuration before starting
- *
- * This fixes the issue where frigg start would attempt AWS discovery during local development,
- * causing unnecessary AWS API calls and potential failures when AWS credentials aren't available.
- */
-
-// Mock dependencies BEFORE importing startCommand
-const mockValidator = {
-    validateDatabaseUrl: jest.fn(),
-    getDatabaseType: jest.fn(),
-    checkPrismaClientGenerated: jest.fn()
-};
-
-jest.mock('node:child_process', () => ({
-    spawn: jest.fn(),
-}));
-
-jest.mock('../utils/database-validator', () => mockValidator);
-jest.mock('dotenv');
-
-const { spawn } = require('node:child_process');
-const { startCommand } = require('./index');
-const { createMockDatabaseValidator } = require('../__tests__/utils/prisma-mock');
-const dotenv = require('dotenv');
-
-describe('startCommand', () => {
-    let mockChildProcess;
-    let mockProcessExit;
-
-    beforeEach(() => {
-        // Mock process.exit to throw error and stop execution (prevents actual exits)
-        const exitError = new Error('process.exit called');
-        exitError.code = 'PROCESS_EXIT';
-        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {
-            throw exitError;
-        });
-
-        // Reset mocks
-        jest.clearAllMocks();
-
-        // Re-apply process.exit mock after clearAllMocks
-        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {
-            throw exitError;
-        });
-
-        // Set up default database validator mocks for all tests
-        const defaultValidator = createMockDatabaseValidator();
-        mockValidator.validateDatabaseUrl.mockReturnValue(defaultValidator.validateDatabaseUrl());
-        mockValidator.getDatabaseType.mockReturnValue(defaultValidator.getDatabaseType());
-        mockValidator.checkPrismaClientGenerated.mockReturnValue(defaultValidator.checkPrismaClientGenerated());
-
-        // Mock dotenv
-        dotenv.config = jest.fn();
-
-        // Clear environment variables
-        delete process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE;
-        delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
-
-        // Create a mock child process
-        mockChildProcess = {
-            on: jest.fn(),
-            stdout: { on: jest.fn() },
-            stderr: { on: jest.fn() },
-        };
-
-        spawn.mockReturnValue(mockChildProcess);
-    });
-
-    afterEach(() => {
-        // Restore process.exit
-        if (mockProcessExit) {
-            mockProcessExit.mockRestore();
-        }
-
-        // Clean up environment
-        delete process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE;
-        delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
-    });
-
-    it('should set FRIGG_SKIP_AWS_DISCOVERY to true in the parent process', async () => {
-        const options = { stage: 'dev' };
-
-        await startCommand(options);
-
-        // Verify the environment variable is set in the parent process
-        expect(process.env.FRIGG_SKIP_AWS_DISCOVERY).toBe('true');
-    });
-
-    it('should set AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE to suppress warnings', async () => {
-        const options = { stage: 'dev' };
-
-        await startCommand(options);
-
-        expect(process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE).toBe('1');
-    });
-
-    it('should spawn serverless with correct arguments', async () => {
-        const options = { stage: 'prod' };
-
-        await startCommand(options);
-
-        expect(spawn).toHaveBeenCalledWith(
-            'serverless',
-            ['offline', '--config', 'infrastructure.js', '--stage', 'prod'],
-            expect.objectContaining({
-                cwd: expect.any(String),
-                stdio: 'inherit',
-                env: expect.objectContaining({
-                    FRIGG_SKIP_AWS_DISCOVERY: 'true',
-                }),
-            })
-        );
-    });
-
-    it('should include verbose flag when verbose option is enabled', async () => {
-        const options = { stage: 'dev', verbose: true };
-
-        await startCommand(options);
-
-        expect(spawn).toHaveBeenCalledWith(
-            'serverless',
-            ['offline', '--config', 'infrastructure.js', '--stage', 'dev', '--verbose'],
-            expect.any(Object)
-        );
-    });
-
-    it('should pass FRIGG_SKIP_AWS_DISCOVERY in spawn environment', async () => {
-        const options = { stage: 'dev' };
-
-        await startCommand(options);
-
-        const spawnCall = spawn.mock.calls[0];
-        const spawnOptions = spawnCall[2];
-
-        expect(spawnOptions.env).toHaveProperty('FRIGG_SKIP_AWS_DISCOVERY', 'true');
-    });
-
-    it('should handle child process errors', async () => {
-        const options = { stage: 'dev' };
-        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-
-        await startCommand(options);
-
-        // Simulate an error
-        const errorCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'error')[1];
-        const testError = new Error('Test error');
-        errorCallback(testError);
-
-        expect(consoleErrorSpy).toHaveBeenCalledWith('Error executing command: Test error');
-
-        consoleErrorSpy.mockRestore();
-    });
-
-    it('should handle child process exit with non-zero code', async () => {
-        const options = { stage: 'dev' };
-        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-
-        await startCommand(options);
-
-        // Simulate exit with error code
-        const closeCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'close')[1];
-        closeCallback(1);
-
-        expect(consoleLogSpy).toHaveBeenCalledWith('Child process exited with code 1');
-
-        consoleLogSpy.mockRestore();
-    });
-
-    it('should not log on successful exit', async () => {
-        const options = { stage: 'dev' };
-        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-
-        await startCommand(options);
-
-        // Clear the spy calls from startCommand execution
-        consoleLogSpy.mockClear();
-
-        // Simulate successful exit
-        const closeCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'close')[1];
-        closeCallback(0);
-
-        // Should not log anything for successful exit
-        expect(consoleLogSpy).not.toHaveBeenCalledWith(expect.stringContaining('exited'));
-
-        consoleLogSpy.mockRestore();
-    });
-
-    describe('Database Pre-flight Validation', () => {
-        let mockConsoleError;
-
-        beforeEach(() => {
-            // Mock console.error (all other mocks are set up in outer beforeEach)
-            mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
-        });
-
-        afterEach(() => {
-            mockConsoleError.mockRestore();
-        });
-
-        it('should pass pre-flight checks when database valid', async () => {
-            const options = { stage: 'dev' };
-
-            await startCommand(options);
-
-            expect(mockValidator.validateDatabaseUrl).toHaveBeenCalled();
-            expect(mockValidator.getDatabaseType).toHaveBeenCalled();
-            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalled();
-            expect(mockProcessExit).not.toHaveBeenCalled();
-            expect(spawn).toHaveBeenCalled();
-        });
-
-        it('should fail when DATABASE_URL missing', async () => {
-            mockValidator.validateDatabaseUrl.mockReturnValue({
-                valid: false,
-                error: 'DATABASE_URL not found'
-            });
-
-            await expect(startCommand({})).rejects.toThrow('process.exit called');
-
-            expect(mockConsoleError).toHaveBeenCalled();
-            expect(mockProcessExit).toHaveBeenCalledWith(1);
-            expect(spawn).not.toHaveBeenCalled();
-        });
-
-        it('should fail when database type not configured', async () => {
-            mockValidator.getDatabaseType.mockReturnValue({
-                error: 'Database not configured'
-            });
-
-            await expect(startCommand({})).rejects.toThrow('process.exit called');
-
-            expect(mockConsoleError).toHaveBeenCalled();
-            expect(mockProcessExit).toHaveBeenCalledWith(1);
-            expect(spawn).not.toHaveBeenCalled();
-        });
-
-        it('should fail when Prisma client not generated', async () => {
-            mockValidator.checkPrismaClientGenerated.mockReturnValue({
-                generated: false,
-                error: 'Client not found'
-            });
-
-            await expect(startCommand({})).rejects.toThrow('process.exit called');
-
-            expect(mockConsoleError).toHaveBeenCalled();
-            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('frigg db:setup'));
-            expect(mockProcessExit).toHaveBeenCalledWith(1);
-            expect(spawn).not.toHaveBeenCalled();
-        });
-
-        it('should suggest running frigg db:setup when client missing', async () => {
-            mockValidator.checkPrismaClientGenerated.mockReturnValue({
-                generated: false,
-                error: 'Client not generated'
-            });
-
-            await expect(startCommand({})).rejects.toThrow('process.exit called');
-
-            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('frigg db:setup'));
-        });
-
-        it('should exit with code 1 on validation failure', async () => {
-            mockValidator.validateDatabaseUrl.mockReturnValue({
-                valid: false
-            });
-
-            await expect(startCommand({})).rejects.toThrow('process.exit called');
-
-            expect(mockProcessExit).toHaveBeenCalledWith(1);
-        });
-
-        it('should continue to serverless start when validation passes', async () => {
-            await startCommand({ stage: 'dev' });
-
-            expect(spawn).toHaveBeenCalledWith(
-                'serverless',
-                expect.arrayContaining(['offline']),
-                expect.any(Object)
-            );
-        });
-
-        it('should load .env before validation', async () => {
-            await startCommand({});
-
-            expect(dotenv.config).toHaveBeenCalledWith(expect.objectContaining({
-                path: expect.stringContaining('.env')
-            }));
-        });
-    });
-});

package/frigg-cli/test/init-command.test.js

@@ -1,180 +0,0 @@
-const path = require('path');
-const fs = require('fs-extra');
-const { initCommand } = require('../init-command');
-const BackendFirstHandler = require('../init-command/backend-first-handler');
-
-// Mock dependencies
-jest.mock('fs-extra');
-jest.mock('chalk', () => ({
-    blue: jest.fn(text => text),
-    green: jest.fn(text => text),
-    red: jest.fn(text => text),
-    yellow: jest.fn(text => text),
-    gray: jest.fn(text => text),
-    cyan: jest.fn(text => text),
-    bold: jest.fn(text => text)
-}));
-jest.mock('@inquirer/prompts');
-jest.mock('child_process');
-jest.mock('cross-spawn');
-jest.mock('../init-command/backend-first-handler');
-jest.mock('validate-npm-package-name');
-
-describe('Init Command', () => {
-    const mockProjectPath = '/test/project/path';
-    const mockProjectName = 'test-project';
-    let mockExit;
-    let mockConsoleLog;
-    const validateProjectName = require('validate-npm-package-name');
-    
-    beforeEach(() => {
-        jest.clearAllMocks();
-        
-        // Mock process.exit
-        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
-            throw new Error('process.exit');
-        });
-        
-        // Mock console.log and console.error
-        mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
-        jest.spyOn(console, 'error').mockImplementation();
-        
-        // Reset fs mocks
-        const fs = require('fs-extra');
-        fs.ensureDirSync.mockImplementation(() => {});
-        fs.pathExists.mockResolvedValue(false);
-        fs.readdir.mockResolvedValue([]);
-        fs.readdirSync.mockReturnValue([]);
-        fs.writeFileSync.mockImplementation(() => {});
-        fs.lstatSync.mockReturnValue({ isDirectory: () => false });
-        
-        // Mock BackendFirstHandler
-        BackendFirstHandler.mockImplementation(() => ({
-            initialize: jest.fn().mockResolvedValue()
-        }));
-        
-        // Mock validate-npm-package-name
-        validateProjectName.mockReturnValue({
-            validForNewPackages: true,
-            errors: [],
-            warnings: []
-        });
-    });
-    
-    afterEach(() => {
-        mockExit.mockRestore();
-        mockConsoleLog.mockRestore();
-    });
-
-    describe('Validation', () => {
-        it('should validate project name', async () => {
-            validateProjectName.mockReturnValue({
-                validForNewPackages: false,
-                errors: ['Invalid name'],
-                warnings: []
-            });
-            
-            await expect(initCommand('invalid-name', {})).rejects.toThrow('process.exit');
-            expect(mockExit).toHaveBeenCalledWith(1);
-            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('npm naming restrictions'));
-        });
-
-        it('should accept valid project names', async () => {
-            validateProjectName.mockReturnValue({
-                validForNewPackages: true,
-                errors: [],
-                warnings: []
-            });
-            
-            await initCommand('valid-name', {});
-            expect(BackendFirstHandler).toHaveBeenCalled();
-        });
-
-        it('should check Node.js version compatibility', async () => {
-            const originalVersion = process.version;
-            Object.defineProperty(process, 'version', {
-                value: 'v12.0.0',
-                configurable: true
-            });
-
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            await initCommand(mockProjectName, {});
-            
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Node 14 or higher'));
-            
-            Object.defineProperty(process, 'version', {
-                value: originalVersion,
-                configurable: true
-            });
-            consoleSpy.mockRestore();
-        });
-    });
-
-    describe('Project Creation Modes', () => {
-        it('should use BackendFirstHandler by default', async () => {
-            await initCommand(mockProjectName, {});
-            
-            expect(BackendFirstHandler).toHaveBeenCalledWith(
-                expect.stringContaining(mockProjectName),
-                expect.objectContaining({
-                    force: false,
-                    verbose: false
-                })
-            );
-        });
-
-        it('should pass options to BackendFirstHandler', async () => {
-            const options = {
-                force: true,
-                verbose: true,
-                mode: 'standalone',
-                frontend: false
-            };
-            
-            await initCommand(mockProjectName, options);
-            
-            expect(BackendFirstHandler).toHaveBeenCalledWith(
-                expect.any(String),
-                expect.objectContaining(options)
-            );
-        });
-
-        it('should handle initialization errors gracefully', async () => {
-            const mockError = new Error('Initialization failed');
-            BackendFirstHandler.mockImplementation(() => ({
-                initialize: jest.fn().mockRejectedValue(mockError)
-            }));
-            
-            await expect(initCommand(mockProjectName, {})).rejects.toThrow('process.exit');
-            
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Aborting'));
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-    });
-
-    describe('Directory Safety', () => {
-        it('should check if directory is safe to use', async () => {
-            BackendFirstHandler.mockImplementation(() => ({
-                initialize: jest.fn().mockRejectedValue(new Error('Directory not empty'))
-            }));
-            
-            await expect(initCommand(mockProjectName, {})).rejects.toThrow('process.exit');
-            
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-
-        it('should allow safe files in directory', async () => {
-            await initCommand(mockProjectName, {});
-            expect(BackendFirstHandler).toHaveBeenCalled();
-        });
-
-        it('should force overwrite when --force flag is used', async () => {
-            await initCommand(mockProjectName, { force: true });
-            expect(BackendFirstHandler).toHaveBeenCalledWith(
-                expect.any(String),
-                expect.objectContaining({ force: true })
-            );
-        });
-    });
-
-});