@aws-solutions-constructs/core 2.0.0-rc.2 → 2.0.0

package/test/alb-helper.test.js

@@ -65,145 +65,136 @@ test('Test ObtainAlb for new ALB with default props', () => {
         Scheme: "internal",
     });
 });
-test('Test ObtainAlb for new ALB with default props', () => {
-    const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
-    });
-    defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction);
-    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {
-        TargetType: "lambda"
-    });
-});
-test('Test ObtainAlb for new ALB with custom props', () => {
-    const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
+test('Test with custom logging bucket props', () => {
+    // Creating ALB logging requires a region and account (but
+    // these can be fake in unit tests)
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined, {
+        env: { account: "123456789012", region: 'us-east-1' },
     });
-    defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
-        targetGroupName: 'test-target-group'
+    // Build VPC
+    const vpc = defaults.buildVpc(stack, {
+        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
     });
-    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {
-        TargetType: "lambda",
-        Name: 'test-target-group'
+    const testName = 'test-name';
+    defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, true, { bucketName: testName });
+    expect(stack).toHaveResourceLike('AWS::S3::Bucket', {
+        BucketName: testName
     });
 });
-test('Test Add Target without ruleProps', () => {
+test('Test with no logging', () => {
     const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
-    });
-    const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
-        targetGroupName: 'test-target-group'
-    });
     // Build VPC
     const vpc = defaults.buildVpc(stack, {
         defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
     });
-    const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {
+    defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, false);
+    expect(stack).not.toHaveResourceLike('AWS::S3::Bucket', {});
+});
+function CreateTestVpc(stack) {
+    return defaults.buildVpc(stack, {
+        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
+    });
+}
+function CreateTestLoadBalancer(stack, vpc) {
+    return new elb.ApplicationLoadBalancer(stack, 'load-balancer', {
         vpc,
         internetFacing: true,
         loadBalancerName: 'unique-name'
     });
-    const testListener = new elb.ApplicationListener(stack, 'test-listener', {
-        loadBalancer: existingLoadBalancer,
+}
+function GetCert(stack) {
+    return acm.Certificate.fromCertificateArn(stack, 'not-really-a-cert', "arn:aws:acm:us-east-1:123456789012:certificate/85c52dc8-1b37-4afd-a7aa-f03aac2db0cc");
+}
+function CreateTestFunction(stack, id) {
+    return new lambda.Function(stack, id, {
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        runtime: lambda.Runtime.NODEJS_14_X,
+        handler: "index.handler",
+    });
+}
+function CreateTestListener(stack, id, alb) {
+    return new elb.ApplicationListener(stack, id, {
+        loadBalancer: alb,
         protocol: elb.ApplicationProtocol.HTTP
     });
-    defaults.AddTarget(stack, targetGroup, testListener);
+}
+test('Test add single lambda target group with no customization', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    // Set up test framework independent of our code for unit testing
+    const testFunction = CreateTestFunction(stack, 'test-function');
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const testListener = CreateTestListener(stack, 'test-listener', testAlb);
+    // This is the code we're testing
+    defaults.AddLambdaTarget(stack, 'test-lambda-target', testListener, testFunction);
     expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
         DefaultActions: [
             {
                 TargetGroupArn: {
-                    Ref: "testtargettgB2EE41CA"
+                    Ref: "testlambdatargettg7E5C32F4"
                 },
                 Type: "forward"
             }
         ],
     });
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {
+        TargetType: "lambda",
+    });
 });
