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

package/node_modules/wide-align/node_modules/strip-ansi/package.json

@@ -1,52 +1,54 @@
 {
-  "name": "strip-ansi",
-  "version": "4.0.0",
-  "description": "Strip ANSI escape codes",
-  "license": "MIT",
-  "repository": "chalk/strip-ansi",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "sindresorhus.com"
-  },
-  "engines": {
-    "node": ">=4"
-  },
-  "scripts": {
-    "test": "xo && ava"
-  },
-  "files": [
-    "index.js"
-  ],
-  "keywords": [
-    "strip",
-    "trim",
-    "remove",
-    "ansi",
-    "styles",
-    "color",
-    "colour",
-    "colors",
-    "terminal",
-    "console",
-    "string",
-    "tty",
-    "escape",
-    "formatting",
-    "rgb",
-    "256",
-    "shell",
-    "xterm",
-    "log",
-    "logging",
-    "command-line",
-    "text"
-  ],
-  "dependencies": {
-    "ansi-regex": "^3.0.0"
-  },
-  "devDependencies": {
-    "ava": "*",
-    "xo": "*"
-  }
+	"name": "strip-ansi",
+	"version": "6.0.1",
+	"description": "Strip ANSI escape codes from a string",
+	"license": "MIT",
+	"repository": "chalk/strip-ansi",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"strip",
+		"trim",
+		"remove",
+		"ansi",
+		"styles",
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"string",
+		"tty",
+		"escape",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text"
+	],
+	"dependencies": {
+		"ansi-regex": "^5.0.1"
+	},
+	"devDependencies": {
+		"ava": "^2.4.0",
+		"tsd": "^0.10.0",
+		"xo": "^0.25.3"
+	}
 }

package/node_modules/wide-align/node_modules/strip-ansi/readme.md

@@ -1,6 +1,6 @@
 # strip-ansi [![Build Status](https://travis-ci.org/chalk/strip-ansi.svg?branch=master)](https://travis-ci.org/chalk/strip-ansi)
 
-> Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code)
+> Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string
 
 
 ## Install
@@ -17,12 +17,23 @@ const stripAnsi = require('strip-ansi');
 
 stripAnsi('\u001B[4mUnicorn\u001B[0m');
 //=> 'Unicorn'
