@friggframework/devtools 2.0.0--canary.398.dd443c7.0 → 2.0.0--canary.402.d2f4ae6.0

package/frigg-cli/__tests__/utils/test-setup.js

@@ -0,0 +1,286 @@
+/**
+ * Global test setup for Frigg CLI tests
+ * This file is executed before each test file
+ */
+
+// Store original environment
+const originalEnv = process.env;
+const originalConsole = { ...console };
+const originalProcess = { ...process };
+
+// Mock console to prevent noisy output during tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn()
+};
+
+// Set up test environment variables
+process.env = {
+  ...originalEnv,
+  NODE_ENV: 'test',
+  HOME: '/mock/home',
+  PATH: '/mock/path',
+  CI: 'true'
+};
+
+// Global setup before each test
+beforeEach(() => {
+  // Clear all mocks
+  jest.clearAllMocks();
+  
+  // Reset timers
+  jest.clearAllTimers();
+  
+  // Reset modules
+  jest.resetModules();
+  
+  // Restore original process methods
+  process.exit = originalProcess.exit;
+  process.cwd = originalProcess.cwd;
+  
+  // Mock process.exit to prevent actual exit
+  process.exit = jest.fn();
+  
+  // Mock process.cwd to return predictable path
+  process.cwd = jest.fn().mockReturnValue('/mock/cwd');
+  
+  // Reset console mocks
+  global.console.log.mockClear();
+  global.console.info.mockClear();
+  global.console.warn.mockClear();
+  global.console.error.mockClear();
+  global.console.debug.mockClear();
+});
+
+// Global cleanup after each test
+afterEach(() => {
+  // Restore environment
+  process.env = { ...originalEnv };
+  
+  // Restore process methods
+  process.exit = originalProcess.exit;
+  process.cwd = originalProcess.cwd;
+  
+  // Clear any remaining timers
+  jest.clearAllTimers();
+  
+  // Unmock all modules
+  jest.restoreAllMocks();
+});
+
+// Global teardown after all tests
+afterAll(() => {
+  // Restore original environment completely
+  process.env = originalEnv;
+  
+  // Restore original console
+  global.console = originalConsole;
+  
+  // Restore original process
+  Object.assign(process, originalProcess);
+});
+
+// Custom matchers for CLI testing
+expect.extend({
+  toBeValidExitCode(received) {
+    const validCodes = [0, 1, 2];
+    const pass = validCodes.includes(received);
+    
+    if (pass) {
+      return {
+        message: () => `expected ${received} not to be a valid exit code`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected ${received} to be a valid exit code (0, 1, or 2)`,
+        pass: false
+      };
+    }
+  },
+  
+  toHaveLoggedError(received, expected) {
+    const errorLogs = global.console.error.mock.calls;
+    const pass = errorLogs.some(call => 
+      call.some(arg => 
+        typeof arg === 'string' && arg.includes(expected)
+      )
+    );
+    
+    if (pass) {
+      return {
+        message: () => `expected not to have logged error containing "${expected}"`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected to have logged error containing "${expected}"`,
+        pass: false
+      };
+    }
+  },
+  
+  toHaveLoggedInfo(received, expected) {
+    const infoLogs = global.console.info.mock.calls;
+    const pass = infoLogs.some(call => 
+      call.some(arg => 
+        typeof arg === 'string' && arg.includes(expected)
+      )
+    );
+    
+    if (pass) {
+      return {
+        message: () => `expected not to have logged info containing "${expected}"`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected to have logged info containing "${expected}"`,
+        pass: false
+      };
+    }
+  },
+  
+  toBeWithinTimeLimit(received, limit) {
+    const pass = received <= limit;
+    
+    if (pass) {
+      return {
+        message: () => `expected ${received}ms not to be within ${limit}ms`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected ${received}ms to be within ${limit}ms`,
+        pass: false
+      };
+    }
+  }
+});
+
+// Helper functions available in all tests
+global.TestHelpers = {
+  /**
+   * Create a temporary directory for tests
+   */
+  createTempDir() {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'frigg-cli-test-'));
+  },
+  
+  /**
+   * Clean up temporary directory
+   */
+  cleanupTempDir(dirPath) {
+    const fs = require('fs');
+    
+    if (fs.existsSync(dirPath)) {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+  },
+  
+  /**
+   * Create a mock package.json file
+   */
+  createMockPackageJson(overrides = {}) {
+    return JSON.stringify({
+      name: 'test-package',
+      version: '1.0.0',
+      main: 'index.js',
+      scripts: {
+        test: 'jest',
+        start: 'node index.js'
+      },
+      dependencies: {},
+      devDependencies: {},
+      ...overrides
+    }, null, 2);
+  },
+  
+  /**
+   * Create a mock frigg.config.json file
+   */
+  createMockFriggConfig(overrides = {}) {
+    return JSON.stringify({
+      stage: 'dev',
+      region: 'us-east-1',
+      profile: 'default',
+      backend: {
+        runtime: 'nodejs18.x',
+        timeout: 30,
+        memory: 128
+      },
+      ...overrides
+    }, null, 2);
+  },
+  
+  /**
+   * Wait for a specific amount of time
+   */
+  async delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  },
+  
+  /**
+   * Generate a random string for test data
+   */
+  randomString(length = 10) {
+    return Math.random().toString(36).substring(2, length + 2);
+  },
+  
+  /**
+   * Simulate file system structure
+   */
+  mockFileSystem(structure) {
+    const fs = require('fs');
+    
+    const originalExistsSync = fs.existsSync;
+    const originalReadFileSync = fs.readFileSync;
+    const originalWriteFileSync = fs.writeFileSync;
+    
+    fs.existsSync = jest.fn((path) => {
+      return structure.hasOwnProperty(path);
+    });
+    
+    fs.readFileSync = jest.fn((path) => {
+      if (structure.hasOwnProperty(path)) {
+        return structure[path];
+      }
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    });
+    
+    fs.writeFileSync = jest.fn((path, data) => {
+      structure[path] = data;
+    });
+    
+    return {
+      restore() {
+        fs.existsSync = originalExistsSync;
+        fs.readFileSync = originalReadFileSync;
+        fs.writeFileSync = originalWriteFileSync;
+      }
+    };
+  }
+};
+
+// Global timeout for all tests
+jest.setTimeout(30000);
+
+// Suppress specific warnings during tests
+const originalWarn = console.warn;
+console.warn = (...args) => {
+  // Suppress specific warnings that are expected during testing
+  const message = args.join(' ');
+  if (message.includes('ExperimentalWarning') || 
+      message.includes('DeprecationWarning')) {
+    return;
+  }
+  originalWarn.apply(console, args);
+};