-test('Test Add Target with ruleProps', () => {
+test('Test add single lambda target group with target group props', () => {
     const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
-    });
-    const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
-        targetGroupName: 'test-target-group'
-    });
-    const secondTargetGroup = defaults.CreateLambdaTargetGroup(stack, 'second-target', testFunction, {
-        targetGroupName: 'second-target-group'
-    });
-    // Build VPC
-    const vpc = defaults.buildVpc(stack, {
-        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
-    });
-    const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {
-        vpc,
-        internetFacing: true,
-        loadBalancerName: 'unique-name'
-    });
-    const testListener = new elb.ApplicationListener(stack, 'test-listener', {
-        loadBalancer: existingLoadBalancer,
-        protocol: elb.ApplicationProtocol.HTTP
+    // Set up test framework independent of our code for unit testing
+    const testFunction = CreateTestFunction(stack, 'test-function');
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const testListener = CreateTestListener(stack, 'test-listener', testAlb);
+    const targetGroupName = 'test-group';
+    // This is the code we're testing
+    defaults.AddLambdaTarget(stack, 'test-lambda-target', testListener, testFunction, undefined, { targetGroupName });
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {
+        TargetType: "lambda",
+        Name: targetGroupName,
     });
-    // The first target is default and can't have rules, so
-    // we need to add 2 targets
-    defaults.AddTarget(stack, targetGroup, testListener);
-    defaults.AddTarget(stack, secondTargetGroup, testListener, {
-        conditions: [elb.ListenerCondition.pathPatterns(["*admin*"])],
+});
+test('Test add rule props for second lambda target group', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    // Set up test framework independent of our code for unit testing
+    const testFunction = CreateTestFunction(stack, 'test-function');
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const testListener = CreateTestListener(stack, 'test-listener', testAlb);
+    const targetGroupName = 'test-group';
+    const pathPattern = '*admin*';
+    defaults.AddLambdaTarget(stack, 'test-lambda-target', testListener, testFunction, undefined, { targetGroupName });
+    // This is the code we're testing
+    const ruleProps = {
+        conditions: [elb.ListenerCondition.pathPatterns([pathPattern])],
         priority: 10
-    });
+    };
+    defaults.AddLambdaTarget(stack, 'test-second-lambda-target', testListener, testFunction, ruleProps, { targetGroupName });
+    expect(stack).toCountResources('AWS::ElasticLoadBalancingV2::TargetGroup', 2);
     expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::ListenerRule', {
-        Actions: [
-            {
-                TargetGroupArn: {
-                    Ref: "secondtargettg0CE37E1F"
-                },
-                Type: "forward"
-            }
-        ],
         Conditions: [
             {
                 Field: "path-pattern",
                 PathPatternConfig: {
                     Values: [
-                        "*admin*"
+                        pathPattern
                     ]
                 }
             }
         ]
     });
 });
-test('Test AddListener with defaults', () => {
+test('Test adding a listener with defaults', () => {
     const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
-    });
-    const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
-        targetGroupName: 'test-target-group'
-    });
-    // Build VPC
-    const vpc = defaults.buildVpc(stack, {
-        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
-    });
-    const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {
-        vpc,
-        internetFacing: true,
-        loadBalancerName: 'unique-name'
-    });
-    const cert = acm.Certificate.fromCertificateArn(stack, 'not-really-a-cert', "arn:aws:acm:us-east-1:123456789012:certificate/85c52dc8-1b37-4afd-a7aa-f03aac2db0cc");
-    defaults.AddListener(stack, existingLoadBalancer, targetGroup, {
-        certificates: [cert],
-    });
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const testCert = GetCert(stack);
+    const listener = defaults.AddListener(stack, testAlb, { certificates: [testCert] });
+    //  Need to add a target because a listener is not allowed to exist without a target or action
+    defaults.AddLambdaTarget(stack, 'dummy-target', listener, CreateTestFunction(stack, 'dummy-function'));
     // This should create 2 listeners, HTTPS plus redirect of HTTP
     expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
         Protocol: 'HTTPS',
@@ -212,110 +203,76 @@ test('Test AddListener with defaults', () => {
         Protocol: 'HTTP',
     });
 });
-test('Test AddListener with no cert for an HTTPS listener', () => {
+test('Test adding an HTTPS listener with no cert (error)', () => {
     const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
-    });
-    const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
-        targetGroupName: 'test-target-group'
-    });
-    // Build VPC
-    const vpc = defaults.buildVpc(stack, {
-        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
-    });
-    const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {
-        vpc,
-        internetFacing: true,
-        loadBalancerName: 'unique-name'
-    });
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
     const app = () => {
-        defaults.AddListener(stack, existingLoadBalancer, targetGroup, {});
+        defaults.AddListener(stack, testAlb, {});
     };