+
+stripAnsi('\u001B]8;;https://github.com\u0007Click\u001B]8;;\u0007');
+//=> 'Click'
 ```
 
 
+## strip-ansi for enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of strip-ansi and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-strip-ansi?utm_source=npm-strip-ansi&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+
+
 ## Related
 
 - [strip-ansi-cli](https://github.com/chalk/strip-ansi-cli) - CLI for this module
+- [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Streaming version of this module
 - [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
 - [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
 - [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
@@ -33,7 +44,3 @@ stripAnsi('\u001B[4mUnicorn\u001B[0m');
 - [Sindre Sorhus](https://github.com/sindresorhus)
 - [Josh Junon](https://github.com/qix-)
 
-
-## License
-
-MIT

package/node_modules/wide-align/package.json

@@ -1,11 +1,10 @@
 {
   "name": "wide-align",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "A wide-character aware text alignment function for use on the console or with fixed width fonts.",
   "main": "align.js",
   "scripts": {
-    "test": "tap --coverage test/*.js",
-    "version": "perl -pi -e 's/^(  \"version\": $ENV{npm_config_node_version}\").*?\",/$1abc\",/' package-lock.json ; git add package-lock.json"
+    "test": "tap --coverage test/*.js"
   },
   "keywords": [
     "wide",
@@ -21,11 +20,12 @@
     "type": "git",
     "url": "https://github.com/iarna/wide-align"
   },
+  "//": "But not version 5 of string-width, as that's ESM only",
   "dependencies": {
-    "string-width": "^1.0.2 || 2"
+    "string-width": "^1.0.2 || 2 || 3 || 4"
   },
   "devDependencies": {
-    "tap": "10 || 11 || 12"
+    "tap": "*"
   },
   "files": [
     "align.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-solutions-constructs/core",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.2",
   "description": "Core CDK Construct for patterns library",
   "main": "index.js",
   "types": "index.ts",

package/test/alb-helper.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import '@aws-cdk/assert/jest';

package/test/alb-helper.test.js

@@ -0,0 +1,321 @@
+"use strict";
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const elb = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const acm = require("aws-cdk-lib/aws-certificatemanager");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const defaults = require("../index");
+require("@aws-cdk/assert/jest");
+test('Test ObtainAlb with existing ALB', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    // 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.ObtainAlb(stack, 'test', vpc, true, existingLoadBalancer);
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {
+        Name: "unique-name",
+    });
+});
+test('Test ObtainAlb for new ALB with provided props', () => {
+    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(),
+    });
+    defaults.ObtainAlb(stack, 'test', vpc, true, undefined, {
+        loadBalancerName: 'new-loadbalancer',
+        vpc,
+        internetFacing: true
+    });
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {
+        Name: "new-loadbalancer",
+        Scheme: "internet-facing",
+    });
+});
+test('Test ObtainAlb for new ALB with default props', () => {
+    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(),
+    });
+    defaults.ObtainAlb(stack, 'test', vpc, false);
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::LoadBalancer', {
+        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",
+    });
+    defaults.CreateLambdaTargetGroup(stack, 'test-target', testFunction, {
+        targetGroupName: 'test-target-group'
+    });
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::TargetGroup', {
+        TargetType: "lambda",
+        Name: 'test-target-group'
+    });
+});
+test('Test Add Target without ruleProps', () => {
+    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 testListener = new elb.ApplicationListener(stack, 'test-listener', {
+        loadBalancer: existingLoadBalancer,
+        protocol: elb.ApplicationProtocol.HTTP
+    });
+    defaults.AddTarget(stack, targetGroup, testListener);
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
+        DefaultActions: [
+            {
+                TargetGroupArn: {
+                    Ref: "testtargettgB2EE41CA"
+                },
+                Type: "forward"
+            }
+        ],
+    });
+});
+test('Test Add Target with ruleProps', () => {
+    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
+    });
+    // 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*"])],
+        priority: 10
+    });
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::ListenerRule', {
+        Actions: [
+            {
+                TargetGroupArn: {
+                    Ref: "secondtargettg0CE37E1F"
+                },
+                Type: "forward"
+            }
+        ],
+        Conditions: [
+            {
+                Field: "path-pattern",
+                PathPatternConfig: {
+                    Values: [
+                        "*admin*"
+                    ]
+                }
+            }
+        ]
+    });
+});
+test('Test AddListener 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],
+    });
+    // This should create 2 listeners, HTTPS plus redirect of HTTP
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
+        Protocol: 'HTTPS',
+    });
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
+        Protocol: 'HTTP',
+    });
+});
+test('Test AddListener with no cert for an HTTPS 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'
+    });
+    const app = () => {
+        defaults.AddListener(stack, existingLoadBalancer, targetGroup, {});
+    };
+    expect(app).toThrowError();
+});
+test('Test AddListener error for HTTP with a cert', () => {
+    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");
+    const app = () => {
+        defaults.AddListener(stack, existingLoadBalancer, targetGroup, {
+            certificates: [cert],
+            protocol: elb.ApplicationProtocol.HTTP,
+        });
+    };
+    expect(app).toThrowError();
+});
+test('Test AddListener for 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,
+    });
+    expect(stack).toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
+        Protocol: 'HTTP',
+    });
+    expect(stack).not.toHaveResourceLike('AWS::ElasticLoadBalancingV2::Listener', {
+        Protocol: 'HTTPS',
+    });
+});
+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 with no logging', () => {
+    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', {});
+});
+//# 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"]}