@friggframework/devtools 2.0.0-next.61 → 2.0.0-next.62

package/infrastructure/__tests__/fixtures/mock-aws-resources.js

@@ -1,391 +0,0 @@
-/**
- * Mock AWS resources for consistent testing across all VPC/KMS/SSM tests
- */
-
-const mockVpc = {
-    VpcId: 'vpc-12345678',
-    IsDefault: true,
-    State: 'available',
-    CidrBlock: '10.0.0.0/16',
-    DhcpOptionsId: 'dopt-12345678',
-    InstanceTenancy: 'default'
-};
-
-const mockSubnets = [
-    {
-        SubnetId: 'subnet-private-1',
-        VpcId: 'vpc-12345678',
-        CidrBlock: '10.0.1.0/24',
-        AvailabilityZone: 'us-east-1a',
-        State: 'available',
-        MapPublicIpOnLaunch: false
-    },
-    {
-        SubnetId: 'subnet-private-2',
-        VpcId: 'vpc-12345678',
-        CidrBlock: '10.0.2.0/24',
-        AvailabilityZone: 'us-east-1b',
-        State: 'available',
-        MapPublicIpOnLaunch: false
-    },
-    {
-        SubnetId: 'subnet-public-1',
-        VpcId: 'vpc-12345678',
-        CidrBlock: '10.0.3.0/24',
-        AvailabilityZone: 'us-east-1a',
-        State: 'available',
-        MapPublicIpOnLaunch: true
-    }
-];
-
-const mockSecurityGroups = [
-    {
-        GroupId: 'sg-frigg-12345678',
-        GroupName: 'frigg-lambda-sg',
-        Description: 'Security group for Frigg Lambda functions',
-        VpcId: 'vpc-12345678'
-    },
-    {
-        GroupId: 'sg-default-12345678',
-        GroupName: 'default',
-        Description: 'Default security group',
-        VpcId: 'vpc-12345678'
-    }
-];
-
-const mockRouteTables = [
-    {
-        RouteTableId: 'rtb-private-12345678',
-        VpcId: 'vpc-12345678',
-        Routes: [
-            {
-                DestinationCidrBlock: '10.0.0.0/16',
-                GatewayId: 'local',
-                State: 'active'
-            },
-            {
-                DestinationCidrBlock: '0.0.0.0/0',
-                NatGatewayId: 'nat-12345678',
-                State: 'active'
-            }
-        ],
-        Associations: [
-            {
-                RouteTableAssociationId: 'rtbassoc-12345678',
-                RouteTableId: 'rtb-private-12345678',
-                SubnetId: 'subnet-private-1'
-            }
-        ]
-    },
-    {
-        RouteTableId: 'rtb-public-12345678',
-        VpcId: 'vpc-12345678',
-        Routes: [
-            {
-                DestinationCidrBlock: '10.0.0.0/16',
-                GatewayId: 'local',
-                State: 'active'
-            },
-            {
-                DestinationCidrBlock: '0.0.0.0/0',
-                GatewayId: 'igw-12345678',
-                State: 'active'
-            }
-        ],
-        Associations: [
-            {
-                RouteTableAssociationId: 'rtbassoc-87654321',
-                RouteTableId: 'rtb-public-12345678',
-                SubnetId: 'subnet-public-1'
-            }
-        ]
-    }
-];
-
-const mockKmsKeys = [
-    {
-        KeyId: '12345678-1234-1234-1234-123456789012',
-        Arn: 'arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012'
-    },
-    {
-        KeyId: '87654321-8765-4321-8765-876543218765',
-        Arn: 'arn:aws:kms:us-east-1:123456789012:key/87654321-8765-4321-8765-876543218765'
-    }
-];
-
-const mockKmsKeyMetadata = {
-    KeyId: '12345678-1234-1234-1234-123456789012',
-    Arn: 'arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012',
-    CreationDate: new Date('2023-01-01'),
-    Enabled: true,
-    Description: 'Default KMS key for Frigg encryption',
-    KeyUsage: 'ENCRYPT_DECRYPT',
-    KeyState: 'Enabled',
-    Origin: 'AWS_KMS',
-    KeyManager: 'CUSTOMER',
-    CustomerMasterKeySpec: 'SYMMETRIC_DEFAULT'
-};
-
-const mockStsCallerIdentity = {
-    UserId: 'AIDACKCEVSQ6C2EXAMPLE',
-    Account: '123456789012',
-    Arn: 'arn:aws:iam::123456789012:user/test-user'
-};
-
-const mockDiscoveredResources = {
-    defaultVpcId: mockVpc.VpcId,
-    defaultSecurityGroupId: mockSecurityGroups[0].GroupId,
-    privateSubnetId1: mockSubnets[0].SubnetId,
-    privateSubnetId2: mockSubnets[1].SubnetId,
-    privateRouteTableId: mockRouteTables[0].RouteTableId,
-    defaultKmsKeyId: mockKmsKeyMetadata.Arn
-};
-
-// App definitions for testing different scenarios
-const mockAppDefinitions = {
-    vpcOnly: {
-        name: 'vpc-test-app',
-        vpc: { enable: true },
-        integrations: []
-    },
-    
-    kmsOnly: {
-        name: 'kms-test-app',
-        encryption: { fieldLevelEncryptionMethod: 'kms' },
-        integrations: []
-    },
-    
-    ssmOnly: {
-        name: 'ssm-test-app',
-        ssm: { enable: true },
-        integrations: []
-    },
-    
-    allFeatures: {
-        name: 'full-feature-app',
-        vpc: { enable: true },
-        encryption: { fieldLevelEncryptionMethod: 'kms' },
-        ssm: { enable: true },
-        integrations: [{
-            Definition: {
-                name: 'testIntegration'
-            }
-        }]
-    },
-    
-    noFeatures: {
-        name: 'minimal-app',
-        integrations: []
-    },
-    
-    multipleIntegrations: {
-        name: 'multi-integration-app',
-        vpc: { enable: true },
-        integrations: [
-            {
-                Definition: {
-                    name: 'hubspot'
-                }
-            },
-            {
-                Definition: {
-                    name: 'salesforce'
-                }
-            }
-        ]
-    }
-};
-
-// Mock serverless service configurations
-const mockServerlessServices = {
-    withVpc: {
-        provider: {
-            name: 'aws',
-            region: 'us-east-1',
-            vpc: '${self:custom.vpc.${self:provider.stage}}'
-        },
-        plugins: [],
-        custom: {
-            vpc: {
-                '${self:provider.stage}': {
-                    securityGroupIds: ['${env:AWS_DISCOVERY_SECURITY_GROUP_ID}'],
-                    subnetIds: [
-                        '${env:AWS_DISCOVERY_SUBNET_ID_1}',
-                        '${env:AWS_DISCOVERY_SUBNET_ID_2}'
-                    ]
-                }
-            }
-        },
-        functions: {}
-    },
-    
-    withKms: {
-        provider: {
-            name: 'aws',
-            region: 'us-east-1'
-        },
-        plugins: ['serverless-kms-grants'],
-        custom: {
-            kmsGrants: {
-                kmsKeyId: '${env:AWS_DISCOVERY_KMS_KEY_ID}'
-            }
-        },
-        functions: {}
-    },
-    
-    withSsm: {
-        provider: {
-            name: 'aws',
-            region: 'us-east-1',
-            layers: [
-                'arn:aws:lambda:us-east-1:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11'
-            ]
-        },
-        plugins: [],
-        custom: {},
-        functions: {}
-    },
-    
-    withAll: {
-        provider: {
-            name: 'aws',
-            region: 'us-east-1',
-            vpc: '${self:custom.vpc.${self:provider.stage}}',
-            layers: [
-                'arn:aws:lambda:us-east-1:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11'
-            ]
-        },
-        plugins: ['serverless-kms-grants'],
-        custom: {
-            vpc: {
-                '${self:provider.stage}': {
-                    securityGroupIds: ['${env:AWS_DISCOVERY_SECURITY_GROUP_ID}'],
-                    subnetIds: [
-                        '${env:AWS_DISCOVERY_SUBNET_ID_1}',
-                        '${env:AWS_DISCOVERY_SUBNET_ID_2}'
-                    ]
-                }
-            },
-            kmsGrants: {
-                kmsKeyId: '${env:AWS_DISCOVERY_KMS_KEY_ID}'
-            }
-        },
-        functions: {}
-    }
-};
-
-// Environment variables for testing
-const mockEnvironmentVariables = {
-    AWS_DISCOVERY_VPC_ID: mockVpc.VpcId,
-    AWS_DISCOVERY_SECURITY_GROUP_ID: mockSecurityGroups[0].GroupId,
-    AWS_DISCOVERY_SUBNET_ID_1: mockSubnets[0].SubnetId,
-    AWS_DISCOVERY_SUBNET_ID_2: mockSubnets[1].SubnetId,
-    AWS_DISCOVERY_ROUTE_TABLE_ID: mockRouteTables[0].RouteTableId,
-    AWS_DISCOVERY_KMS_KEY_ID:mockKmsKeyMetadata.Arn
-};
-
-// Fallback environment variables for error scenarios
-const mockFallbackEnvironmentVariables = {
-    AWS_DISCOVERY_VPC_ID: 'vpc-fallback',
-    AWS_DISCOVERY_SECURITY_GROUP_ID: 'sg-fallback',
-    AWS_DISCOVERY_SUBNET_ID_1: 'subnet-fallback-1',
-    AWS_DISCOVERY_SUBNET_ID_2: 'subnet-fallback-2',
-    AWS_DISCOVERY_ROUTE_TABLE_ID: 'rtb-fallback',
-    AWS_DISCOVERY_KMS_KEY_ID:'arn:aws:kms:*:*:key/*'
-};
-
-// Mock AWS SDK responses
-const mockAwsSdkResponses = {
-    ec2: {
-        describeVpcs: {
-            default: {
-                Vpcs: [mockVpc]
-            },
-            empty: {
-                Vpcs: []
-            },
-            multiple: {
-                Vpcs: [mockVpc, { ...mockVpc, VpcId: 'vpc-87654321', IsDefault: false }]
-            }
-        },
-        
-        describeSubnets: {
-            private: {
-                Subnets: mockSubnets.slice(0, 2) // Only private subnets
-            },
-            mixed: {
-                Subnets: mockSubnets // All subnets
-            },
-            empty: {
-                Subnets: []
-            }
-        },
-        
-        describeSecurityGroups: {
-            frigg: {
-                SecurityGroups: [mockSecurityGroups[0]]
-            },
-            default: {
-                SecurityGroups: [mockSecurityGroups[1]]
-            },
-            empty: {
-                SecurityGroups: []
-            }
-        },
-        
-        describeRouteTables: {
-            private: {
-                RouteTables: [mockRouteTables[0]]
-            },
-            public: {
-                RouteTables: [mockRouteTables[1]]
-            },
-            mixed: {
-                RouteTables: mockRouteTables
-            }
-        }
-    },
-    
-    kms: {
-        listKeys: {
-            withKeys: {
-                Keys: mockKmsKeys
-            },
-            empty: {
-                Keys: []
-            }
-        },
-        
-        describeKey: {
-            customer: {
-                KeyMetadata: mockKmsKeyMetadata
-            },
-            aws: {
-                KeyMetadata: {
-                    ...mockKmsKeyMetadata,
-                    KeyManager: 'AWS'
-                }
-            }
-        }
-    },
-    
-    sts: {
-        getCallerIdentity: mockStsCallerIdentity
-    }
-};
-
-module.exports = {
-    mockVpc,
-    mockSubnets,
-    mockSecurityGroups,
-    mockRouteTables,
-    mockKmsKeys,
-    mockKmsKeyMetadata,
-    mockStsCallerIdentity,
-    mockDiscoveredResources,
-    mockAppDefinitions,
-    mockServerlessServices,
-    mockEnvironmentVariables,
-    mockFallbackEnvironmentVariables,
-    mockAwsSdkResponses
-};