-    expect(app).toThrowError();
+    expect(app).toThrowError('A listener using HTTPS protocol requires a certificate');
 });
-test('Test AddListener error for HTTP with a cert', () => {
+test('Test adding an HTTP listener with a cert (error)', () => {
     const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
-    });
-    const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
-        targetGroupName: 'test-target-group'
-    });
-    // Build VPC
-    const vpc = defaults.buildVpc(stack, {
-        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
-    });
-    const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {
-        vpc,
-        internetFacing: true,
-        loadBalancerName: 'unique-name'
-    });
-    const cert = acm.Certificate.fromCertificateArn(stack, 'not-really-a-cert', "arn:aws:acm:us-east-1:123456789012:certificate/85c52dc8-1b37-4afd-a7aa-f03aac2db0cc");
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const testCert = GetCert(stack);
     const app = () => {
-        defaults.AddListener(stack, existingLoadBalancer, targetGroup, {
-            certificates: [cert],
-            protocol: elb.ApplicationProtocol.HTTP,
-        });
+        defaults.AddListener(stack, testAlb, { protocol: 'HTTP', certificates: [testCert] });
     };
-    expect(app).toThrowError();
+    expect(app).toThrowError('HTTP listeners cannot use a certificate');
 });
-test('Test AddListener for HTTP Listener', () => {
+test('Test adding a HTTP listener', () => {
     const stack = new aws_cdk_lib_1.Stack();
-    const testFunction = new lambda.Function(stack, 'test-function', {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
-        runtime: lambda.Runtime.NODEJS_14_X,
-        handler: "index.handler",
-    });
-    const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
-        targetGroupName: 'test-target-group'
-    });
-    // Build VPC
-    const vpc = defaults.buildVpc(stack, {
-        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
-    });
-    const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {
-        vpc,
-        internetFacing: true,
-        loadBalancerName: 'unique-name'
-    });
-    defaults.AddListener(stack, existingLoadBalancer, targetGroup, {
-        protocol: elb.ApplicationProtocol.HTTP,
-    });
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const listener = defaults.AddListener(stack, testAlb, { protocol: 'HTTP' });
+    //  Need to add a target because a listener is not allowed to exist without a target or action
+    defaults.AddLambdaTarget(stack, 'dummy-target', listener, CreateTestFunction(stack, 'dummy-function'));
     expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
         Protocol: 'HTTP',
     });
-    expect(stack).not.toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
-        Protocol: 'HTTPS',
-    });
+    expect(stack).toCountResources('AWS::ElasticLoadBalancingV2::Listener', 1);
 });
-test('Test with custom logging bucket props', () => {
-    // Creating ALB logging requires a region and account (but
-    // these can be fake in unit tests)
-    const stack = new aws_cdk_lib_1.Stack(undefined, undefined, {
-        env: { account: "123456789012", region: 'us-east-1' },
-    });
-    // Build VPC
-    const vpc = defaults.buildVpc(stack, {
-        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
-    });
-    const testName = 'test-name';
-    defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, true, { bucketName: testName });
-    expect(stack).toHaveResourceLike('AWS::S3::Bucket', {
-        BucketName: testName
-    });
+test('Test sending custom logging bucket props', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const listener = defaults.AddListener(stack, testAlb, { protocol: 'HTTP' });
+    //  Need to add a target because a listener is not allowed to exist without a target or action
+    defaults.AddLambdaTarget(stack, 'dummy-target', listener, CreateTestFunction(stack, 'dummy-function'));
 });
