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

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

@@ -0,0 +1,320 @@
+/**
+ * Test suite for deploy command
+ *
+ * Tests the serverless deployment functionality including:
+ * - Command execution with spawn
+ * - Stage option handling
+ * - Environment variable filtering and propagation
+ * - SLS_STAGE propagation for resource discovery
+ * - Error handling
+ */
+
+// Mock dependencies BEFORE requiring modules
+jest.mock('child_process', () => ({
+  spawn: jest.fn()
+}));
+
+jest.mock('fs', () => ({
+  existsSync: jest.fn()
+}));
+
+// Require after mocks
+const { spawn } = require('child_process');
+const fs = require('fs');
+const { deployCommand } = require('../../../deploy-command');
+
+describe('CLI Command: deploy', () => {
+  let consoleLogSpy;
+  let consoleWarnSpy;
+  let consoleErrorSpy;
+  let mockChildProcess;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Mock console methods
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+    // Mock child process
+    mockChildProcess = {
+      on: jest.fn()
+    };
+
+    // Mock successful spawn by default
+    spawn.mockReturnValue(mockChildProcess);
+
+    // Mock fs.existsSync to return false (no app definition)
+    fs.existsSync.mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('Success Cases', () => {
+    it('should spawn serverless with default stage', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        ['deploy', '--config', 'infrastructure.js', '--stage', 'dev'],
+        expect.objectContaining({
+          cwd: expect.any(String),
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should spawn serverless with production stage', async () => {
+      await deployCommand({ stage: 'production' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        expect.arrayContaining(['--stage', 'production']),
+        expect.any(Object)
+      );
+    });
+
+    it('should spawn serverless with qa stage', async () => {
+      await deployCommand({ stage: 'qa' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        expect.arrayContaining(['--stage', 'qa']),
+        expect.any(Object)
+      );
+    });
+
+    it('should spawn serverless with --force flag when force option is true', async () => {
+      await deployCommand({ stage: 'dev', force: true });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        ['deploy', '--config', 'infrastructure.js', '--stage', 'dev', '--force'],
+        expect.objectContaining({
+          cwd: expect.any(String),
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should spawn serverless without --force flag when force option is false', async () => {
+      await deployCommand({ stage: 'dev', force: false });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        ['deploy', '--config', 'infrastructure.js', '--stage', 'dev'],
+        expect.objectContaining({
+          cwd: expect.any(String),
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should spawn serverless without --force flag when force option is undefined', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        ['deploy', '--config', 'infrastructure.js', '--stage', 'dev'],
+        expect.objectContaining({
+          cwd: expect.any(String),
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should use process.cwd() as working directory', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.cwd).toBe(process.cwd());
+    });
+
+    it('should use stdio inherit for output streaming', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.stdio).toBe('inherit');
+    });
+
+    it('should set SLS_STAGE environment variable to match stage option', async () => {
+      await deployCommand({ stage: 'qa' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      // Verify SLS_STAGE is set for discovery to use
+      expect(options.env.SLS_STAGE).toBe('qa');
+    });
+
+    it('should set SLS_STAGE for production stage', async () => {
+      await deployCommand({ stage: 'production' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.SLS_STAGE).toBe('production');
+    });
+
+    it('should set SLS_STAGE for dev stage', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.SLS_STAGE).toBe('dev');
+    });
+
+    it('should use infrastructure.js as config file', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        expect.arrayContaining(['--config', 'infrastructure.js']),
+        expect.any(Object)
+      );
+    });
+
+    it('should log deployment start messages', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('Deploying the serverless application...');
+      expect(consoleLogSpy).toHaveBeenCalledWith('🚀 Deploying serverless application...');
+    });
+
+    it('should include essential system environment variables', async () => {
+      process.env.PATH = '/usr/bin';
+      process.env.HOME = '/home/user';
+      process.env.USER = 'testuser';
+
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.PATH).toBe('/usr/bin');
+      expect(options.env.HOME).toBe('/home/user');
+      expect(options.env.USER).toBe('testuser');
+    });
+
+    it('should include AWS environment variables', async () => {
+      process.env.AWS_REGION = 'us-east-1';
+      process.env.AWS_PROFILE = 'test-profile';
+      process.env.AWS_ACCESS_KEY_ID = 'test-key';
+
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.AWS_REGION).toBe('us-east-1');
+      expect(options.env.AWS_PROFILE).toBe('test-profile');
+      expect(options.env.AWS_ACCESS_KEY_ID).toBe('test-key');
+
+      delete process.env.AWS_REGION;
+      delete process.env.AWS_PROFILE;
+      delete process.env.AWS_ACCESS_KEY_ID;
+    });
+
+    it('should register error handler', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(mockChildProcess.on).toHaveBeenCalledWith('error', expect.any(Function));
+    });
+
+    it('should register close handler', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(mockChildProcess.on).toHaveBeenCalledWith('close', expect.any(Function));
+    });
+  });
+
+  describe('Environment Variable Filtering', () => {
+    it('should filter environment variables when app definition exists', async () => {
+      // Mock app definition with environment config
+      fs.existsSync.mockReturnValue(true);
+      jest.mock(
+        process.cwd() + '/index.js',
+        () => ({
+          Definition: {
+            environment: {
+              DATABASE_URL: true,
+              API_KEY: true
+            }
+          }
+        }),
+        { virtual: true }
+      );
+
+      process.env.DATABASE_URL = 'postgres://localhost';
+      process.env.API_KEY = 'test-key';
+      process.env.RANDOM_VAR = 'should-not-be-included';
+
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      // Should include app-defined variables
+      expect(options.env.DATABASE_URL).toBe('postgres://localhost');
+      expect(options.env.API_KEY).toBe('test-key');
+
+      // Should NOT include non-app-defined variables (except system/AWS)
+      expect(options.env.RANDOM_VAR).toBeUndefined();
+
+      delete process.env.DATABASE_URL;
+      delete process.env.API_KEY;
+      delete process.env.RANDOM_VAR;
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should log error when spawn fails', async () => {
+      const testError = new Error('Spawn failed');
+
+      await deployCommand({ stage: 'dev' });
+
+      // Simulate error event
+      const errorHandler = mockChildProcess.on.mock.calls.find(
+        call => call[0] === 'error'
+      )[1];
+      errorHandler(testError);
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Error executing command: Spawn failed');
+    });
+
+    it('should log when child process exits with non-zero code', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      // Simulate close event with error code
+      const closeHandler = mockChildProcess.on.mock.calls.find(
+        call => call[0] === 'close'
+      )[1];
+      closeHandler(1);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('Child process exited with code 1');
+    });
+
+    it('should NOT log when child process exits with zero code', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      // Simulate close event with success code
+      const closeHandler = mockChildProcess.on.mock.calls.find(
+        call => call[0] === 'close'
+      )[1];
+      closeHandler(0);
+
+      // Should not log exit message for success
+      expect(consoleLogSpy).not.toHaveBeenCalledWith('Child process exited with code 0');
+    });
+  });
+});

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

