@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/test/storage.test.ts

@@ -1,463 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { Storage } from '../src/modules/storage'
-import { TemplateBuilder } from '../src/template-builder'
-
-describe('Storage Module', () => {
-  describe('createBucket', () => {
-    it('should create a basic private bucket', () => {
-      const { bucket, logicalId } = Storage.createBucket({
-        name: 'test',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      expect(bucket.Type).toBe('AWS::S3::Bucket')
-      expect(bucket.Properties?.BucketName).toBe('my-app-production-s3-test')
-      expect(logicalId).toBe('MyAppProductionS3Test')
-      expect(bucket.Properties?.PublicAccessBlockConfiguration).toBeDefined()
-      expect(bucket.Properties?.BucketEncryption).toBeDefined()
-    })
-
-    it('should create a public bucket with policy', () => {
-      const { bucket, bucketPolicy, logicalId } = Storage.createBucket({
-        name: 'website',
-        slug: 'my-app',
-        environment: 'production',
-        public: true,
-      })
-
-      expect(bucket.Properties?.PublicAccessBlockConfiguration).toBeUndefined()
-      expect(bucketPolicy).toBeDefined()
-      expect(bucketPolicy?.Type).toBe('AWS::S3::BucketPolicy')
-      expect(bucketPolicy?.Properties.PolicyDocument.Statement[0].Effect).toBe('Allow')
-      expect(bucketPolicy?.Properties.PolicyDocument.Statement[0].Action).toContain('s3:GetObject')
-    })
-
-    it('should enable versioning when specified', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'versioned',
-        slug: 'my-app',
-        environment: 'production',
-        versioning: true,
-      })
-
-      expect(bucket.Properties?.VersioningConfiguration?.Status).toBe('Enabled')
-    })
-
-    it('should enable website hosting when specified', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'website',
-        slug: 'my-app',
-        environment: 'production',
-        website: true,
-      })
-
-      expect(bucket.Properties?.WebsiteConfiguration).toBeDefined()
-      expect(bucket.Properties?.WebsiteConfiguration?.IndexDocument).toBe('index.html')
-      expect(bucket.Properties?.WebsiteConfiguration?.ErrorDocument).toBe('error.html')
-    })
-
-    it('should configure CORS rules', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'api',
-        slug: 'my-app',
-        environment: 'production',
-        cors: [
-          {
-            allowedOrigins: ['https://example.com'],
-            allowedMethods: ['GET', 'POST'],
-            allowedHeaders: ['*'],
-            maxAge: 3600,
-          },
-        ],
-      })
-
-      expect(bucket.Properties?.CorsConfiguration?.CorsRules).toHaveLength(1)
-      expect(bucket.Properties?.CorsConfiguration?.CorsRules[0].AllowedOrigins).toContain('https://example.com')
-    })
-
-    it('should configure lifecycle rules', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'logs',
-        slug: 'my-app',
-        environment: 'production',
-        lifecycleRules: [
-          {
-            id: 'DeleteOldLogs',
-            enabled: true,
-            expirationDays: 30,
-          },
-        ],
-      })
-
-      expect(bucket.Properties?.LifecycleConfiguration?.Rules).toHaveLength(1)
-      expect(bucket.Properties?.LifecycleConfiguration?.Rules[0].ExpirationInDays).toBe(30)
-      expect(bucket.Properties?.LifecycleConfiguration?.Rules[0].Status).toBe('Enabled')
-    })
-  })
-
-  describe('enableVersioning', () => {
-    it('should enable versioning on existing bucket', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'test',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.enableVersioning(bucket)
-
-      expect(updated.Properties?.VersioningConfiguration?.Status).toBe('Enabled')
-    })
-  })
-
-  describe('enableWebsiteHosting', () => {
-    it('should enable website hosting with default documents', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'test',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.enableWebsiteHosting(bucket)
-
-      expect(updated.Properties?.WebsiteConfiguration?.IndexDocument).toBe('index.html')
-      expect(updated.Properties?.WebsiteConfiguration?.ErrorDocument).toBe('error.html')
-    })
-
-    it('should enable website hosting with custom documents', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'test',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.enableWebsiteHosting(bucket, 'main.html', '404.html')
-
-      expect(updated.Properties?.WebsiteConfiguration?.IndexDocument).toBe('main.html')
-      expect(updated.Properties?.WebsiteConfiguration?.ErrorDocument).toBe('404.html')
-    })
-  })
-
-  describe('addLambdaNotification', () => {
-    it('should add Lambda notification for object creation', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'uploads',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.addLambdaNotification(bucket, {
-        functionArn: 'arn:aws:lambda:us-east-1:123456789:function:ProcessUpload',
-        events: ['s3:ObjectCreated:*'],
-      })
-
-      expect(updated.Properties?.NotificationConfiguration).toBeDefined()
-      expect(updated.Properties?.NotificationConfiguration?.LambdaConfigurations).toHaveLength(1)
-      expect(updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[0].Event).toBe('s3:ObjectCreated:*')
-      expect(updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[0].Function).toBe('arn:aws:lambda:us-east-1:123456789:function:ProcessUpload')
-    })
-
-    it('should add Lambda notification with prefix filter', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'uploads',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.addLambdaNotification(bucket, {
-        functionArn: 'arn:aws:lambda:us-east-1:123456789:function:ProcessImage',
-        events: ['s3:ObjectCreated:Put'],
-        filter: {
-          prefix: 'images/',
-        },
-      })
-
-      const config = updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[0]
-      expect(config?.Filter).toBeDefined()
-      expect(config?.Filter?.S3Key?.Rules).toContainEqual({ Name: 'prefix', Value: 'images/' })
-    })
-
-    it('should add Lambda notification with suffix filter', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'uploads',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.addLambdaNotification(bucket, {
-        functionArn: 'arn:aws:lambda:us-east-1:123456789:function:ProcessPDF',
-        events: ['s3:ObjectCreated:*'],
-        filter: {
-          suffix: '.pdf',
-        },
-      })
-
-      const config = updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[0]
-      expect(config?.Filter).toBeDefined()
-      expect(config?.Filter?.S3Key?.Rules).toContainEqual({ Name: 'suffix', Value: '.pdf' })
-    })
-
-    it('should add Lambda notification with both prefix and suffix filters', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'uploads',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.addLambdaNotification(bucket, {
-        functionArn: 'arn:aws:lambda:us-east-1:123456789:function:ProcessDoc',
-        events: ['s3:ObjectCreated:*'],
-        filter: {
-          prefix: 'documents/',
-          suffix: '.docx',
-        },
-      })
-
-      const config = updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[0]
-      expect(config?.Filter?.S3Key?.Rules).toHaveLength(2)
-      expect(config?.Filter?.S3Key?.Rules).toContainEqual({ Name: 'prefix', Value: 'documents/' })
-      expect(config?.Filter?.S3Key?.Rules).toContainEqual({ Name: 'suffix', Value: '.docx' })
-    })
-
-    it('should add multiple Lambda notifications for multiple events', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'monitored',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.addLambdaNotification(bucket, {
-        functionArn: 'arn:aws:lambda:us-east-1:123456789:function:Monitor',
-        events: ['s3:ObjectCreated:*', 's3:ObjectRemoved:*'],
-      })
-
-      expect(updated.Properties?.NotificationConfiguration?.LambdaConfigurations).toHaveLength(2)
-      expect(updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[0].Event).toBe('s3:ObjectCreated:*')
-      expect(updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[1].Event).toBe('s3:ObjectRemoved:*')
-    })
-
-    it('should support Fn::GetAtt for Lambda ARN', () => {
-      const { bucket } = Storage.createBucket({
-        name: 'uploads',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const updated = Storage.addLambdaNotification(bucket, {
-        functionArn: { 'Fn::GetAtt': ['ProcessorFunction', 'Arn'] },
-        events: ['s3:ObjectCreated:*'],
-      })
-
-      expect((updated.Properties?.NotificationConfiguration?.LambdaConfigurations?.[0] as any).Function).toEqual({
-        'Fn::GetAtt': ['ProcessorFunction', 'Arn'],
-      })
-    })
-  })
-
-  describe('Storage.Notifications helpers', () => {
-    it('should create onObjectCreated notification config', () => {
-      const config = Storage.Notifications.onObjectCreated('arn:aws:lambda:us-east-1:123456789:function:OnCreate')
-
-      expect(config.functionArn).toBe('arn:aws:lambda:us-east-1:123456789:function:OnCreate')
-      expect(config.events).toContain('s3:ObjectCreated:*')
-    })
-
-    it('should create onObjectRemoved notification config', () => {
-      const config = Storage.Notifications.onObjectRemoved('arn:aws:lambda:us-east-1:123456789:function:OnDelete')
-
-      expect(config.functionArn).toBe('arn:aws:lambda:us-east-1:123456789:function:OnDelete')
-      expect(config.events).toContain('s3:ObjectRemoved:*')
-    })
-
-    it('should create onImageUpload notification config', () => {
-      const config = Storage.Notifications.onImageUpload('arn:aws:lambda:us-east-1:123456789:function:ProcessImage', 'uploads/')
-
-      expect(config.functionArn).toBe('arn:aws:lambda:us-east-1:123456789:function:ProcessImage')
-      expect(config.events).toContain('s3:ObjectCreated:*')
-      expect(config.filter?.prefix).toBe('uploads/')
-      expect((config.filter as any)?.suffix).toBe('.jpg')
-    })
-
-    it('should create onFileType notification config', () => {
-      const config = Storage.Notifications.onFileType(
-        'arn:aws:lambda:us-east-1:123456789:function:ProcessPDF',
-        '.pdf',
-        'documents/',
-      )
-
-      expect(config.functionArn).toBe('arn:aws:lambda:us-east-1:123456789:function:ProcessPDF')
-      expect(config.events).toContain('s3:ObjectCreated:*')
-      expect(config.filter?.prefix).toBe('documents/')
-      expect(config.filter?.suffix).toBe('.pdf')
-    })
-
-    it('should create onFolderUpload notification config', () => {
-      const config = Storage.Notifications.onFolderUpload('arn:aws:lambda:us-east-1:123456789:function:ProcessFolder', 'uploads')
-
-      expect(config.functionArn).toBe('arn:aws:lambda:us-east-1:123456789:function:ProcessFolder')
-      expect(config.events).toContain('s3:ObjectCreated:*')
-      expect(config.filter?.prefix).toBe('uploads/')
-    })
-
-    it('should handle folder paths with trailing slash', () => {
-      const config = Storage.Notifications.onFolderUpload('arn:aws:lambda:us-east-1:123456789:function:Process', 'uploads/')
-
-      expect(config.filter?.prefix).toBe('uploads/')
-    })
-
-    it('should work with Fn::GetAtt in helper methods', () => {
-      const config = Storage.Notifications.onObjectCreated({ 'Fn::GetAtt': ['MyFunction', 'Arn'] })
-
-      expect(config.functionArn).toEqual({ 'Fn::GetAtt': ['MyFunction', 'Arn'] })
-    })
-  })
-
-  describe('Integration with TemplateBuilder', () => {
-    it('should integrate with CloudFormation template', () => {
-      const template = new TemplateBuilder('Test Infrastructure')
-
-      const { bucket, bucketPolicy, logicalId } = Storage.createBucket({
-        name: 'website',
-        slug: 'my-app',
-        environment: 'production',
-        public: true,
-        website: true,
-        versioning: true,
-      })
-
-      template.addResource(logicalId, bucket)
-
-      if (bucketPolicy) {
-        template.addResource(`${logicalId}Policy`, bucketPolicy)
-      }
-
-      const result = template.build()
-
-      expect(result.Resources[logicalId]).toBeDefined()
-      expect(result.Resources[`${logicalId}Policy`]).toBeDefined()
-      expect(result.AWSTemplateFormatVersion).toBe('2010-09-09')
-    })
-
-    it('should generate valid JSON template', () => {
-      const template = new TemplateBuilder('Test S3')
-
-      const { bucket, logicalId } = Storage.createBucket({
-        name: 'data',
-        slug: 'test',
-        environment: 'development',
-        encryption: true,
-      })
-
-      template.addResource(logicalId, bucket)
-
-      const json = template.toJSON()
-      const parsed = JSON.parse(json)
-
-      expect(parsed.Resources[logicalId].Type).toBe('AWS::S3::Bucket')
-      expect(parsed.Resources[logicalId].Properties.BucketEncryption).toBeDefined()
-    })
-  })
-
-  describe('createBackupPlan', () => {
-    it('should create a backup plan with vault, plan, selection, and role', () => {
-      const { bucket: bucket1, logicalId: bucketId1 } = Storage.createBucket({
-        name: 'data1',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const { bucket: bucket2, logicalId: bucketId2 } = Storage.createBucket({
-        name: 'data2',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const { vault, plan, selection, role, vaultLogicalId, planLogicalId, selectionLogicalId, roleLogicalId }
-        = Storage.createBackupPlan({
-          name: 's3-backup',
-          slug: 'my-app',
-          environment: 'production',
-          bucketLogicalIds: [bucketId1, bucketId2],
-          retentionDays: 30,
-        })
-
-      expect(vault.Type).toBe('AWS::Backup::BackupVault')
-      expect(vault.Properties.BackupVaultName).toBe('my-app-production-backup-vault-s3-backup')
-      expect(vaultLogicalId).toBe('MyAppProductionBackupVaultS3Backup')
-
-      expect(plan.Type).toBe('AWS::Backup::BackupPlan')
-      expect(plan.Properties.BackupPlan.BackupPlanName).toBe('my-app-production-backup-plan-s3-backup')
-      expect(plan.Properties.BackupPlan.BackupPlanRule).toHaveLength(1)
-      expect(plan.Properties!.BackupPlan.BackupPlanRule![0].ScheduleExpression).toBe('cron(0 5 * * ? *)')
-      expect(plan.Properties!.BackupPlan.BackupPlanRule![0].Lifecycle!.DeleteAfterDays).toBe(30)
-      expect(planLogicalId).toBe('MyAppProductionBackupPlanS3Backup')
-
-      expect(selection.Type).toBe('AWS::Backup::BackupSelection')
-      expect(selection.Properties.BackupSelection.Resources).toHaveLength(2)
-      expect(selectionLogicalId).toBe('MyAppProductionBackupSelectionS3Backup')
-
-      expect(role.Type).toBe('AWS::IAM::Role')
-      expect(role.Properties.ManagedPolicyArns).toContain('arn:aws:iam::aws:policy/service-role/AWSBackupServiceRolePolicyForBackup')
-      expect(role.Properties.ManagedPolicyArns).toContain('arn:aws:iam::aws:policy/service-role/AWSBackupServiceRolePolicyForRestores')
-      expect(roleLogicalId).toBe('MyAppProductionBackupRoleS3Backup')
-    })
-
-    it('should create backup plan with custom schedule', () => {
-      const { bucket, logicalId } = Storage.createBucket({
-        name: 'data',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const { plan } = Storage.createBackupPlan({
-        name: 'hourly-backup',
-        slug: 'my-app',
-        environment: 'production',
-        bucketLogicalIds: [logicalId],
-        retentionDays: 7,
-        schedule: Storage.BackupSchedules.HOURLY,
-      })
-
-      expect(plan.Properties.BackupPlan.BackupPlanRule[0].ScheduleExpression).toBe('cron(0 * * * ? *)')
-    })
-
-    it('should create backup plan with cold storage transition', () => {
-      const { bucket, logicalId } = Storage.createBucket({
-        name: 'data',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const { plan } = Storage.createBackupPlan({
-        name: 'cold-storage',
-        slug: 'my-app',
-        environment: 'production',
-        bucketLogicalIds: [logicalId],
-        retentionDays: 90,
-        moveToColdStorageAfterDays: 30,
-      })
-
-      expect(plan.Properties!.BackupPlan.BackupPlanRule![0].Lifecycle!.DeleteAfterDays).toBe(90)
-      expect(plan.Properties!.BackupPlan.BackupPlanRule![0].Lifecycle!.MoveToColdStorageAfterDays).toBe(30)
-    })
-
-    it('should create backup plan with continuous backup enabled', () => {
-      const { bucket, logicalId } = Storage.createBucket({
-        name: 'data',
-        slug: 'my-app',
-        environment: 'production',
-      })
-
-      const { plan } = Storage.createBackupPlan({
-        name: 'continuous',
-        slug: 'my-app',
-        environment: 'production',
-        bucketLogicalIds: [logicalId],
-        retentionDays: 7,
-        enableContinuousBackup: true,
-      })
-
-      expect(plan.Properties.BackupPlan.BackupPlanRule[0].EnableContinuousBackup).toBe(true)
-    })
-  })
-})