-test('Test with no logging', () => {
+test('Test GetActiveListener with 0 listeners', () => {
     const stack = new aws_cdk_lib_1.Stack();
-    // Build VPC
-    const vpc = defaults.buildVpc(stack, {
-        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
-    });
-    defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, false);
-    expect(stack).not.toHaveResourceLike('AWS::S3::Bucket', {});
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const app = () => {
+        defaults.GetActiveListener(testAlb.listeners);
+    };
+    expect(app).toThrowError('There are no listeners in the ALB');
+});
+test('Test GetActiveListener with 1 listener', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    defaults.AddListener(stack, testAlb, { protocol: 'HTTP' });
+    const listener = defaults.GetActiveListener(testAlb.listeners);
+    expect(listener.node.defaultChild.protocol).toBe('HTTP');
+});
+test('Test GetActiveListener with 2 listeners', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    // Set up test framework independent of our code for unit testing
+    const testVpc = CreateTestVpc(stack);
+    const testAlb = CreateTestLoadBalancer(stack, testVpc);
+    const testCert = GetCert(stack);
+    defaults.AddListener(stack, testAlb, { certificates: [testCert] });
+    const listener = defaults.GetActiveListener(testAlb.listeners);
+    expect(listener.node.defaultChild.protocol).toBe('HTTPS');
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alb-helper.test.js","sourceRoot":"","sources":["alb-helper.test.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { Stack } from 'aws-cdk-lib';\nimport * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport * as acm from \"aws-cdk-lib/aws-certificatemanager\";\nimport * as lambda from \"aws-cdk-lib/aws-lambda\";\nimport * as defaults from '../index';\nimport '@aws-cdk/assert/jest';\n\ntest('Test ObtainAlb with existing ALB', () => {\n  const stack = new Stack();\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, true, existingLoadBalancer);\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {\n    Name: \"unique-name\",\n  });\n});\n\ntest('Test ObtainAlb for new ALB with provided props', () => {\n  const stack = new Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, true, undefined, {\n    loadBalancerName: 'new-loadbalancer',\n    vpc,\n    internetFacing: true\n  });\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {\n    Name: \"new-loadbalancer\",\n    Scheme: \"internet-facing\",\n  });\n});\n\ntest('Test ObtainAlb for new ALB with default props', () => {\n  const stack = new Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, false);\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {\n    Scheme: \"internal\",\n  });\n});\n\ntest('Test ObtainAlb for new ALB with default props', () => {\n  const stack = new Stack();\n\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction);\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {\n    TargetType: \"lambda\"\n  });\n});\n\ntest('Test ObtainAlb for new ALB with custom props', () => {\n  const stack = new Stack();\n\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {\n    targetGroupName: 'test-target-group'\n  });\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {\n    TargetType: \"lambda\",\n    Name: 'test-target-group'\n  });\n});\n\ntest('Test Add Target without ruleProps', () => {\n  const stack = new Stack();\n\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {\n    targetGroupName: 'test-target-group'\n  });\n\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  const testListener = new elb.ApplicationListener(stack, 'test-listener', {\n    loadBalancer: existingLoadBalancer,\n    protocol: elb.ApplicationProtocol.HTTP\n  });\n\n  defaults.AddTarget(stack, targetGroup, testListener);\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    DefaultActions: [\n      {\n        TargetGroupArn: {\n          Ref: \"testtargettgB2EE41CA\"\n        },\n        Type: \"forward\"\n      }\n    ],\n  });\n});\n\ntest('Test Add Target with ruleProps', () => {\n  const stack = new Stack();\n\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {\n    targetGroupName: 'test-target-group'\n  });\n\n  const secondTargetGroup = defaults.CreateLambdaTargetGroup(stack, 'second-target', testFunction, {\n    targetGroupName: 'second-target-group'\n  });\n\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  const testListener = new elb.ApplicationListener(stack, 'test-listener', {\n    loadBalancer: existingLoadBalancer,\n    protocol: elb.ApplicationProtocol.HTTP\n  });\n\n  // The first target is default and can't have rules, so\n  // we need to add 2 targets\n  defaults.AddTarget(stack, targetGroup, testListener);\n  defaults.AddTarget(stack, secondTargetGroup, testListener, {\n    conditions: [elb.ListenerCondition.pathPatterns([\"*admin*\"])],\n    priority: 10\n  });\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::ListenerRule', {\n    Actions: [\n      {\n        TargetGroupArn: {\n          Ref: \"secondtargettg0CE37E1F\"\n        },\n        Type: \"forward\"\n      }\n    ],\n    Conditions: [\n      {\n        Field: \"path-pattern\",\n        PathPatternConfig: {\n          Values: [\n            \"*admin*\"\n          ]\n        }\n      }\n    ]\n  });\n});\n\ntest('Test AddListener with defaults', () => {\n  const stack = new Stack();\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {\n    targetGroupName: 'test-target-group'\n  });\n\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  const cert = acm.Certificate.fromCertificateArn(\n    stack,\n    'not-really-a-cert',\n    \"arn:aws:acm:us-east-1:123456789012:certificate/85c52dc8-1b37-4afd-a7aa-f03aac2db0cc\"\n  );\n\n  defaults.AddListener(stack, existingLoadBalancer, targetGroup, {\n    certificates: [ cert ],\n  });\n\n  // This should create 2 listeners, HTTPS plus redirect of HTTP\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    Protocol: 'HTTPS',\n  });\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    Protocol: 'HTTP',\n  });\n});\n\ntest('Test AddListener with no cert for an HTTPS listener', () => {\n  const stack = new Stack();\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {\n    targetGroupName: 'test-target-group'\n  });\n\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  const app = () => {\n    defaults.AddListener(stack, existingLoadBalancer, targetGroup, {});\n  };\n  expect(app).toThrowError();\n});\n\ntest('Test AddListener error for HTTP with a cert', () => {\n  const stack = new Stack();\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {\n    targetGroupName: 'test-target-group'\n  });\n\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  const cert = acm.Certificate.fromCertificateArn(\n    stack,\n    'not-really-a-cert',\n    \"arn:aws:acm:us-east-1:123456789012:certificate/85c52dc8-1b37-4afd-a7aa-f03aac2db0cc\"\n  );\n\n  const app = () => {\n    defaults.AddListener(stack, existingLoadBalancer, targetGroup, {\n      certificates: [ cert ],\n      protocol: elb.ApplicationProtocol.HTTP,\n    });\n  };\n  expect(app).toThrowError();\n\n});\n\ntest('Test AddListener for HTTP Listener', () => {\n  const stack = new Stack();\n  const testFunction = new lambda.Function(stack, 'test-function', {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n\n  const targetGroup = defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {\n    targetGroupName: 'test-target-group'\n  });\n\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  defaults.AddListener(stack, existingLoadBalancer, targetGroup, {\n    protocol: elb.ApplicationProtocol.HTTP,\n  });\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    Protocol: 'HTTP',\n  });\n  expect(stack).not.toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    Protocol: 'HTTPS',\n  });\n});\n\ntest('Test with custom logging bucket props', () => {\n  // Creating ALB logging requires a region and account (but\n  // these can be fake in unit tests)\n  const stack = new Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const testName = 'test-name';\n\n  defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, true, { bucketName: testName });\n  expect(stack).toHaveResourceLike('AWS::S3::Bucket', {\n    BucketName: testName\n  });\n});\n\ntest('Test with no logging', () => {\n  const stack = new Stack();\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, false);\n  expect(stack).not.toHaveResourceLike('AWS::S3::Bucket', {});\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alb-helper.test.js","sourceRoot":"","sources":["alb-helper.test.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { Stack } from 'aws-cdk-lib';\nimport * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport * as acm from \"aws-cdk-lib/aws-certificatemanager\";\nimport * as lambda from \"aws-cdk-lib/aws-lambda\";\nimport * as defaults from '../index';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport '@aws-cdk/assert/jest';\n\ntest('Test ObtainAlb with existing ALB', () => {\n  const stack = new Stack();\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const existingLoadBalancer = new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, true, existingLoadBalancer);\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {\n    Name: \"unique-name\",\n  });\n});\n\ntest('Test ObtainAlb for new ALB with provided props', () => {\n  const stack = new Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, true, undefined, {\n    loadBalancerName: 'new-loadbalancer',\n    vpc,\n    internetFacing: true\n  });\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {\n    Name: \"new-loadbalancer\",\n    Scheme: \"internet-facing\",\n  });\n});\n\ntest('Test ObtainAlb for new ALB with default props', () => {\n  const stack = new Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, false);\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {\n    Scheme: \"internal\",\n  });\n});\n\ntest('Test with custom logging bucket props', () => {\n  // Creating ALB logging requires a region and account (but\n  // these can be fake in unit tests)\n  const stack = new Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  const testName = 'test-name';\n\n  defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, true, { bucketName: testName });\n  expect(stack).toHaveResourceLike('AWS::S3::Bucket', {\n    BucketName: testName\n  });\n});\n\ntest('Test with no logging', () => {\n  const stack = new Stack();\n  // Build VPC\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n\n  defaults.ObtainAlb(stack, 'test', vpc, false, undefined, undefined, false);\n  expect(stack).not.toHaveResourceLike('AWS::S3::Bucket', {});\n});\n\nfunction CreateTestVpc(stack: Stack) {\n  return defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n  });\n}\n\nfunction CreateTestLoadBalancer(stack: Stack, vpc: ec2.IVpc): elb.ApplicationLoadBalancer {\n  return new elb.ApplicationLoadBalancer(stack, 'load-balancer', {\n    vpc,\n    internetFacing: true,\n    loadBalancerName: 'unique-name'\n  });\n}\n\nfunction GetCert(stack: Stack): acm.ICertificate {\n  return acm.Certificate.fromCertificateArn(\n    stack,\n    'not-really-a-cert',\n    \"arn:aws:acm:us-east-1:123456789012:certificate/85c52dc8-1b37-4afd-a7aa-f03aac2db0cc\"\n  );\n}\n\nfunction CreateTestFunction(stack: Stack, id: string): lambda.Function {\n  return new lambda.Function(stack, id, {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: \"index.handler\",\n  });\n}\n\nfunction CreateTestListener(stack: Stack, id: string, alb: elb.ApplicationLoadBalancer) {\n  return new elb.ApplicationListener(stack, id, {\n    loadBalancer: alb,\n    protocol: elb.ApplicationProtocol.HTTP\n  });\n}\n\ntest('Test add single lambda target group with no customization', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testFunction = CreateTestFunction(stack, 'test-function');\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n  const testListener = CreateTestListener(stack, 'test-listener', testAlb);\n\n  // This is the code we're testing\n  defaults.AddLambdaTarget(\n    stack,\n    'test-lambda-target',\n    testListener,\n    testFunction,\n  );\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    DefaultActions: [\n      {\n        TargetGroupArn: {\n          Ref: \"testlambdatargettg7E5C32F4\"\n        },\n        Type: \"forward\"\n      }\n    ],\n  });\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {\n    TargetType: \"lambda\",\n  });\n\n});\n\ntest('Test add single lambda target group with target group props', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testFunction = CreateTestFunction(stack, 'test-function');\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n  const testListener = CreateTestListener(stack, 'test-listener', testAlb);\n  const targetGroupName = 'test-group';\n\n  // This is the code we're testing\n  defaults.AddLambdaTarget(\n    stack,\n    'test-lambda-target',\n    testListener,\n    testFunction,\n    undefined,\n    { targetGroupName },\n  );\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {\n    TargetType: \"lambda\",\n    Name: targetGroupName,\n  });\n\n});\n\ntest('Test add rule props for second lambda target group', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testFunction = CreateTestFunction(stack, 'test-function');\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n  const testListener = CreateTestListener(stack, 'test-listener', testAlb);\n  const targetGroupName = 'test-group';\n  const pathPattern = '*admin*';\n\n  defaults.AddLambdaTarget(\n    stack,\n    'test-lambda-target',\n    testListener,\n    testFunction,\n    undefined,\n    { targetGroupName },\n  );\n\n  // This is the code we're testing\n  const ruleProps = {\n    conditions: [elb.ListenerCondition.pathPatterns([pathPattern])],\n    priority: 10\n  };\n  defaults.AddLambdaTarget(\n    stack,\n    'test-second-lambda-target',\n    testListener,\n    testFunction,\n    ruleProps,\n    { targetGroupName },\n  );\n\n  expect(stack).toCountResources('AWS::ElasticLoadBalancingV2::TargetGroup', 2);\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::ListenerRule', {\n    Conditions: [\n      {\n        Field: \"path-pattern\",\n        PathPatternConfig: {\n          Values: [\n            pathPattern\n          ]\n        }\n      }\n    ]\n  });\n\n});\n\ntest('Test adding a listener with defaults', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n  const testCert = GetCert(stack);\n\n  const listener = defaults.AddListener(stack, testAlb, { certificates: [ testCert ] });\n\n  //  Need to add a target because a listener is not allowed to exist without a target or action\n  defaults.AddLambdaTarget(stack, 'dummy-target', listener, CreateTestFunction(stack, 'dummy-function'));\n\n  // This should create 2 listeners, HTTPS plus redirect of HTTP\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    Protocol: 'HTTPS',\n  });\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    Protocol: 'HTTP',\n  });\n});\n\ntest('Test adding an HTTPS listener with no cert (error)', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n\n  const app = () => {\n    defaults.AddListener(stack, testAlb, { });\n  };\n\n  expect(app).toThrowError('A listener using HTTPS protocol requires a certificate');\n});\n\ntest('Test adding an HTTP listener with a cert (error)', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n  const testCert = GetCert(stack);\n\n  const app = () => {\n    defaults.AddListener(stack, testAlb, { protocol: 'HTTP', certificates: [ testCert ] });\n  };\n\n  expect(app).toThrowError('HTTP listeners cannot use a certificate');\n});\n\ntest('Test adding a HTTP listener', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n\n  const listener = defaults.AddListener(stack, testAlb, { protocol: 'HTTP' });\n\n  //  Need to add a target because a listener is not allowed to exist without a target or action\n  defaults.AddLambdaTarget(stack, 'dummy-target', listener, CreateTestFunction(stack, 'dummy-function'));\n\n  expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {\n    Protocol: 'HTTP',\n  });\n  expect(stack).toCountResources('AWS::ElasticLoadBalancingV2::Listener', 1);\n});\n\ntest('Test sending custom logging bucket props', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n\n  const listener = defaults.AddListener(stack, testAlb, { protocol: 'HTTP' });\n\n  //  Need to add a target because a listener is not allowed to exist without a target or action\n  defaults.AddLambdaTarget(stack, 'dummy-target', listener, CreateTestFunction(stack, 'dummy-function'));\n\n});\n\ntest('Test GetActiveListener with 0 listeners', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n\n  const app = () => {\n    defaults.GetActiveListener(testAlb.listeners);\n  };\n\n  expect(app).toThrowError('There are no listeners in the ALB');\n\n});\n\ntest('Test GetActiveListener with 1 listener', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n\n  defaults.AddListener(stack, testAlb, { protocol: 'HTTP' });\n  const listener = defaults.GetActiveListener(testAlb.listeners);\n\n  expect((listener.node.defaultChild as elb.CfnListener).protocol).toBe('HTTP');\n\n});\n\ntest('Test GetActiveListener with 2 listeners', () => {\n  const stack = new Stack();\n\n  // Set up test framework independent of our code for unit testing\n  const testVpc = CreateTestVpc(stack);\n  const testAlb = CreateTestLoadBalancer(stack, testVpc);\n  const testCert = GetCert(stack);\n\n  defaults.AddListener(stack, testAlb, { certificates: [ testCert ] });\n  const listener = defaults.GetActiveListener(testAlb.listeners);\n\n  expect((listener.node.defaultChild as elb.CfnListener).protocol).toBe('HTTPS');\n\n});\n"]}