package/infrastructure/__tests__/helpers/test-utils.js

@@ -1,277 +0,0 @@
-/**
- * Test utilities for VPC/KMS/SSM testing
- */
-
-const { mockEnvironmentVariables, mockFallbackEnvironmentVariables } = require('../fixtures/mock-aws-resources');
-
-/**
- * Set up environment variables for testing
- * @param {Object} envVars - Environment variables to set
- */
-function setTestEnvironmentVariables(envVars = mockEnvironmentVariables) {
-    Object.keys(envVars).forEach(key => {
-        process.env[key] = envVars[key];
-    });
-}
-
-/**
- * Clean up environment variables after testing
- * @param {Object} envVars - Environment variables to clean up
- */
-function cleanupTestEnvironmentVariables(envVars = mockEnvironmentVariables) {
-    Object.keys(envVars).forEach(key => {
-        delete process.env[key];
-    });
-}
-
-/**
- * Set up fallback environment variables for error testing
- */
-function setFallbackEnvironmentVariables() {
-    setTestEnvironmentVariables(mockFallbackEnvironmentVariables);
-}
-
-/**
- * Create a mock AWS SDK client send function
- * @param {Array} responses - Array of responses to return in order
- * @returns {Function} Mock send function
- */
-function createMockSendFunction(responses) {
-    let callCount = 0;
-    return jest.fn().mockImplementation(() => {
-        const response = responses[callCount] || responses[responses.length - 1];
-        callCount++;
-        return Promise.resolve(response);
-    });
-}
-
-/**
- * Create a mock serverless object for plugin testing
- * @param {Object} serviceConfig - Serverless service configuration
- * @param {Array} commands - Commands in processedInput
- * @returns {Object} Mock serverless object
- */
-function createMockServerless(serviceConfig = {}, commands = []) {
-    return {
-        cli: {
-            log: jest.fn()
-        },
-        service: {
-            provider: {
-                name: 'aws',
-                region: 'us-east-1',
-                ...serviceConfig.provider
-            },
-            plugins: serviceConfig.plugins || [],
-            custom: serviceConfig.custom || {},
-            functions: serviceConfig.functions || {},
-            ...serviceConfig
-        },
-        processedInput: {
-            commands: commands
-        },
-        getProvider: jest.fn(() => ({})),
-        extendConfiguration: jest.fn()
-    };
-}
-
-/**
- * Verify that environment variables are set correctly
- * @param {Object} expectedVars - Expected environment variables
- */
-function verifyEnvironmentVariables(expectedVars) {
-    Object.keys(expectedVars).forEach(key => {
-        expect(process.env[key]).toBe(expectedVars[key]);
-    });
-}
-
-/**
- * Create a mock integration definition
- * @param {string} name - Integration name
- * @returns {Object} Mock integration
- */
-function createMockIntegration(name = 'testIntegration') {
-    return {
-        Definition: {
-            name: name
-        }
-    };
-}
-
-/**
- * Create a mock app definition with specified features
- * @param {Object} features - Features to enable (vpc, kms, ssm)
- * @param {Array} integrations - Integration definitions
- * @returns {Object} Mock app definition
- */
-function createMockAppDefinition(features = {}, integrations = []) {
-    const appDefinition = {
-        name: 'test-app',
-        integrations: integrations
-    };
-
-    if (features.vpc) {
-        appDefinition.vpc = { enable: true };
-    }
-
-    if (features.kms) {
-        appDefinition.encryption = { fieldLevelEncryptionMethod: 'kms' };
-    }
-
-    if (features.ssm) {
-        appDefinition.ssm = { enable: true };
-    }
-
-    return appDefinition;
-}
-
-/**
- * Verify serverless configuration contains expected VPC settings
- * @param {Object} config - Serverless configuration
- */
-function verifyVpcConfiguration(config) {
-    expect(config.provider.vpc).toBe('${self:custom.vpc.${self:provider.stage}}');
-    expect(config.custom.vpc).toEqual({
-        '${self:provider.stage}': {
-            securityGroupIds: ['${env:AWS_DISCOVERY_SECURITY_GROUP_ID}'],
-            subnetIds: [
-                '${env:AWS_DISCOVERY_SUBNET_ID_1}',
-                '${env:AWS_DISCOVERY_SUBNET_ID_2}'
-            ]
-        }
-    });
-    expect(config.resources.Resources.VPCEndpointS3).toBeDefined();
-}
-
-/**
- * Verify serverless configuration contains expected KMS settings
- * @param {Object} config - Serverless configuration
- */
-function verifyKmsConfiguration(config) {
-    expect(config.plugins).toContain('serverless-kms-grants');
-    expect(config.provider.environment.KMS_KEY_ARN).toBe('${self:custom.kmsGrants.kmsKeyId}');
-    expect(config.custom.kmsGrants).toEqual({
-        kmsKeyId: '${env:AWS_DISCOVERY_KMS_KEY_ID}'
-    });
-
-    // Verify KMS IAM permissions
-    const kmsPermission = config.provider.iamRoleStatements.find(
-        statement => statement.Action.includes('kms:GenerateDataKey')
-    );
-    expect(kmsPermission).toBeDefined();
-}
-
-/**
- * Verify serverless configuration contains expected SSM settings
- * @param {Object} config - Serverless configuration
- */
-function verifySsmConfiguration(config) {
-    expect(config.provider.layers).toEqual([
-        'arn:aws:lambda:${self:provider.region}:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11'
-    ]);
-    expect(config.provider.environment.SSM_PARAMETER_PREFIX).toBe('/${self:service}/${self:provider.stage}');
-
-    // Verify SSM IAM permissions
-    const ssmPermission = config.provider.iamRoleStatements.find(
-        statement => statement.Action.includes('ssm:GetParameter')
-    );
-    expect(ssmPermission).toBeDefined();
-}
-
-/**
- * Verify integration-specific resources are created
- * @param {Object} config - Serverless configuration
- * @param {string} integrationName - Name of the integration
- */
-function verifyIntegrationConfiguration(config, integrationName) {
-    const capitalizedName = integrationName.charAt(0).toUpperCase() + integrationName.slice(1);
-    
-    // Verify integration function
-    expect(config.functions[integrationName]).toBeDefined();
-    
-    // Verify queue worker function
-    expect(config.functions[`${integrationName}QueueWorker`]).toBeDefined();
-    
-    // Verify SQS queue resource
-    expect(config.resources.Resources[`${capitalizedName}Queue`]).toBeDefined();
-    
-    // Verify environment variable
-    expect(config.provider.environment[`${integrationName.toUpperCase()}_QUEUE_URL`]).toBeDefined();
-}
-
-/**
- * Wait for async operations to complete
- * @param {number} ms - Milliseconds to wait
- */
-function wait(ms = 0) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Capture console output for testing
- */
-function captureConsoleOutput() {
-    const originalLog = console.log;
-    const originalError = console.error;
-    const originalWarn = console.warn;
-    
-    const logs = [];
-    const errors = [];
-    const warnings = [];
-    
-    console.log = (...args) => {
-        logs.push(args.join(' '));
-    };
-    
-    console.error = (...args) => {
-        errors.push(args.join(' '));
-    };
-    
-    console.warn = (...args) => {
-        warnings.push(args.join(' '));
-    };
-    
-    return {
-        logs,
-        errors,
-        warnings,
-        restore: () => {
-            console.log = originalLog;
-            console.error = originalError;
-            console.warn = originalWarn;
-        }
-    };
-}
-
-/**
- * Mock process.argv for testing
- * @param {Array} argv - Arguments to set
- */
-function mockProcessArgv(argv = ['node', 'test']) {
-    const originalArgv = process.argv;
-    jest.spyOn(process, 'argv', 'get').mockReturnValue(argv);
-    
-    return {
-        restore: () => {
-            process.argv = originalArgv;
-        }
-    };
-}
-
-module.exports = {
-    setTestEnvironmentVariables,
-    cleanupTestEnvironmentVariables,
-    setFallbackEnvironmentVariables,
-    createMockSendFunction,
-    createMockServerless,
-    verifyEnvironmentVariables,
-    createMockIntegration,
-    createMockAppDefinition,
-    verifyVpcConfiguration,
-    verifyKmsConfiguration,
-    verifySsmConfiguration,
-    verifyIntegrationConfiguration,
-    wait,
-    captureConsoleOutput,
-    mockProcessArgv
-};