@stacksjs/ts-cloud-core 0.1.1

package/test/cache.test.ts

@@ -0,0 +1,406 @@
+import { describe, expect, it } from 'bun:test'
+import { Cache } from '../src/modules/cache'
+import { TemplateBuilder } from '../src/template-builder'
+
+describe('Cache Module', () => {
+  describe('createRedis', () => {
+    it('should create Redis replication group with default settings', () => {
+      const { replicationGroup, logicalId } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+      })
+
+      expect(replicationGroup.Type).toBe('AWS::ElastiCache::ReplicationGroup')
+      expect(replicationGroup.Properties.Engine).toBe('redis')
+      expect(replicationGroup.Properties.EngineVersion).toBe('7.1')
+      expect(replicationGroup.Properties.CacheNodeType).toBe('cache.t3.micro')
+      expect(replicationGroup.Properties.Port).toBe(6379)
+      expect(replicationGroup.Properties.NumCacheClusters).toBe(2)
+      expect(replicationGroup.Properties.AutomaticFailoverEnabled).toBe(true)
+      expect(replicationGroup.Properties.MultiAZEnabled).toBe(true)
+      expect(replicationGroup.Properties.AtRestEncryptionEnabled).toBe(true)
+      expect(replicationGroup.Properties.TransitEncryptionEnabled).toBe(true)
+      expect(replicationGroup.Properties.SnapshotRetentionLimit).toBe(7)
+      expect(logicalId).toBeDefined()
+    })
+
+    it('should create Redis with subnet group', () => {
+      const { replicationGroup, subnetGroup, subnetGroupId } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        subnetIds: ['subnet-1', 'subnet-2', 'subnet-3'],
+      })
+
+      expect(subnetGroup).toBeDefined()
+      expect(subnetGroup?.Type).toBe('AWS::ElastiCache::SubnetGroup')
+      expect(subnetGroup?.Properties.SubnetIds).toEqual(['subnet-1', 'subnet-2', 'subnet-3'])
+      expect(subnetGroupId).toBeDefined()
+    })
+
+    it('should support custom configuration', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        nodeType: 'cache.r5.large',
+        engineVersion: '7.0',
+        port: 6380,
+        numCacheClusters: 3,
+        automaticFailover: false,
+        multiAz: false,
+        snapshotRetentionDays: 14,
+      })
+
+      expect(replicationGroup.Properties.CacheNodeType).toBe('cache.r5.large')
+      expect(replicationGroup.Properties.EngineVersion).toBe('7.0')
+      expect(replicationGroup.Properties.Port).toBe(6380)
+      expect(replicationGroup.Properties.NumCacheClusters).toBe(3)
+      expect(replicationGroup.Properties.AutomaticFailoverEnabled).toBe(false)
+      expect(replicationGroup.Properties.MultiAZEnabled).toBe(false)
+      expect(replicationGroup.Properties.SnapshotRetentionLimit).toBe(14)
+    })
+
+    it('should support cluster mode', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        clusterMode: true,
+        numNodeGroups: 3,
+        replicasPerNodeGroup: 2,
+      })
+
+      expect(replicationGroup.Properties.NumNodeGroups).toBe(3)
+      expect(replicationGroup.Properties.ReplicasPerNodeGroup).toBe(2)
+      expect(replicationGroup.Properties.NumCacheClusters).toBeUndefined()
+    })
+
+    it('should support auth token', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        authToken: 'MySecureToken123!',
+      })
+
+      expect(replicationGroup.Properties.AuthToken).toBe('MySecureToken123!')
+    })
+
+    it('should support KMS encryption', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        atRestEncryption: true,
+        kmsKeyId: 'arn:aws:kms:us-east-1:123456789:key/abc',
+      })
+
+      expect(replicationGroup.Properties.KmsKeyId).toBe('arn:aws:kms:us-east-1:123456789:key/abc')
+    })
+
+    it('should support security groups', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        securityGroupIds: ['sg-123', 'sg-456'],
+      })
+
+      expect(replicationGroup.Properties.SecurityGroupIds).toEqual(['sg-123', 'sg-456'])
+    })
+
+    it('should support snapshot window', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        snapshotWindow: '03:00-05:00',
+      })
+
+      expect(replicationGroup.Properties.SnapshotWindow).toBe('03:00-05:00')
+    })
+
+    it('should support maintenance window', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        maintenanceWindow: 'sun:05:00-sun:07:00',
+      })
+
+      expect(replicationGroup.Properties.PreferredMaintenanceWindow).toBe('sun:05:00-sun:07:00')
+    })
+
+    it('should disable encryption when requested', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        atRestEncryption: false,
+        transitEncryption: false,
+      })
+
+      expect(replicationGroup.Properties.AtRestEncryptionEnabled).toBe(false)
+      expect(replicationGroup.Properties.TransitEncryptionEnabled).toBe(false)
+    })
+  })
+
+  describe('createMemcached', () => {
+    it('should create Memcached cluster with default settings', () => {
+      const { cluster, logicalId } = Cache.createMemcached({
+        slug: 'my-app',
+        environment: 'production',
+      })
+
+      expect(cluster.Type).toBe('AWS::ElastiCache::CacheCluster')
+      expect(cluster.Properties.Engine).toBe('memcached')
+      expect(cluster.Properties.EngineVersion).toBe('1.6.22')
+      expect(cluster.Properties.CacheNodeType).toBe('cache.t3.micro')
+      expect(cluster.Properties.Port).toBe(11211)
+      expect(cluster.Properties.NumCacheNodes).toBe(2)
+      expect(cluster.Properties.AZMode).toBe('cross-az')
+      expect(logicalId).toBeDefined()
+    })
+
+    it('should create Memcached with subnet group', () => {
+      const { cluster, subnetGroup, subnetGroupId } = Cache.createMemcached({
+        slug: 'my-app',
+        environment: 'production',
+        subnetIds: ['subnet-1', 'subnet-2'],
+      })
+
+      expect(subnetGroup).toBeDefined()
+      expect(subnetGroup?.Type).toBe('AWS::ElastiCache::SubnetGroup')
+      expect(subnetGroup?.Properties.SubnetIds).toEqual(['subnet-1', 'subnet-2'])
+      expect(subnetGroupId).toBeDefined()
+    })
+
+    it('should support custom configuration', () => {
+      const { cluster } = Cache.createMemcached({
+        slug: 'my-app',
+        environment: 'production',
+        nodeType: 'cache.m5.large',
+        engineVersion: '1.6.17',
+        port: 11212,
+        numCacheNodes: 3,
+        azMode: 'single-az',
+      })
+
+      expect(cluster.Properties.CacheNodeType).toBe('cache.m5.large')
+      expect(cluster.Properties.EngineVersion).toBe('1.6.17')
+      expect(cluster.Properties.Port).toBe(11212)
+      expect(cluster.Properties.NumCacheNodes).toBe(3)
+      expect(cluster.Properties.AZMode).toBe('single-az')
+    })
+
+    it('should support security groups', () => {
+      const { cluster } = Cache.createMemcached({
+        slug: 'my-app',
+        environment: 'production',
+        securityGroupIds: ['sg-123'],
+      })
+
+      expect(cluster.Properties.VpcSecurityGroupIds).toEqual(['sg-123'])
+    })
+
+    it('should support preferred availability zones', () => {
+      const { cluster } = Cache.createMemcached({
+        slug: 'my-app',
+        environment: 'production',
+        preferredAzs: ['us-east-1a', 'us-east-1b'],
+      })
+
+      expect(cluster.Properties.PreferredAvailabilityZones).toEqual(['us-east-1a', 'us-east-1b'])
+    })
+
+    it('should support maintenance window', () => {
+      const { cluster } = Cache.createMemcached({
+        slug: 'my-app',
+        environment: 'production',
+        maintenanceWindow: 'sun:05:00-sun:07:00',
+      })
+
+      expect(cluster.Properties.PreferredMaintenanceWindow).toBe('sun:05:00-sun:07:00')
+    })
+  })
+
+  describe('enableClusterMode', () => {
+    it('should enable cluster mode on Redis', () => {
+      const { replicationGroup } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+      })
+
+      Cache.enableClusterMode(replicationGroup, 3, 2)
+
+      expect(replicationGroup.Properties.NumNodeGroups).toBe(3)
+      expect(replicationGroup.Properties.ReplicasPerNodeGroup).toBe(2)
+      expect(replicationGroup.Properties.NumCacheClusters).toBeUndefined()
+    })
+  })
+
+  describe('createRedisParameterGroup', () => {
+    it('should create Redis parameter group', () => {
+      const { parameterGroup, logicalId } = Cache.createRedisParameterGroup('7.1', {
+        slug: 'my-app',
+        environment: 'production',
+        parameters: {
+          'maxmemory-policy': 'allkeys-lru',
+          'timeout': '300',
+        },
+      })
+
+      expect(parameterGroup.Type).toBe('AWS::ElastiCache::ParameterGroup')
+      expect(parameterGroup.Properties.CacheParameterGroupFamily).toBe('redis7.x')
+      expect(parameterGroup.Properties.Properties?.['maxmemory-policy']).toBe('allkeys-lru')
+      expect(parameterGroup.Properties.Properties?.timeout).toBe('300')
+      expect(logicalId).toBeDefined()
+    })
+
+    it('should support different Redis versions', () => {
+      const { parameterGroup: v6 } = Cache.createRedisParameterGroup('6.2', {
+        slug: 'my-app',
+        environment: 'production',
+      })
+
+      const { parameterGroup: v7 } = Cache.createRedisParameterGroup('7.0', {
+        slug: 'my-app',
+        environment: 'production',
+      })
+
+      expect(v6.Properties.CacheParameterGroupFamily).toBe('redis6.x')
+      expect(v7.Properties.CacheParameterGroupFamily).toBe('redis7.x')
+    })
+  })
+
+  describe('createMemcachedParameterGroup', () => {
+    it('should create Memcached parameter group', () => {
+      const { parameterGroup, logicalId } = Cache.createMemcachedParameterGroup('1.6.22', {
+        slug: 'my-app',
+        environment: 'production',
+        parameters: {
+          'max_item_size': '10485760',
+        },
+      })
+
+      expect(parameterGroup.Type).toBe('AWS::ElastiCache::ParameterGroup')
+      expect(parameterGroup.Properties.CacheParameterGroupFamily).toBe('memcached1.6')
+      expect(parameterGroup.Properties.Properties?.max_item_size).toBe('10485760')
+      expect(logicalId).toBeDefined()
+    })
+  })
+
+  describe('NodeTypes', () => {
+    it('should provide common node type constants', () => {
+      expect(Cache.NodeTypes.T3_Micro).toBe('cache.t3.micro')
+      expect(Cache.NodeTypes.T3_Small).toBe('cache.t3.small')
+      expect(Cache.NodeTypes.M5_Large).toBe('cache.m5.large')
+      expect(Cache.NodeTypes.R5_XLarge).toBe('cache.r5.xlarge')
+      expect(Cache.NodeTypes.R6g_Large).toBe('cache.r6g.large')
+    })
+  })
+
+  describe('Integration with TemplateBuilder', () => {
+    it('should create Redis cluster infrastructure', () => {
+      const template = new TemplateBuilder('Redis Cluster')
+
+      const { replicationGroup, subnetGroup, logicalId, subnetGroupId } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        subnetIds: ['subnet-1', 'subnet-2', 'subnet-3'],
+        securityGroupIds: ['sg-123'],
+        numCacheClusters: 3,
+        authToken: 'MySecureToken123!',
+      })
+
+      if (subnetGroup && subnetGroupId) {
+        template.addResource(subnetGroupId, subnetGroup)
+      }
+
+      template.addResource(logicalId, replicationGroup)
+
+      const result = template.build()
+
+      expect(Object.keys(result.Resources)).toHaveLength(2)
+      expect(result.Resources[logicalId].Type).toBe('AWS::ElastiCache::ReplicationGroup')
+    })
+
+    it('should create Redis cluster mode infrastructure', () => {
+      const template = new TemplateBuilder('Redis Cluster Mode')
+
+      const { replicationGroup, logicalId } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+        clusterMode: true,
+        numNodeGroups: 3,
+        replicasPerNodeGroup: 2,
+        nodeType: Cache.NodeTypes.R5_Large,
+      })
+
+      template.addResource(logicalId, replicationGroup)
+
+      const result = template.build()
+
+      expect(Object.keys(result.Resources)).toHaveLength(1)
+      expect(result.Resources[logicalId]!.Properties!.NumNodeGroups).toBe(3)
+      expect(result.Resources[logicalId]!.Properties!.ReplicasPerNodeGroup).toBe(2)
+    })
+
+    it('should create Memcached cluster infrastructure', () => {
+      const template = new TemplateBuilder('Memcached Cluster')
+
+      const { cluster, subnetGroup, logicalId, subnetGroupId } = Cache.createMemcached({
+        slug: 'my-app',
+        environment: 'production',
+        subnetIds: ['subnet-1', 'subnet-2'],
+        numCacheNodes: 3,
+        azMode: 'cross-az',
+      })
+
+      if (subnetGroup && subnetGroupId) {
+        template.addResource(subnetGroupId, subnetGroup)
+      }
+
+      template.addResource(logicalId, cluster)
+
+      const result = template.build()
+
+      expect(Object.keys(result.Resources)).toHaveLength(2)
+      expect(result.Resources[logicalId].Type).toBe('AWS::ElastiCache::CacheCluster')
+    })
+
+    it('should create Redis with parameter group', () => {
+      const template = new TemplateBuilder('Redis with Params')
+
+      const { replicationGroup, logicalId: redisId } = Cache.createRedis({
+        slug: 'my-app',
+        environment: 'production',
+      })
+
+      const { parameterGroup, logicalId: paramsId } = Cache.createRedisParameterGroup('7.1', {
+        slug: 'my-app',
+        environment: 'production',
+        parameters: {
+          'maxmemory-policy': 'allkeys-lru',
+        },
+      })
+
+      template.addResource(paramsId, parameterGroup)
+      template.addResource(redisId, replicationGroup)
+
+      const result = template.build()
+
+      expect(Object.keys(result.Resources)).toHaveLength(2)
+      expect(result.Resources[paramsId].Type).toBe('AWS::ElastiCache::ParameterGroup')
+    })
+
+    it('should generate valid JSON template', () => {
+      const template = new TemplateBuilder('Cache Test')
+
+      const { replicationGroup, logicalId } = Cache.createRedis({
+        slug: 'test',
+        environment: 'development',
+      })
+
+      template.addResource(logicalId, replicationGroup)
+
+      const json = template.toJSON()
+      const parsed = JSON.parse(json)
+
+      expect(parsed.Resources[logicalId].Type).toBe('AWS::ElastiCache::ReplicationGroup')
+      expect(parsed.Resources[logicalId].Properties.Engine).toBe('redis')
+    })
+  })
+})