@@ -0,0 +1,309 @@
+/**
+ * Unit tests for frigg doctor command
+ * Tests stack listing, selection, and health check orchestration
+ */
+
+const { describe, test, expect, jest, beforeEach } = require('@jest/globals');
+
+describe('Doctor Command - Stack Listing and Selection', () => {
+    let mockCloudFormationClient;
+    let mockSelect;
+    let listStacks;
+    let promptForStackSelection;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        // Mock AWS SDK CloudFormation client
+        mockCloudFormationClient = {
+            send: jest.fn(),
+        };
+
+        // Mock @inquirer/prompts select function
+        mockSelect = jest.fn();
+    });
+
+    describe('listStacks', () => {
+        test('should return array of stacks with name, status, and timestamps', async () => {
+            // Arrange
+            const mockResponse = {
+                StackSummaries: [
+                    {
+                        StackName: 'quo-frigg-production',
+                        StackStatus: 'UPDATE_COMPLETE',
+                        CreationTime: new Date('2024-01-15'),
+                        LastUpdatedTime: new Date('2024-10-20'),
+                    },
+                    {
+                        StackName: 'test-app-dev',
+                        StackStatus: 'CREATE_COMPLETE',
+                        CreationTime: new Date('2024-10-01'),
+                        LastUpdatedTime: null,
+                    },
+                ],
+            };
+
+            mockCloudFormationClient.send.mockResolvedValue(mockResponse);
+
+            // Act
+            const { CloudFormationClient, ListStacksCommand } = require('@aws-sdk/client-cloudformation');
+            const client = new CloudFormationClient({ region: 'us-east-1' });
+            const command = new ListStacksCommand({
+                StackStatusFilter: ['CREATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_COMPLETE', 'ROLLBACK_COMPLETE'],
+            });
+            const response = await mockCloudFormationClient.send(command);
+            const stacks = response.StackSummaries.map(stack => ({
+                name: stack.StackName,
+                status: stack.StackStatus,
+                createdTime: stack.CreationTime,
+                updatedTime: stack.LastUpdatedTime,
+            }));
+
+            // Assert
+            expect(stacks).toHaveLength(2);
+            expect(stacks[0]).toEqual({
+                name: 'quo-frigg-production',
+                status: 'UPDATE_COMPLETE',
+                createdTime: new Date('2024-01-15'),
+                updatedTime: new Date('2024-10-20'),
+            });
+            expect(stacks[1]).toEqual({
+                name: 'test-app-dev',
+                status: 'CREATE_COMPLETE',
+                createdTime: new Date('2024-10-01'),
+                updatedTime: null,
+            });
+        });
+
+        test('should filter stacks by completed statuses only', async () => {
+            // Arrange - command should request only completed stacks
+            const expectedFilter = [
+                'CREATE_COMPLETE',
+                'UPDATE_COMPLETE',
+                'UPDATE_ROLLBACK_COMPLETE',
+                'ROLLBACK_COMPLETE',
+            ];
+
+            // Act
+            const { ListStacksCommand } = require('@aws-sdk/client-cloudformation');
+            const command = new ListStacksCommand({
+                StackStatusFilter: expectedFilter,
+            });
+
+            // Assert
+            expect(command.input.StackStatusFilter).toEqual(expectedFilter);
+        });
+
+        test('should handle empty stack list', async () => {
+            // Arrange
+            const mockResponse = {
+                StackSummaries: [],
+            };
+
+            mockCloudFormationClient.send.mockResolvedValue(mockResponse);
+
+            // Act
+            const response = await mockCloudFormationClient.send();
+            const stacks = (response.StackSummaries || []).map(stack => ({
+                name: stack.StackName,
+                status: stack.StackStatus,
+                createdTime: stack.CreationTime,
+                updatedTime: stack.LastUpdatedTime,
+            }));
+
+            // Assert
+            expect(stacks).toEqual([]);
+        });
+
+        test('should throw error with helpful message when API call fails', async () => {
+            // Arrange
+            const apiError = new Error('AccessDenied: User is not authorized');
+            mockCloudFormationClient.send.mockRejectedValue(apiError);
+
+            // Act & Assert
+            await expect(async () => {
+                try {
+                    await mockCloudFormationClient.send();
+                } catch (error) {
+                    throw new Error(`Failed to list CloudFormation stacks: ${error.message}`);
+                }
+            }).rejects.toThrow('Failed to list CloudFormation stacks: AccessDenied: User is not authorized');
+        });
+    });
+
+    describe('promptForStackSelection', () => {
+        test('should display stacks with status icons and metadata', async () => {
+            // Arrange
+            const mockStacks = [
+                {
+                    name: 'production-stack',
+                    status: 'UPDATE_COMPLETE',
+                    createdTime: new Date('2024-01-15'),
+                    updatedTime: new Date('2024-10-20'),
+                },
+                {
+                    name: 'dev-stack',
+                    status: 'CREATE_COMPLETE',
+                    createdTime: new Date('2024-10-01'),
+                    updatedTime: null,
+                },
+            ];
+
+            const expectedChoices = [
+                {
+                    name: '✓ production-stack (UPDATE_COMPLETE) - Updated: 10/20/2024',
+                    value: 'production-stack',
+                    description: 'Status: UPDATE_COMPLETE',
+                },
+                {
+                    name: '✓ dev-stack (CREATE_COMPLETE) - Created: 10/1/2024',
+                    value: 'dev-stack',
+                    description: 'Status: CREATE_COMPLETE',
+                },
+            ];
+
+            mockSelect.mockResolvedValue('production-stack');
+
+            // Act
+            const choices = mockStacks.map(stack => {
+                const statusIcon = stack.status.includes('COMPLETE') ? '✓' : '⚠';
+                const timeInfo = stack.updatedTime
+                    ? `Updated: ${stack.updatedTime.toLocaleDateString()}`
+                    : `Created: ${stack.createdTime.toLocaleDateString()}`;
+
+                return {
+                    name: `${statusIcon} ${stack.name} (${stack.status}) - ${timeInfo}`,
+                    value: stack.name,
+                    description: `Status: ${stack.status}`,
+                };
+            });
+
+            const selectedStack = await mockSelect({
+                message: 'Select a stack to run health check:',
+                choices,
+                pageSize: 15,
+            });
+
+            // Assert
+            expect(choices).toEqual(expectedChoices);
+            expect(selectedStack).toBe('production-stack');
+            expect(mockSelect).toHaveBeenCalledWith({
+                message: 'Select a stack to run health check:',
+                choices: expectedChoices,
+                pageSize: 15,
+            });
+        });
+
+        test('should exit with error when no stacks are found', async () => {
+            // Arrange
+            const mockStacks = [];
+            const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+            const mockConsoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+            const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+            // Act
+            if (mockStacks.length === 0) {
+                console.error('\n✗ No CloudFormation stacks found in us-east-1');
+                console.log('  Make sure you have stacks deployed and the correct AWS credentials configured.');
+                process.exit(1);
+            }
+
+            // Assert
+            expect(mockConsoleError).toHaveBeenCalledWith('\n✗ No CloudFormation stacks found in us-east-1');
+            expect(mockConsoleLog).toHaveBeenCalledWith('  Make sure you have stacks deployed and the correct AWS credentials configured.');
+            expect(mockExit).toHaveBeenCalledWith(1);
+
+            mockExit.mockRestore();
+            mockConsoleError.mockRestore();
+            mockConsoleLog.mockRestore();
+        });
+
+        test('should return selected stack name', async () => {
+            // Arrange
+            const mockStacks = [
+                { name: 'stack-a', status: 'UPDATE_COMPLETE', createdTime: new Date(), updatedTime: new Date() },
+                { name: 'stack-b', status: 'CREATE_COMPLETE', createdTime: new Date(), updatedTime: null },
+            ];
+
+            mockSelect.mockResolvedValue('stack-b');
+
+            // Act
+            const choices = mockStacks.map(stack => ({
+                name: `${stack.name} (${stack.status})`,
+                value: stack.name,
+                description: `Status: ${stack.status}`,
+            }));
+
+            const selectedStack = await mockSelect({
+                message: 'Select a stack to run health check:',
+                choices,
+                pageSize: 15,
+            });
+
+            // Assert
+            expect(selectedStack).toBe('stack-b');
+        });
+
+        test('should handle user cancellation (Ctrl+C)', async () => {
+            // Arrange
+            mockSelect.mockRejectedValue(new Error('User cancelled'));
+
+            // Act & Assert
+            await expect(mockSelect({ message: 'Select a stack:', choices: [] }))
+                .rejects.toThrow('User cancelled');
+        });
+    });
+
+    describe('doctorCommand integration with stack selection', () => {
+        test('should prompt for stack selection when stackName is not provided', async () => {
+            // Arrange
+            const mockPromptForStackSelection = jest.fn().mockResolvedValue('selected-stack');
+            const stackName = undefined;
+            const region = 'us-east-1';
+
+            // Act
+            let selectedStack = stackName;
+            if (!selectedStack) {
+                selectedStack = await mockPromptForStackSelection(region);
+            }
+
+            // Assert
+            expect(mockPromptForStackSelection).toHaveBeenCalledWith('us-east-1');
+            expect(selectedStack).toBe('selected-stack');
+        });
+
+        test('should use provided stackName when given', async () => {
+            // Arrange
+            const mockPromptForStackSelection = jest.fn();
+            const stackName = 'my-production-stack';
+            const region = 'us-east-1';
+
+            // Act
+            let selectedStack = stackName;
+            if (!selectedStack) {
+                selectedStack = await mockPromptForStackSelection(region);
+            }
+
+            // Assert
+            expect(mockPromptForStackSelection).not.toHaveBeenCalled();
+            expect(selectedStack).toBe('my-production-stack');
+        });
+
+        test('should use region from options or default to us-east-1', () => {
+            // Test with region provided
+            const options1 = { region: 'eu-west-1' };
+            const region1 = options1.region || process.env.AWS_REGION || 'us-east-1';
+            expect(region1).toBe('eu-west-1');
+
+            // Test with no region (and no env var)
+            const oldEnv = process.env.AWS_REGION;
+            delete process.env.AWS_REGION;
+            const options2 = {};
+            const region2 = options2.region || process.env.AWS_REGION || 'us-east-1';
+            expect(region2).toBe('us-east-1');
+
+            // Restore
+            if (oldEnv) process.env.AWS_REGION = oldEnv;
+        });
+    });
+});