package/frigg-cli/generate-command/__tests__/generate-command.test.js

@@ -0,0 +1,312 @@
+const path = require('path');
+const fs = require('fs');
+const generateCommand = require('../index');
+
+// Mock dependencies
+jest.mock('fs');
+jest.mock('@friggframework/core');
+jest.mock('@inquirer/prompts');
+jest.mock('../../../infrastructure/iam-generator');
+jest.mock('../terraform-generator');
+jest.mock('../azure-generator');
+jest.mock('../gcp-generator');
+
+describe('Generate Command', () => {
+    const mockBackendDir = '/mock/backend';
+    const mockPackageJsonPath = path.join(mockBackendDir, 'package.json');
+    const mockAppDefinitionPath = path.join(mockBackendDir, 'index.js');
+    
+    beforeEach(() => {
+        jest.clearAllMocks();
+        
+        // Mock process.exit
+        jest.spyOn(process, 'exit').mockImplementation(() => {});
+        
+        // Mock console methods
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+        jest.spyOn(console, 'error').mockImplementation(() => {});
+        
+        // Mock findNearestBackendPackageJson
+        const { findNearestBackendPackageJson } = require('@friggframework/core');
+        findNearestBackendPackageJson.mockResolvedValue(mockPackageJsonPath);
+        
+        // Mock fs operations
+        fs.readFileSync.mockImplementation((filePath) => {
+            if (filePath === mockPackageJsonPath) {
+                return JSON.stringify({ name: 'test-app' });
+            }
+            return '';
+        });
+        
+        fs.existsSync.mockImplementation((filePath) => {
+            if (filePath === mockAppDefinitionPath) {
+                return true;
+            }
+            if (filePath.includes('backend/infrastructure')) {
+                return false; // Directory doesn't exist, will be created
+            }
+            return true;
+        });
+        
+        fs.mkdirSync.mockImplementation(() => {});
+        fs.writeFileSync.mockImplementation(() => {});
+        
+        // Mock app definition
+        jest.doMock(mockAppDefinitionPath, () => ({
+            vpc: { enable: true },
+            encryption: { useDefaultKMSForFieldLevelEncryption: true },
+            ssm: { enable: true },
+            websockets: { enable: false }
+        }), { virtual: true });
+    });
+    
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    
+    describe('AWS CloudFormation Generation', () => {
+        it('should generate CloudFormation template with explicit options', async () => {
+            const { generateCloudFormationTemplate } = require('../../../infrastructure/iam-generator');
+            generateCloudFormationTemplate.mockResolvedValue('AWSTemplateFormatVersion: 2010-09-09\nDescription: Test template');
+            
+            await generateCommand({
+                provider: 'aws',
+                format: 'cloudformation',
+                output: 'backend/infrastructure',
+                user: 'test-user',
+                stackName: 'test-stack'
+            });
+            
+            expect(generateCloudFormationTemplate).toHaveBeenCalledWith({
+                appName: 'test-app',
+                features: {
+                    vpc: true,
+                    kms: true,
+                    ssm: true,
+                    websockets: false
+                },
+                userPrefix: 'test-user',
+                stackName: 'test-stack'
+            });
+            
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                expect.stringContaining('frigg-deployment-aws-cloudformation.yaml'),
+                expect.stringContaining('AWSTemplateFormatVersion')
+            );
+            
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('✅ Generated cloudformation template for aws'));
+        });
+        
+        it('should handle missing app definition gracefully', async () => {
+            fs.existsSync.mockImplementation((filePath) => {
+                if (filePath === mockAppDefinitionPath) {
+                    return false;
+                }
+                return true;
+            });
+            
+            await generateCommand({
+                provider: 'aws',
+                format: 'cloudformation'
+            });
+            
+            expect(console.error).toHaveBeenCalledWith(
+                'Error generating deployment credentials:',
+                expect.stringContaining('App definition not found')
+            );
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+    });
+    
+    describe('AWS Terraform Generation', () => {
+        it('should generate Terraform template for AWS', async () => {
+            const { generateTerraformTemplate } = require('../terraform-generator');
+            generateTerraformTemplate.mockResolvedValue('provider "aws" {\n  region = var.region\n}');
+            
+            await generateCommand({
+                provider: 'aws',
+                format: 'terraform',
+                output: 'backend/infrastructure'
+            });
+            
+            expect(generateTerraformTemplate).toHaveBeenCalledWith({
+                appName: 'test-app',
+                features: {
+                    vpc: true,
+                    kms: true,
+                    ssm: true,
+                    websockets: false
+                },
+                userPrefix: 'frigg-deployment-user'
+            });
+            
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                expect.stringContaining('frigg-deployment-aws-terraform.tf'),
+                expect.stringContaining('provider "aws"')
+            );
+        });
+    });
+    
+    describe('Azure Generators', () => {
+        it('should generate ARM template for Azure', async () => {
+            const { generateAzureARMTemplate } = require('../azure-generator');
+            generateAzureARMTemplate.mockResolvedValue(JSON.stringify({
+                "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+                "contentVersion": "1.0.0.0"
+            }));
+            
+            await generateCommand({
+                provider: 'azure',
+                format: 'arm',
+                output: 'backend/infrastructure'
+            });
+            
+            expect(generateAzureARMTemplate).toHaveBeenCalledWith({
+                appName: 'test-app',
+                features: expect.any(Object),
+                userPrefix: 'frigg-deployment-user'
+            });
+            
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                expect.stringContaining('frigg-deployment-azure-arm.json'),
+                expect.stringContaining('$schema')
+            );
+        });
+        
+        it('should generate Terraform template for Azure', async () => {
+            const { generateAzureTerraformTemplate } = require('../azure-generator');
+            generateAzureTerraformTemplate.mockResolvedValue('provider "azurerm" {\n  features {}\n}');
+            
+            await generateCommand({
+                provider: 'azure',
+                format: 'terraform'
+            });
+            
+            expect(generateAzureTerraformTemplate).toHaveBeenCalled();
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                expect.stringContaining('frigg-deployment-azure-terraform.tf'),
+                expect.stringContaining('provider "azurerm"')
+            );
+        });
+    });
+    
+    describe('GCP Generators', () => {
+        it('should generate Deployment Manager template for GCP', async () => {
+            const { generateGCPDeploymentManagerTemplate } = require('../gcp-generator');
+            generateGCPDeploymentManagerTemplate.mockResolvedValue('resources:\n- name: test-resource\n  type: compute.v1.instance');
+            
+            await generateCommand({
+                provider: 'gcp',
+                format: 'deployment-manager'
+            });
+            
+            expect(generateGCPDeploymentManagerTemplate).toHaveBeenCalled();
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                expect.stringContaining('frigg-deployment-gcp-deployment-manager.yaml'),
+                expect.stringContaining('resources:')
+            );
+        });
+        
+        it('should generate Terraform template for GCP', async () => {
+            const { generateGCPTerraformTemplate } = require('../gcp-generator');
+            generateGCPTerraformTemplate.mockResolvedValue('provider "google" {\n  project = var.project_id\n}');
+            
+            await generateCommand({
+                provider: 'gcp',
+                format: 'terraform'
+            });
+            
+            expect(generateGCPTerraformTemplate).toHaveBeenCalled();
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                expect.stringContaining('frigg-deployment-gcp-terraform.tf'),
+                expect.stringContaining('provider "google"')
+            );
+        });
+    });
+    
+    describe('Interactive Mode', () => {
+        it('should prompt for provider and format when not provided', async () => {
+            const { select } = require('@inquirer/prompts');
+            select.mockResolvedValueOnce('aws').mockResolvedValueOnce('cloudformation');
+            
+            const { generateCloudFormationTemplate } = require('../../../infrastructure/iam-generator');
+            generateCloudFormationTemplate.mockResolvedValue('AWSTemplateFormatVersion: 2010-09-09');
+            
+            await generateCommand({});
+            
+            expect(select).toHaveBeenCalledTimes(2);
+            expect(select).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                message: 'Select cloud provider:',
+                choices: expect.arrayContaining([
+                    expect.objectContaining({ name: 'AWS', value: 'aws' }),
+                    expect.objectContaining({ name: 'Azure', value: 'azure' }),
+                    expect.objectContaining({ name: 'Google Cloud Platform', value: 'gcp' })
+                ])
+            }));
+            
+            expect(select).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                message: 'Select output format:',
+                choices: expect.arrayContaining([
+                    expect.objectContaining({ name: 'CloudFormation', value: 'cloudformation' })
+                ])
+            }));
+        });
+        
+        it('should handle user cancellation gracefully', async () => {
+            const { select } = require('@inquirer/prompts');
+            const exitError = new Error('User cancelled');
+            exitError.name = 'ExitPromptError';
+            select.mockRejectedValue(exitError);
+            
+            await generateCommand({});
+            
+            expect(console.log).toHaveBeenCalledWith('\n✖ Command cancelled by user');
+            expect(process.exit).toHaveBeenCalledWith(0);
+        });
+    });
+    
+    describe('Error Handling', () => {
+        it('should handle missing Frigg application', async () => {
+            const { findNearestBackendPackageJson } = require('@friggframework/core');
+            findNearestBackendPackageJson.mockResolvedValue(null);
+            
+            await generateCommand({
+                provider: 'aws',
+                format: 'cloudformation'
+            });
+            
+            expect(console.error).toHaveBeenCalledWith(
+                'Error generating deployment credentials:',
+                'Could not find a Frigg application. Make sure you are in a Frigg project directory.'
+            );
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        
+        it('should show stack trace in verbose mode', async () => {
+            const { findNearestBackendPackageJson } = require('@friggframework/core');
+            const error = new Error('Test error');
+            error.stack = 'Error: Test error\n    at testFunction';
+            findNearestBackendPackageJson.mockRejectedValue(error);
+            
+            await generateCommand({
+                provider: 'aws',
+                format: 'cloudformation',
+                verbose: true
+            });
+            
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('at testFunction'));
+        });
+        
+        it('should handle unsupported formats', async () => {
+            await generateCommand({
+                provider: 'aws',
+                format: 'pulumi'
+            });
+            
+            expect(console.error).toHaveBeenCalledWith(
+                'Error generating deployment credentials:',
+                'Pulumi support is not yet implemented'
+            );
+        });
+    });
+});

