@aws-solutions-constructs/aws-cloudfront-apigateway-lambda 2.99.0 → 2.100.1

package/test/cloudfront-apigateway-lambda.test.js

@@ -0,0 +1,399 @@
+"use strict";
+/**
+ *  Copyright 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 lib_1 = require("../lib");
+const cdk = require("aws-cdk-lib");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const api = require("aws-cdk-lib/aws-apigateway");
+const s3 = require("aws-cdk-lib/aws-s3");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const defaults = require("@aws-solutions-constructs/core");
+function deployNewFunc(stack) {
+    const lambdaFunctionProps = {
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler'
+    };
+    return new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } },
+        lambdaFunctionProps
+    });
+}
+function useExistingFunc(stack) {
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    return new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } },
+        existingLambdaObj: new lambda.Function(stack, 'MyExistingFunction', lambdaFunctionProps)
+    });
+}
+test('check properties', () => {
+    const stack = new cdk.Stack();
+    const construct = deployNewFunc(stack);
+    expect(construct.cloudFrontWebDistribution).toBeDefined();
+    expect(construct.apiGateway).toBeDefined();
+    expect(construct.lambdaFunction).toBeDefined();
+    expect(construct.cloudFrontFunction).toBeDefined();
+    expect(construct.cloudFrontLoggingBucket).toBeDefined();
+    expect(construct.apiGatewayCloudWatchRole).toBeDefined();
+    expect(construct.apiGatewayLogGroup).toBeDefined();
+});
+test('check lambda function properties for deploy: true', () => {
+    const stack = new cdk.Stack();
+    deployNewFunc(stack);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Lambda::Function', {
+        Handler: "index.handler",
+        Role: {
+            "Fn::GetAtt": [
+                "testcloudfrontapigatewaylambdaLambdaFunctionServiceRoleCB74590F",
+                "Arn"
+            ]
+        },
+        Runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_STRING,
+        Environment: {
+            Variables: {
+                AWS_NODEJS_CONNECTION_REUSE_ENABLED: "1"
+            }
+        }
+    });
+    template.resourceCountIs('AWS::ApiGateway::UsagePlan', 1);
+});
+test('check lambda function role for deploy: false', () => {
+    const stack = new cdk.Stack();
+    useExistingFunc(stack);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::IAM::Role', {
+        AssumeRolePolicyDocument: {
+            Statement: [
+                {
+                    Action: "sts:AssumeRole",
+                    Effect: "Allow",
+                    Principal: {
+                        Service: "lambda.amazonaws.com"
+                    }
+                }
+            ],
+            Version: "2012-10-17"
+        },
+        ManagedPolicyArns: [
+            {
+                "Fn::Join": [
+                    "",
+                    [
+                        "arn:",
+                        {
+                            Ref: "AWS::Partition"
+                        },
+                        ":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+                    ]
+                ]
+            }
+        ]
+    });
+});
+test('check exception for Missing existingObj from props', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } },
+    };
+    try {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(Error);
+    }
+});
+test('check no prop', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } },
+    };
+    try {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(Error);
+    }
+});
+test('override api gateway properties with existingLambdaObj', () => {
+    const stack = new cdk.Stack();
+    const lambdaFunctionProps = {
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler'
+    };
+    const fn = new lambda.Function(stack, 'MyExistingFunction', lambdaFunctionProps);
+    new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {
+        existingLambdaObj: fn,
+        apiGatewayProps: {
+            defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE },
+            description: "Override description"
+        }
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::RestApi', {
+        Description: "Override description",
+        EndpointConfiguration: {
+            Types: [
+                "REGIONAL"
+            ]
+        },
+        Name: "LambdaRestApi"
+    });
+});
+test('override api gateway properties without existingLambdaObj', () => {
+    const stack = new cdk.Stack();
+    new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {
+        lambdaFunctionProps: {
+            code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+            runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+            handler: 'index.handler'
+        },
+        apiGatewayProps: {
+            defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE },
+            endpointConfiguration: {
+                types: [api.EndpointType.PRIVATE],
+            },
+            description: "Override description"
+        }
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::RestApi', {
+        Description: "Override description",
+        EndpointConfiguration: {
+            Types: [
+                "PRIVATE"
+            ]
+        },
+        Name: "LambdaRestApi"
+    });
+});
+test('Cloudfront logging bucket with destroy removal policy and auto delete objects', () => {
+    const stack = new cdk.Stack();
+    new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {
+        lambdaFunctionProps: {
+            code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+            runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+            handler: 'index.handler'
+        },
+        apiGatewayProps: {
+            defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE },
+            endpointConfiguration: {
+                types: [api.EndpointType.PRIVATE],
+            }
+        },
+        cloudFrontLoggingBucketProps: {
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+            autoDeleteObjects: true
+        }
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties("AWS::S3::Bucket", {
+        OwnershipControls: { Rules: [{ ObjectOwnership: "ObjectWriter" }] },
+    });
+    template.hasResourceProperties("Custom::S3AutoDeleteObjects", {
+        ServiceToken: {
+            "Fn::GetAtt": [
+                "CustomS3AutoDeleteObjectsCustomResourceProviderHandler9D90184F",
+                "Arn"
+            ]
+        },
+        BucketName: {
+            Ref: "testcloudfrontapigatewaylambdaCloudFrontToApiGatewayCloudfrontLoggingBucket7F467421"
+        }
+    });
+});
+test('Cloudfront logging bucket error when providing existing log bucket and logBucketProps', () => {
+    const stack = new cdk.Stack();
+    const logBucket = new s3.Bucket(stack, 'cloudfront-log-bucket', {});
+    const app = () => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'cloudfront-s3', {
+            lambdaFunctionProps: {
+                code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+                runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+                handler: 'index.handler'
+            },
+            apiGatewayProps: {
+                endpointConfiguration: {
+                    types: [api.EndpointType.PRIVATE],
+                }
+            },
+            cloudFrontLoggingBucketProps: {
+                removalPolicy: cdk.RemovalPolicy.DESTROY,
+                autoDeleteObjects: true
+            },
+            cloudFrontDistributionProps: {
+                logBucket
+            },
+        });
+    };
+    expect(app).toThrow();
+});
+test('Confirm CheckLambdaProps is being called', () => {
+    const stack = new cdk.Stack();
+    const existingLambdaObj = new lambda.Function(stack, 'ExistingLambda', {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+    });
+    const props = {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } },
+        existingLambdaObj,
+        lambdaFunctionProps: {
+            runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        }
+    };
+    const app = () => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'cf-test-apigateway-lambda', props);
+    };
+    expect(app).toThrow('Error - Either provide lambdaFunctionProps or existingLambdaObj, but not both.\n');
+});
+test("Confirm CheckCloudFrontProps is being called", () => {
+    const stack = new cdk.Stack();
+    expect(() => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, "test-cloudfront-apigateway-lambda", {
+            apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } },
+            lambdaFunctionProps: {
+                runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+                handler: 'index.handler',
+                code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+            },
+            insertHttpSecurityHeaders: true,
+            responseHeadersPolicyProps: {
+                securityHeadersBehavior: {
+                    strictTransportSecurity: {
+                        accessControlMaxAge: cdk.Duration.seconds(63072),
+                        includeSubdomains: true,
+                        override: false,
+                        preload: true
+                    }
+                }
+            }
+        });
+    }).toThrow('responseHeadersPolicyProps.securityHeadersBehavior can only be passed if httpSecurityHeaders is set to `false`.');
+});
+test('confirm error thrown for AWS_IAM authorization', () => {
+    const stack = new cdk.Stack();
+    const lambdaFunctionProps = {
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler'
+    };
+    const props = {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: 'AWS_IAM' } },
+        lambdaFunctionProps
+    };
+    const app = () => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-one', props);
+    };
+    expect(app).toThrow(/Amazon API Gateway Rest APIs integrated with Amazon CloudFront do not support AWS_IAM authorization/);
+});
+test('confirm error thrown for unspecified authorization', () => {
+    const stack = new cdk.Stack();
+    const lambdaFunctionProps = {
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler'
+    };
+    const props = {
+        apiGatewayProps: {},
+        lambdaFunctionProps
+    };
+    const app = () => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-one', props);
+    };
+    expect(app).toThrow(/As of v2.48.0, an explicit authorization type is required for CloudFront\/API Gateway patterns/);
+});
+test('Confirm call to CheckApiProps', () => {
+    // Initial Setup
+    const stack = new cdk.Stack();
+    const lambdaFunction = new lambda.Function(stack, 'a-function', {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+    });
+    const props = {
+        existingLambdaObj: lambdaFunction,
+        apiGatewayProps: {
+            defaultMethodOptions: {
+                authorizationType: 'AWS_NONE',
+                apiKeyRequired: true
+            },
+        },
+        createUsagePlan: false,
+    };
+    const app = () => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);
+    };
+    // Assertion
+    expect(app).toThrow('Error - if API key is required, then the Usage plan must be created\n');
+});
+test('Confirm suppression of Usage Plan', () => {
+    // Initial Setup
+    const stack = new cdk.Stack();
+    const props = {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: 'AWS_NONE' } },
+        lambdaFunctionProps: {
+            code: new lambda.InlineCode('exports.handler = async (event) => { console.log(event); return {\'statusCode\': 200, \'body\': \'\'}; }'),
+            runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+            handler: 'index.handler',
+        },
+        createUsagePlan: false
+    };
+    new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs('AWS::ApiGateway::UsagePlan', 0);
+});
+test('Test that ValidateLambdaRestApiProps() is being called', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        lambdaFunctionProps: {
+            code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+            runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+            handler: 'index.handler'
+        },
+        apiGatewayProps: {
+            invalidProperty: true
+        }
+    };
+    const app = () => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-construct', props);
+    };
+    expect(app).toThrow(/ERROR - invalidProperty is not a valid property of LambdaRestApiProps/);
+});
+test('Test that ValidateDistributionProps() is being called', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        apiGatewayProps: { defaultMethodOptions: { authorizationType: 'AWS_NONE' } },
+        lambdaFunctionProps: {
+            code: new lambda.InlineCode('exports.handler = async (event) => { console.log(event); return {\'statusCode\': 200, \'body\': \'\'}; }'),
+            runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+            handler: 'index.handler',
+        },
+        cloudFrontDistributionProps: {
+            invalidProperty: true
+        }
+    };
+    const app = () => {
+        new lib_1.CloudFrontToApiGatewayToLambda(stack, 'test-construct', props);
+    };
+    expect(app).toThrow(/ERROR - invalidProperty is not a valid property of DistributionProps/);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudfront-apigateway-lambda.test.js","sourceRoot":"","sources":["cloudfront-apigateway-lambda.test.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 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 { CloudFrontToApiGatewayToLambda, CloudFrontToApiGatewayToLambdaProps } from \"../lib\";\nimport * as cdk from \"aws-cdk-lib\";\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as api from 'aws-cdk-lib/aws-apigateway';\nimport * as s3 from \"aws-cdk-lib/aws-s3\";\nimport { Template } from 'aws-cdk-lib/assertions';\nimport * as defaults from '@aws-solutions-constructs/core';\n\nfunction deployNewFunc(stack: cdk.Stack) {\n  const lambdaFunctionProps: lambda.FunctionProps = {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n    handler: 'index.handler'\n  };\n\n  return new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE }},\n    lambdaFunctionProps\n  });\n}\n\nfunction useExistingFunc(stack: cdk.Stack) {\n  const lambdaFunctionProps: lambda.FunctionProps = {\n    runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n    handler: 'index.handler',\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`)\n  };\n\n  return new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE }},\n    existingLambdaObj: new lambda.Function(stack, 'MyExistingFunction', lambdaFunctionProps)\n  });\n}\n\ntest('check properties', () => {\n  const stack = new cdk.Stack();\n\n  const construct: CloudFrontToApiGatewayToLambda = deployNewFunc(stack);\n\n  expect(construct.cloudFrontWebDistribution).toBeDefined();\n  expect(construct.apiGateway).toBeDefined();\n  expect(construct.lambdaFunction).toBeDefined();\n  expect(construct.cloudFrontFunction).toBeDefined();\n  expect(construct.cloudFrontLoggingBucket).toBeDefined();\n  expect(construct.apiGatewayCloudWatchRole).toBeDefined();\n  expect(construct.apiGatewayLogGroup).toBeDefined();\n});\n\ntest('check lambda function properties for deploy: true', () => {\n  const stack = new cdk.Stack();\n\n  deployNewFunc(stack);\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::Lambda::Function', {\n    Handler: \"index.handler\",\n    Role: {\n      \"Fn::GetAtt\": [\n        \"testcloudfrontapigatewaylambdaLambdaFunctionServiceRoleCB74590F\",\n        \"Arn\"\n      ]\n    },\n    Runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_STRING,\n    Environment: {\n      Variables: {\n        AWS_NODEJS_CONNECTION_REUSE_ENABLED: \"1\"\n      }\n    }\n  });\n  template.resourceCountIs('AWS::ApiGateway::UsagePlan', 1);\n});\n\ntest('check lambda function role for deploy: false', () => {\n  const stack = new cdk.Stack();\n\n  useExistingFunc(stack);\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::IAM::Role', {\n    AssumeRolePolicyDocument: {\n      Statement: [\n        {\n          Action: \"sts:AssumeRole\",\n          Effect: \"Allow\",\n          Principal: {\n            Service: \"lambda.amazonaws.com\"\n          }\n        }\n      ],\n      Version: \"2012-10-17\"\n    },\n    ManagedPolicyArns: [\n      {\n        \"Fn::Join\": [\n          \"\",\n          [\n            \"arn:\",\n            {\n              Ref: \"AWS::Partition\"\n            },\n            \":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole\"\n          ]\n        ]\n      }\n    ]\n  });\n});\n\ntest('check exception for Missing existingObj from props', () => {\n  const stack = new cdk.Stack();\n\n  const props: CloudFrontToApiGatewayToLambdaProps = {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE }},\n  };\n\n  try {\n    new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);\n  } catch (e) {\n    expect(e).toBeInstanceOf(Error);\n  }\n});\n\ntest('check no prop', () => {\n  const stack = new cdk.Stack();\n\n  const props: CloudFrontToApiGatewayToLambdaProps = {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE }},\n  };\n\n  try {\n    new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);\n  } catch (e) {\n    expect(e).toBeInstanceOf(Error);\n  }\n});\n\ntest('override api gateway properties with existingLambdaObj', () => {\n  const stack = new cdk.Stack();\n\n  const lambdaFunctionProps: lambda.FunctionProps = {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n    handler: 'index.handler'\n  };\n\n  const fn: lambda.Function = new lambda.Function(stack, 'MyExistingFunction', lambdaFunctionProps);\n\n  new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {\n    existingLambdaObj: fn,\n    apiGatewayProps: {\n      defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE },\n      description: \"Override description\"\n    }\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::RestApi',\n    {\n      Description: \"Override description\",\n      EndpointConfiguration: {\n        Types: [\n          \"REGIONAL\"\n        ]\n      },\n      Name: \"LambdaRestApi\"\n    });\n});\n\ntest('override api gateway properties without existingLambdaObj', () => {\n  const stack = new cdk.Stack();\n\n  new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {\n    lambdaFunctionProps: {\n      code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n      runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n      handler: 'index.handler'\n    },\n    apiGatewayProps: {\n      defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE },\n      endpointConfiguration: {\n        types: [api.EndpointType.PRIVATE],\n      },\n      description: \"Override description\"\n    }\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::RestApi',\n    {\n      Description: \"Override description\",\n      EndpointConfiguration: {\n        Types: [\n          \"PRIVATE\"\n        ]\n      },\n      Name: \"LambdaRestApi\"\n    });\n});\n\ntest('Cloudfront logging bucket with destroy removal policy and auto delete objects', () => {\n  const stack = new cdk.Stack();\n\n  new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', {\n    lambdaFunctionProps: {\n      code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n      runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n      handler: 'index.handler'\n    },\n    apiGatewayProps: {\n      defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE },\n      endpointConfiguration: {\n        types: [api.EndpointType.PRIVATE],\n      }\n    },\n    cloudFrontLoggingBucketProps: {\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      autoDeleteObjects: true\n    }\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties(\"AWS::S3::Bucket\", {\n    OwnershipControls: { Rules: [ { ObjectOwnership: \"ObjectWriter\" } ] },\n  });\n\n  template.hasResourceProperties(\"Custom::S3AutoDeleteObjects\", {\n    ServiceToken: {\n      \"Fn::GetAtt\": [\n        \"CustomS3AutoDeleteObjectsCustomResourceProviderHandler9D90184F\",\n        \"Arn\"\n      ]\n    },\n    BucketName: {\n      Ref: \"testcloudfrontapigatewaylambdaCloudFrontToApiGatewayCloudfrontLoggingBucket7F467421\"\n    }\n  });\n});\n\ntest('Cloudfront logging bucket error when providing existing log bucket and logBucketProps', () => {\n  const stack = new cdk.Stack();\n  const logBucket = new s3.Bucket(stack, 'cloudfront-log-bucket', {});\n\n  const app = () => { new CloudFrontToApiGatewayToLambda(stack, 'cloudfront-s3', {\n    lambdaFunctionProps: {\n      code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n      runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n      handler: 'index.handler'\n    },\n    apiGatewayProps: {\n      endpointConfiguration: {\n        types: [api.EndpointType.PRIVATE],\n      }\n    },\n    cloudFrontLoggingBucketProps: {\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      autoDeleteObjects: true\n    },\n    cloudFrontDistributionProps: {\n      logBucket\n    },\n  });\n  };\n\n  expect(app).toThrow();\n});\n\ntest('Confirm CheckLambdaProps is being called', () => {\n  const stack = new cdk.Stack();\n  const existingLambdaObj = new lambda.Function(stack, 'ExistingLambda', {\n    runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n    handler: 'index.handler',\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n  });\n\n  const props: CloudFrontToApiGatewayToLambdaProps = {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE }},\n    existingLambdaObj,\n    lambdaFunctionProps: {\n      runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n      handler: 'index.handler',\n      code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    }\n  };\n\n  const app = () => {\n    new CloudFrontToApiGatewayToLambda(stack, 'cf-test-apigateway-lambda', props);\n  };\n  expect(app).toThrow('Error - Either provide lambdaFunctionProps or existingLambdaObj, but not both.\\n');\n});\n\ntest(\"Confirm CheckCloudFrontProps is being called\", () => {\n  const stack = new cdk.Stack();\n\n  expect(() => {\n    new CloudFrontToApiGatewayToLambda(stack, \"test-cloudfront-apigateway-lambda\", {\n      apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE }},\n      lambdaFunctionProps: {\n        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n        handler: 'index.handler',\n        code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n      },\n      insertHttpSecurityHeaders: true,\n      responseHeadersPolicyProps: {\n        securityHeadersBehavior: {\n          strictTransportSecurity: {\n            accessControlMaxAge: cdk.Duration.seconds(63072),\n            includeSubdomains: true,\n            override: false,\n            preload: true\n          }\n        }\n      }\n    });\n  }).toThrow('responseHeadersPolicyProps.securityHeadersBehavior can only be passed if httpSecurityHeaders is set to `false`.');\n});\n\ntest('confirm error thrown for AWS_IAM authorization', () => {\n  const stack = new cdk.Stack();\n  const lambdaFunctionProps: lambda.FunctionProps = {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n    handler: 'index.handler'\n  };\n\n  const props = {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: 'AWS_IAM' }},\n    lambdaFunctionProps\n  };\n\n  const app = () => {\n    new CloudFrontToApiGatewayToLambda(stack, 'test-one', props);\n  };\n  expect(app).toThrow(/Amazon API Gateway Rest APIs integrated with Amazon CloudFront do not support AWS_IAM authorization/);\n});\n\ntest('confirm error thrown for unspecified authorization', () => {\n  const stack = new cdk.Stack();\n  const lambdaFunctionProps: lambda.FunctionProps = {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n    handler: 'index.handler'\n  };\n\n  const props = {\n    apiGatewayProps: { },\n    lambdaFunctionProps\n  };\n\n  const app = () => {\n    new CloudFrontToApiGatewayToLambda(stack, 'test-one', props);\n  };\n  expect(app).toThrow(/As of v2.48.0, an explicit authorization type is required for CloudFront\\/API Gateway patterns/);\n});\n\ntest('Confirm call to CheckApiProps', () => {\n  // Initial Setup\n  const stack = new cdk.Stack();\n  const lambdaFunction = new lambda.Function(stack, 'a-function', {\n    runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n    handler: 'index.handler',\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n  });\n\n  const props: CloudFrontToApiGatewayToLambdaProps = {\n    existingLambdaObj: lambdaFunction,\n    apiGatewayProps: {\n      defaultMethodOptions: {\n        authorizationType: 'AWS_NONE',\n        apiKeyRequired: true\n      },\n    },\n    createUsagePlan: false,\n  };\n  const app = () => {\n    new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);\n  };\n  // Assertion\n  expect(app).toThrow('Error - if API key is required, then the Usage plan must be created\\n');\n});\n\ntest('Confirm suppression of Usage Plan', () => {\n  // Initial Setup\n  const stack = new cdk.Stack();\n  const props: CloudFrontToApiGatewayToLambdaProps = {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: 'AWS_NONE' }},\n    lambdaFunctionProps: {\n       code: new lambda.InlineCode('exports.handler = async (event) => { console.log(event); return {\\'statusCode\\': 200, \\'body\\': \\'\\'}; }'),\n       runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n       handler: 'index.handler',\n    },\n    createUsagePlan: false\n  };\n  new CloudFrontToApiGatewayToLambda(stack, 'test-cloudfront-apigateway-lambda', props);\n\n  const template = Template.fromStack(stack);\n  template.resourceCountIs('AWS::ApiGateway::UsagePlan', 0);\n});\n\ntest('Test that ValidateLambdaRestApiProps() is being called', () => {\n  const stack = new cdk.Stack();\n  const props: CloudFrontToApiGatewayToLambdaProps = {\n    lambdaFunctionProps: {\n      code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n      runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n      handler: 'index.handler'\n    },\n    apiGatewayProps: {\n      invalidProperty: true\n    }\n  };\n\n  const app = () => {\n    new CloudFrontToApiGatewayToLambda(stack, 'test-construct', props);\n  };\n\n  expect(app).toThrow(/ERROR - invalidProperty is not a valid property of LambdaRestApiProps/);\n});\n\ntest('Test that ValidateDistributionProps() is being called', () => {\n  const stack = new cdk.Stack();\n  const props: CloudFrontToApiGatewayToLambdaProps = {\n    apiGatewayProps: { defaultMethodOptions: { authorizationType: 'AWS_NONE' }},\n    lambdaFunctionProps: {\n       code: new lambda.InlineCode('exports.handler = async (event) => { console.log(event); return {\\'statusCode\\': 200, \\'body\\': \\'\\'}; }'),\n       runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,\n       handler: 'index.handler',\n    },\n    cloudFrontDistributionProps: {\n      invalidProperty: true\n    }\n  };\n\n  const app = () => {\n    new CloudFrontToApiGatewayToLambda(stack, 'test-construct', props);\n  };\n\n  expect(app).toThrow(/ERROR - invalidProperty is not a valid property of DistributionProps/);\n});\n"]}

package/test/integ.cftaplam-customCloudfrontLoggingBucket.js

@@ -33,7 +33,7 @@ new lib_1.CloudFrontToApiGatewayToLambda(stack, 'cf-apigw-lambda', {
         },
     },
     lambdaFunctionProps: {
-        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        code: new lambda.InlineCode('exports.handler = async (event) => { console.log(event); return {\'statusCode\': 200, \'body\': \'\'}; }'),
         runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
         handler: 'index.handler'
     },
@@ -49,4 +49,4 @@ new lib_1.CloudFrontToApiGatewayToLambda(stack, 'cf-apigw-lambda', {
 new integ_tests_alpha_1.IntegTest(stack, 'Integ', { testCases: [
         stack
     ] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/test/integ.cftaplam-customCloudfrontLoggingBucket.js.snapshot/cdk.out

@@ -1 +1 @@
-{"version":"48.0.0"}
+{"version":"50.0.0"}

package/test/integ.cftaplam-customCloudfrontLoggingBucket.js.snapshot/cftaplam-customCloudfrontLoggingBucket.assets.json

@@ -1,5 +1,5 @@
 {
-  "version": "48.0.0",
+  "version": "50.0.0",
   "files": {
     "0772ffe05bd3b2e012dc5086ab3b6dd03c8a0268fc1c81326f5e72b0a4c6b51e": {
       "displayName": "cftaplam-customCloudfrontLoggingBucket-authorizerAuthFunction/Code",
@@ -29,16 +29,16 @@
         }
       }
     },
-    "6c6309f3099f0198c3896bb74b614bf6ccb54a69ea6dd4d33505d8ba8cf2e575": {
+    "6722aea7e5c8787d7c6cece228dd0507a8fe853f48c62cd38b9fda81f880d5bf": {
       "displayName": "cftaplam-customCloudfrontLoggingBucket Template",
       "source": {
         "path": "cftaplam-customCloudfrontLoggingBucket.template.json",
         "packaging": "file"
       },
       "destinations": {
-        "current_account-current_region-fcc6f56f": {
+        "current_account-current_region-20f4e064": {
           "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
-          "objectKey": "6c6309f3099f0198c3896bb74b614bf6ccb54a69ea6dd4d33505d8ba8cf2e575.json",
+          "objectKey": "6722aea7e5c8787d7c6cece228dd0507a8fe853f48c62cd38b9fda81f880d5bf.json",
           "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
         }
       }

package/test/integ.cftaplam-customCloudfrontLoggingBucket.js.snapshot/cftaplam-customCloudfrontLoggingBucket.template.json

@@ -239,10 +239,7 @@
    "Type": "AWS::Lambda::Function",
    "Properties": {
     "Code": {
-     "S3Bucket": {
-      "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}"
-     },
-     "S3Key": "0772ffe05bd3b2e012dc5086ab3b6dd03c8a0268fc1c81326f5e72b0a4c6b51e.zip"
+     "ZipFile": "exports.handler = async (event) => { console.log(event); return {'statusCode': 200, 'body': ''}; }"
     },
     "Environment": {
      "Variables": {

package/test/integ.cftaplam-customCloudfrontLoggingBucket.js.snapshot/cftaplamcustomCloudfrontLoggingBucketIntegDefaultTestDeployAssert35A683E0.assets.json

@@ -1,5 +1,5 @@
 {
-  "version": "48.0.0",
+  "version": "50.0.0",
   "files": {
     "21fbb51d7b23f6a6c262b46a9caee79d744a3ac019fd45422d988b96d44b2a22": {
       "displayName": "cftaplamcustomCloudfrontLoggingBucketIntegDefaultTestDeployAssert35A683E0 Template",

package/test/integ.cftaplam-customCloudfrontLoggingBucket.js.snapshot/integ.json

@@ -1,5 +1,5 @@
 {
-  "version": "48.0.0",
+  "version": "50.0.0",
   "testCases": {
     "cftaplam-customCloudfrontLoggingBucket/Integ/DefaultTest": {
       "stacks": [
@@ -9,5 +9,5 @@
       "assertionStackName": "cftaplamcustomCloudfrontLoggingBucketIntegDefaultTestDeployAssert35A683E0"
     }
   },
-  "minimumCliVersion": "2.1029.2"
+  "minimumCliVersion": "2.1105.0"
 }