package/test/cdn.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, it } from 'bun:test'
+import { CDN } from '../src/modules/cdn'
+import { TemplateBuilder } from '../src/template-builder'
+
+describe('CDN Module', () => {
+  describe('createDistribution', () => {
+    it('should create a basic CloudFront distribution with S3 origin', () => {
+      const { distribution, originAccessControl, logicalId } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+      })
+
+      expect(distribution.Type).toBe('AWS::CloudFront::Distribution')
+      expect(distribution.Properties.DistributionConfig.Enabled).toBe(true)
+      expect(distribution.Properties.DistributionConfig.Origins).toHaveLength(1)
+      expect(distribution.Properties.DistributionConfig.Origins[0].DomainName).toBe('my-bucket.s3.amazonaws.com')
+      expect(originAccessControl).toBeDefined()
+      expect(originAccessControl?.Type).toBe('AWS::CloudFront::OriginAccessControl')
+    })
+
+    it('should create distribution with custom domain and certificate', () => {
+      const { distribution } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+        customDomain: 'www.example.com',
+        certificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/abc',
+      })
+
+      expect(distribution.Properties.DistributionConfig.Aliases).toContain('www.example.com')
+      expect(distribution.Properties.DistributionConfig.ViewerCertificate?.AcmCertificateArn).toBe(
+        'arn:aws:acm:us-east-1:123456789:certificate/abc',
+      )
+      expect(distribution.Properties.DistributionConfig.ViewerCertificate?.SslSupportMethod).toBe('sni-only')
+    })
+
+    it('should create distribution with ALB origin', () => {
+      const { distribution, originAccessControl } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 'alb',
+          domainName: 'my-alb.us-east-1.elb.amazonaws.com',
+        },
+      })
+
+      expect(distribution.Properties.DistributionConfig.Origins[0].CustomOriginConfig).toBeDefined()
+      expect(distribution.Properties.DistributionConfig.Origins[0].CustomOriginConfig?.OriginProtocolPolicy).toBe(
+        'https-only',
+      )
+      expect(originAccessControl).toBeUndefined() // ALB doesn't use OAC
+    })
+
+    it('should configure error pages for SPA', () => {
+      const { distribution } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+        errorPages: [
+          { errorCode: 404, responseCode: 200, responsePagePath: '/index.html' },
+          { errorCode: 403, responseCode: 200, responsePagePath: '/index.html' },
+        ],
+      })
+
+      expect(distribution.Properties.DistributionConfig.CustomErrorResponses).toHaveLength(2)
+      expect(distribution.Properties.DistributionConfig.CustomErrorResponses?.[0].ErrorCode).toBe(404)
+      expect(distribution.Properties.DistributionConfig.CustomErrorResponses?.[0].ResponsePagePath).toBe('/index.html')
+    })
+
+    it('should enable HTTP/3 when specified', () => {
+      const { distribution } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+        http3: true,
+      })
+
+      expect(distribution.Properties.DistributionConfig.HttpVersion).toBe('http2and3')
+    })
+
+    it('should configure Lambda@Edge functions', () => {
+      const { distribution } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+        edgeFunctions: [
+          {
+            event: 'origin-request',
+            functionArn: 'arn:aws:lambda:us-east-1:123456789:function:my-function:1',
+          },
+        ],
+      })
+
+      expect(
+        distribution.Properties.DistributionConfig.DefaultCacheBehavior.LambdaFunctionAssociations,
+      ).toHaveLength(1)
+      expect(
+        distribution.Properties.DistributionConfig.DefaultCacheBehavior.LambdaFunctionAssociations?.[0].EventType,
+      ).toBe('origin-request')
+    })
+  })
+
+  describe('createSpaDistribution', () => {
+    it('should create SPA distribution with 404/403 → index.html mapping', () => {
+      const { distribution } = CDN.createSpaDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+      })
+
+      const errorResponses = distribution.Properties.DistributionConfig.CustomErrorResponses
+      expect(errorResponses).toHaveLength(2)
+      expect(errorResponses?.find(r => r.ErrorCode === 404)?.ResponseCode).toBe(200)
+      expect(errorResponses?.find(r => r.ErrorCode === 403)?.ResponseCode).toBe(200)
+    })
+  })
+
+  describe('setCustomDomain', () => {
+    it('should add custom domain to existing distribution', () => {
+      const { distribution } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+      })
+
+      const updated = CDN.setCustomDomain(
+        distribution,
+        'cdn.example.com',
+        'arn:aws:acm:us-east-1:123456789:certificate/xyz',
+      )
+
+      expect(updated.Properties.DistributionConfig.Aliases).toContain('cdn.example.com')
+      expect(updated.Properties.DistributionConfig.ViewerCertificate?.AcmCertificateArn).toContain('certificate/xyz')
+    })
+  })
+
+  describe('enableHttp3', () => {
+    it('should enable HTTP/3 on existing distribution', () => {
+      const { distribution } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+      })
+
+      const updated = CDN.enableHttp3(distribution)
+
+      expect(updated.Properties.DistributionConfig.HttpVersion).toBe('http2and3')
+    })
+  })
+
+  describe('addEdgeFunction', () => {
+    it('should add Lambda@Edge function to existing distribution', () => {
+      const { distribution } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+      })
+
+      const updated = CDN.addEdgeFunction(
+        distribution,
+        'viewer-request',
+        'arn:aws:lambda:us-east-1:123456789:function:auth:1',
+      )
+
+      const associations = updated.Properties.DistributionConfig.DefaultCacheBehavior.LambdaFunctionAssociations
+      expect(associations).toHaveLength(1)
+      expect(associations?.[0].EventType).toBe('viewer-request')
+    })
+  })
+
+  describe('Integration with TemplateBuilder', () => {
+    it('should integrate with CloudFormation template', () => {
+      const template = new TemplateBuilder('CDN Infrastructure')
+
+      const { distribution, originAccessControl, logicalId } = CDN.createDistribution({
+        slug: 'my-app',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'my-bucket.s3.amazonaws.com',
+        },
+        customDomain: 'www.example.com',
+        certificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/abc',
+      })
+
+      template.addResource(logicalId, distribution)
+
+      if (originAccessControl) {
+        template.addResource(`${logicalId}OAC`, originAccessControl)
+      }
+
+      const result = template.build()
+
+      expect(result.Resources[logicalId]).toBeDefined()
+      expect(result.Resources[logicalId].Type).toBe('AWS::CloudFront::Distribution')
+    })
+
+    it('should generate valid JSON template', () => {
+      const template = new TemplateBuilder('CDN Test')
+
+      const { distribution, logicalId } = CDN.createSpaDistribution({
+        slug: 'spa',
+        environment: 'production',
+        origin: {
+          type: 's3',
+          domainName: 'spa-bucket.s3.amazonaws.com',
+        },
+      })
+
+      template.addResource(logicalId, distribution)
+
+      const json = template.toJSON()
+      const parsed = JSON.parse(json)
+
+      expect(parsed.Resources[logicalId].Type).toBe('AWS::CloudFront::Distribution')
+      expect(parsed.Resources[logicalId].Properties.DistributionConfig.CustomErrorResponses).toHaveLength(2)
+    })
+  })
+})