package/frigg-cli/generate-command/azure-generator.js

@@ -0,0 +1,43 @@
+async function generateAzureARMTemplate(options) {
+    const { appName, features, userPrefix } = options;
+    
+    // Placeholder for Azure ARM template generation
+    const template = {
+        "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+        "contentVersion": "1.0.0.0",
+        "metadata": {
+            "description": "Frigg deployment credentials for Azure - Coming Soon",
+            "author": "Frigg CLI"
+        },
+        "parameters": {},
+        "variables": {},
+        "resources": [],
+        "outputs": {
+            "message": {
+                "type": "string",
+                "value": "Azure ARM template generation is coming soon. Please use Terraform for now."
+            }
+        }
+    };
+
+    return JSON.stringify(template, null, 2);
+}
+
+async function generateAzureTerraformTemplate(options) {
+    // Placeholder for Azure Terraform template
+    return `# Frigg Deployment Configuration for Azure
+# Coming Soon
+
+# Azure support with Terraform is under development.
+# Please check back in a future release.
+
+output "message" {
+  value = "Azure Terraform support is coming soon"
+}
+`;
+}
+
+module.exports = {
+    generateAzureARMTemplate,
+    generateAzureTerraformTemplate
+};

package/frigg-cli/generate-command/gcp-generator.js

@@ -0,0 +1,47 @@
+async function generateGCPDeploymentManagerTemplate(options) {
+    const { appName, features, userPrefix } = options;
+    
+    // Placeholder for GCP Deployment Manager template
+    const template = `# Frigg Deployment Configuration for Google Cloud Platform
+# Coming Soon
+
+# GCP Deployment Manager support is under development.
+# Please use Terraform for GCP deployments in the meantime.
+
+resources: []
+
+outputs:
+- name: message
+  value: "GCP Deployment Manager support is coming soon"
+`;
+
+    return template;
+}
+
+async function generateGCPTerraformTemplate(options) {
+    // Placeholder for GCP Terraform template
+    return `# Frigg Deployment Configuration for Google Cloud Platform
+# Coming Soon
+
+terraform {
+  required_providers {
+    google = {
+      source  = "hashicorp/google"
+      version = "~> 5.0"
+    }
+  }
+}
+
+# GCP support with Terraform is under development.
+# Please check back in a future release.
+
+output "message" {
+  value = "GCP Terraform support is coming soon"
+}
+`;
+}
+
+module.exports = {
+    generateGCPDeploymentManagerTemplate,
+    generateGCPTerraformTemplate
+};