@gemeentenijmegen/webapp 1.1.13 → 1.1.14

package/node_modules/@aws-solutions-constructs/core/test/apigateway-helper.test.js

@@ -0,0 +1,819 @@
+"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 aws_cdk_lib_1 = require("aws-cdk-lib");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const api = require("aws-cdk-lib/aws-apigateway");
+const iam = require("aws-cdk-lib/aws-iam");
+const defaults = require("../index");
+const assertions_1 = require("aws-cdk-lib/assertions");
+function deployRegionalApiGateway(stack) {
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);
+    return defaults.RegionalLambdaRestApi(stack, fn, undefined);
+}
+function setupRestApi(stack, apiProps, createUsagePlan = true) {
+    const globalRestApiResponse = defaults.GlobalRestApi(stack, apiProps, undefined, createUsagePlan);
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');
+    // Setup the API Gateway Integration
+    const apiGatewayIntegration = new api.AwsIntegration({
+        service: "sqs",
+        integrationHttpMethod: "POST",
+        options: {
+            passthroughBehavior: api.PassthroughBehavior.NEVER,
+            requestParameters: {
+                "integration.request.header.Content-Type": "'application/x-www-form-urlencoded'"
+            },
+            requestTemplates: {
+                "application/x-www-form-urlencoded": "Action=SendMessage&MessageBody=$util.urlEncode(\"$input.body\")&MessageAttribute.1.Name=queryParam1&MessageAttribute.1.Value.StringValue=$input.params(\"query_param_1\")&MessageAttribute.1.Value.DataType=String"
+            },
+            integrationResponses: [
+                {
+                    statusCode: "200",
+                    responseTemplates: {
+                        "text/html": "Success"
+                    }
+                },
+                {
+                    statusCode: "500",
+                    responseTemplates: {
+                        "text/html": "Error"
+                    },
+                    selectionPattern: "500"
+                }
+            ]
+        },
+        path: '11112222/thisqueuequeueName'
+    });
+    // Setup the API Gateway method(s)
+    apiGatewayResource.addMethod('POST', apiGatewayIntegration, {
+        requestParameters: {
+            "method.request.querystring.query_param_1": true
+        },
+        methodResponses: [
+            {
+                statusCode: "200",
+                responseParameters: {
+                    "method.response.header.Content-Type": true
+                }
+            },
+            {
+                statusCode: "500",
+                responseParameters: {
+                    "method.response.header.Content-Type": true
+                },
+            }
+        ]
+    });
+}
+test('Test override for RegionalApiGateway', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);
+    defaults.RegionalLambdaRestApi(stack, fn, {
+        handler: fn,
+        description: 'Hello World'
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResource('AWS::ApiGateway::RestApi', {
+        Type: "AWS::ApiGateway::RestApi",
+        Properties: {
+            Description: "Hello World",
+            EndpointConfiguration: {
+                Types: [
+                    "REGIONAL"
+                ]
+            },
+            Name: "LambdaRestApi"
+        }
+    });
+    template.hasResource("AWS::ApiGateway::UsagePlan", {});
+});
+test('Test override for GlobalApiGateway', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);
+    defaults.GlobalLambdaRestApi(stack, fn, {
+        handler: fn,
+        restApiName: "HelloWorld"
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResource('AWS::ApiGateway::RestApi', {
+        Type: "AWS::ApiGateway::RestApi",
+        Properties: {
+            EndpointConfiguration: {
+                Types: [
+                    "EDGE"
+                ]
+            },
+            Name: "HelloWorld"
+        }
+    });
+    template.hasResource("AWS::ApiGateway::UsagePlan", {});
+});
+test('Test ApiGateway::Account resource for RegionalApiGateway', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);
+    defaults.RegionalLambdaRestApi(stack, fn);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::Account', {
+        CloudWatchRoleArn: {
+            "Fn::GetAtt": [
+                "LambdaRestApiCloudWatchRoleF339D4E6",
+                "Arn"
+            ]
+        }
+    });
+});
+test('Test ApiGateway::Account resource for GlobalApiGateway', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);
+    defaults.GlobalLambdaRestApi(stack, fn);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::Account', {
+        CloudWatchRoleArn: {
+            "Fn::GetAtt": [
+                "LambdaRestApiCloudWatchRoleF339D4E6",
+                "Arn"
+            ]
+        }
+    });
+});
+test('Test default RestApi deployment w/ ApiGatewayProps', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    setupRestApi(stack, {
+        restApiName: "customRestApi"
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::RestApi', {
+        Name: "customRestApi"
+    });
+});
+test('Test suppress UsagePlan', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    setupRestApi(stack, {
+        restApiName: "customRestApi"
+    }, false);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::RestApi', {
+        Name: "customRestApi"
+    });
+    template.resourceCountIs("AWS::ApiGateway::UsagePlan", 0);
+});
+test('Test default RestApi deployment w/ cloudWatchRole set to false', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    setupRestApi(stack, {
+        cloudWatchRole: false
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs("AWS::ApiGateway::Account", 0);
+    template.hasResource("AWS::ApiGateway::UsagePlan", {});
+});
+test('Test default RestApi deployment for Cloudwatch loggroup', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    deployRegionalApiGateway(stack);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResource('AWS::Logs::LogGroup', {
+        UpdateReplacePolicy: "Retain",
+        DeletionPolicy: "Retain"
+    });
+    template.hasResourceProperties('AWS::ApiGateway::Stage', {
+        AccessLogSetting: {
+            DestinationArn: {
+                "Fn::GetAtt": [
+                    "ApiAccessLogGroupCEA70788",
+                    "Arn"
+                ]
+            },
+            Format: "{\"requestId\":\"$context.requestId\",\"ip\":\"$context.identity.sourceIp\",\"user\":\"$context.identity.user\",\"caller\":\"$context.identity.caller\",\"requestTime\":\"$context.requestTime\",\"httpMethod\":\"$context.httpMethod\",\"resourcePath\":\"$context.resourcePath\",\"status\":\"$context.status\",\"protocol\":\"$context.protocol\",\"responseLength\":\"$context.responseLength\"}",
+        },
+    });
+});
+test('Test addMethodToApiResource with action', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');
+    const getRequestTemplate = "{}";
+    // Add Method
+    defaults.addProxyMethodToApiResource({
+        action: "Query",
+        service: "dynamodb",
+        apiResource: apiGatewayResource,
+        apiGatewayRole,
+        apiMethod: "GET",
+        requestTemplate: getRequestTemplate
+    });
+    // Add Method
+    defaults.addProxyMethodToApiResource({
+        path: '11112222/thisqueuequeueName',
+        service: "sqs",
+        apiResource: apiGatewayResource,
+        apiGatewayRole,
+        apiMethod: "PUT",
+        requestTemplate: getRequestTemplate
+    });
+    // Error scenario: missing action and path
+    try {
+        defaults.addProxyMethodToApiResource({
+            service: "sqs",
+            apiResource: apiGatewayResource,
+            apiGatewayRole,
+            apiMethod: "DELETE",
+            requestTemplate: getRequestTemplate
+        });
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(Error);
+    }
+});
+test('Test default RestApi w/ request model and validator', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');
+    const validator = globalRestApiResponse.api.addRequestValidator('default-validator', {
+        requestValidatorName: 'default-validator',
+        validateRequestBody: true
+    });
+    defaults.addProxyMethodToApiResource({
+        service: "kinesis",
+        action: "PutRecord",
+        apiGatewayRole,
+        apiMethod: 'POST',
+        apiResource: apiGatewayResource,
+        requestTemplate: "{}",
+        contentType: "'x-amz-json-1.1'",
+        methodOptions: {
+            requestValidator: validator,
+            requestModels: { "application/json": api.Model.EMPTY_MODEL }
+        }
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::RequestValidator', {
+        Name: "default-validator",
+        ValidateRequestBody: true
+    });
+    template.hasResourceProperties('AWS::ApiGateway::Method', {
+        RequestModels: { "application/json": "Empty" }
+    });
+});
+// -----------------------------------------------------------------------
+// Test for Regional ApiGateway Creation
+// -----------------------------------------------------------------------
+test('Test for RegionalRestApiGateway', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const regionalRestApiResponse = defaults.RegionalRestApi(stack, {
+        restApiName: "HelloWorld-RegionalApi"
+    });
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = regionalRestApiResponse.api.root.addResource('hello');
+    defaults.addProxyMethodToApiResource({
+        service: 'iotdata',
+        path: 'hello',
+        apiGatewayRole,
+        apiMethod: 'POST',
+        apiResource: apiGatewayResource,
+        requestTemplate: "$input.json('$')"
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResource('AWS::ApiGateway::RestApi', {
+        Type: "AWS::ApiGateway::RestApi",
+        Properties: {
+            EndpointConfiguration: {
+                Types: [
+                    "REGIONAL"
+                ]
+            },
+            Name: "HelloWorld-RegionalApi"
+        }
+    });
+});
+test('Test supporess usage plan in RegionalRestApiGateway', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const regionalRestApiResponse = defaults.RegionalRestApi(stack, {
+        restApiName: "HelloWorld-RegionalApi"
+    }, undefined, false);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = regionalRestApiResponse.api.root.addResource('hello');
+    defaults.addProxyMethodToApiResource({
+        service: 'iotdata',
+        path: 'hello',
+        apiGatewayRole,
+        apiMethod: 'POST',
+        apiResource: apiGatewayResource,
+        requestTemplate: "$input.json('$')"
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs("AWS::ApiGateway::UsagePlan", 0);
+});
+// -----------------------------------------------------------------------
+// Tests for exception while overriding restApiProps using endPointTypes
+// -----------------------------------------------------------------------
+test('Test for Exception while overriding restApiProps using endPointTypes', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    try {
+        defaults.RegionalRestApi(stack, {
+            endpointTypes: [api.EndpointType.REGIONAL]
+        });
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(Error);
+    }
+});
+// -----------------------------------------------------------------------
+// Tests for exception while overriding LambdaRestApiProps using endPointTypes
+// -----------------------------------------------------------------------
+test('Test for Exception while overriding LambdaRestApiProps using endPointTypes', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);
+    try {
+        defaults.GlobalLambdaRestApi(stack, fn, {
+            handler: fn,
+            endpointTypes: [api.EndpointType.REGIONAL]
+        });
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(Error);
+    }
+});
+// -----------------------------------------------------------------------
+// Test for Integration Request Props Override
+// -----------------------------------------------------------------------
+test('Test for Integration Request Props Override', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const regionalRestApiResponse = defaults.RegionalRestApi(stack);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = regionalRestApiResponse.api.root.addResource('hello');
+    const integReqParams = { 'integration.request.path.topic-level-1': "'method.request.path.topic-level-1'" };
+    const integResp = [
+        {
+            statusCode: "200",
+            selectionPattern: "2\\d{2}",
+            responseTemplates: {
+                "application/json": "$input.json('$')"
+            }
+        }
+    ];
+    // Override the default Integration Request Props
+    const integrationReqProps = {
+        subdomain: 'abcdefgh12345',
+        options: {
+            requestParameters: integReqParams,
+            integrationResponses: integResp,
+            passthroughBehavior: api.PassthroughBehavior.WHEN_NO_MATCH
+        }
+    };
+    defaults.addProxyMethodToApiResource({
+        service: 'iotdata',
+        path: 'hello',
+        apiGatewayRole,
+        apiMethod: 'POST',
+        apiResource: apiGatewayResource,
+        requestTemplate: "$input.json('$')",
+        awsIntegrationProps: integrationReqProps
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties("AWS::ApiGateway::Method", {
+        HttpMethod: "POST",
+        AuthorizationType: "AWS_IAM",
+        Integration: {
+            IntegrationHttpMethod: "POST",
+            IntegrationResponses: [
+                {
+                    ResponseTemplates: {
+                        "application/json": "$input.json('$')"
+                    },
+                    SelectionPattern: "2\\d{2}",
+                    StatusCode: "200"
+                }
+            ],
+            PassthroughBehavior: "WHEN_NO_MATCH",
+            RequestParameters: {
+                "integration.request.header.Content-Type": "'application/json'",
+                "integration.request.path.topic-level-1": "'method.request.path.topic-level-1'",
+            },
+            RequestTemplates: {
+                "application/json": "$input.json('$')"
+            },
+            Type: "AWS",
+            Uri: {
+                "Fn::Join": [
+                    "",
+                    [
+                        "arn:",
+                        {
+                            Ref: "AWS::Partition"
+                        },
+                        ":apigateway:",
+                        {
+                            Ref: "AWS::Region"
+                        },
+                        `:abcdefgh12345.iotdata:path/hello`
+                    ]
+                ]
+            }
+        },
+        MethodResponses: [
+            {
+                StatusCode: "200",
+                ResponseParameters: {
+                    "method.response.header.Content-Type": true
+                }
+            },
+            {
+                StatusCode: "500",
+                ResponseParameters: {
+                    "method.response.header.Content-Type": true
+                }
+            }
+        ]
+    });
+});
+// -----------------------------------------------------------------------
+// Test for Method Options Override
+// -----------------------------------------------------------------------
+test('Test for Method Request Props Override', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('hello');
+    const methodReqParams = { 'method.request.path.topic-level-1': true };
+    const methodResp = [
+        {
+            statusCode: "403"
+        }
+    ];
+    const resourceMethodOptions = {
+        requestParameters: methodReqParams,
+        methodResponses: methodResp,
+    };
+    defaults.addProxyMethodToApiResource({
+        service: 'iotdata',
+        path: 'hello',
+        apiGatewayRole,
+        apiMethod: 'POST',
+        apiResource: apiGatewayResource,
+        requestTemplate: "$input.json('$')",
+        methodOptions: resourceMethodOptions
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties("AWS::ApiGateway::Method", {
+        HttpMethod: "POST",
+        AuthorizationType: "AWS_IAM",
+        Integration: {
+            IntegrationHttpMethod: "POST",
+            IntegrationResponses: [
+                {
+                    StatusCode: "200"
+                },
+                {
+                    StatusCode: "500",
+                    ResponseTemplates: {
+                        "text/html": "Error"
+                    },
+                    SelectionPattern: "500"
+                }
+            ],
+            PassthroughBehavior: "NEVER",
+            RequestParameters: {
+                "integration.request.header.Content-Type": "'application/json'",
+            },
+            RequestTemplates: {
+                "application/json": "$input.json('$')"
+            },
+            Type: "AWS",
+            Uri: {
+                "Fn::Join": [
+                    "",
+                    [
+                        "arn:",
+                        {
+                            Ref: "AWS::Partition"
+                        },
+                        ":apigateway:",
+                        {
+                            Ref: "AWS::Region"
+                        },
+                        `:iotdata:path/hello`
+                    ]
+                ]
+            }
+        },
+        MethodResponses: [
+            {
+                StatusCode: "403"
+            }
+        ],
+        RequestParameters: {
+            "method.request.path.topic-level-1": true
+        }
+    });
+});
+// -----------------------------------------------------------------------
+// Test for ApiKey Creation of RestApi
+// -----------------------------------------------------------------------
+test('Test for ApiKey creation using restApiProps', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack, {
+        defaultMethodOptions: {
+            apiKeyRequired: true
+        }
+    });
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('hello');
+    defaults.addProxyMethodToApiResource({
+        service: 'iotdata',
+        path: 'hello',
+        apiGatewayRole,
+        apiMethod: 'POST',
+        apiResource: apiGatewayResource,
+        requestTemplate: "$input.json('$')"
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    // Assertion to check for ApiKey
+    template.hasResourceProperties("AWS::ApiGateway::Method", {
+        ApiKeyRequired: true
+    });
+    template.hasResourceProperties("AWS::ApiGateway::ApiKey", {
+        Enabled: true
+    });
+    // Assertion to check for UsagePlan Api Key Mapping
+    template.hasResourceProperties("AWS::ApiGateway::UsagePlanKey", {
+        KeyType: "API_KEY"
+    });
+});
+// -----------------------------------------------------------------------
+// Test for ApiKey Creation of LambdaRestApi
+// -----------------------------------------------------------------------
+test('Test for ApiKey creation using lambdaApiProps', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const lambdaFunctionProps = {
+        runtime: defaults.COMMERCIAL_REGION_LAMBDA_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`)
+    };
+    const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);
+    defaults.RegionalLambdaRestApi(stack, fn, {
+        handler: fn,
+        defaultMethodOptions: {
+            apiKeyRequired: true
+        }
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    // Assertion to check for ApiKey
+    template.hasResourceProperties("AWS::ApiGateway::Method", {
+        ApiKeyRequired: true
+    });
+    template.hasResourceProperties("AWS::ApiGateway::ApiKey", {
+        Enabled: true
+    });
+    // Assertion to check for UsagePlan Api Key Mapping
+    template.hasResourceProperties("AWS::ApiGateway::UsagePlanKey", {
+        KeyType: "API_KEY"
+    });
+});
+test('Additional request templates can be specified on addMethodToApiResource method', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');
+    const requestTemplate = '{}';
+    const additionalRequestTemplates = {
+        'text/plain': 'additional-request-template'
+    };
+    // Add Method
+    defaults.addProxyMethodToApiResource({
+        action: "Query",
+        service: "dynamodb",
+        apiResource: apiGatewayResource,
+        apiGatewayRole,
+        apiMethod: "GET",
+        requestTemplate,
+        additionalRequestTemplates
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::Method', {
+        HttpMethod: 'GET',
+        Integration: {
+            RequestTemplates: {
+                'application/json': `{}`,
+                'text/plain': 'additional-request-template'
+            }
+        }
+    });
+});
+test('Default integration responses are used on addMethodToApiResource method', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');
+    // Add Method
+    defaults.addProxyMethodToApiResource({
+        action: 'Query',
+        service: 'dynamodb',
+        apiResource: apiGatewayResource,
+        apiGatewayRole,
+        apiMethod: 'GET',
+        requestTemplate: '{}',
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::Method', {
+        HttpMethod: 'GET',
+        Integration: {
+            IntegrationResponses: [
+                {
+                    StatusCode: '200'
+                },
+                {
+                    ResponseTemplates: {
+                        'text/html': 'Error'
+                    },
+                    SelectionPattern: '500',
+                    StatusCode: '500'
+                }
+            ]
+        }
+    });
+});
+test('Can override integration responses on addMethodToApiResource method', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack);
+    // Setup the API Gateway role
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    // Setup the API Gateway resource
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');
+    // Add Method
+    defaults.addProxyMethodToApiResource({
+        action: 'Query',
+        service: 'dynamodb',
+        apiResource: apiGatewayResource,
+        apiGatewayRole,
+        apiMethod: 'GET',
+        requestTemplate: '{}',
+        integrationResponses: [
+            {
+                statusCode: "200",
+                responseTemplates: {
+                    "text/html": "OK"
+                }
+            }
+        ]
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::ApiGateway::Method', {
+        HttpMethod: 'GET',
+        Integration: {
+            IntegrationResponses: [
+                {
+                    ResponseTemplates: {
+                        'text/html': 'OK'
+                    },
+                    StatusCode: '200'
+                }
+            ],
+        }
+    });
+});
+test('Specifying application/json content-type in additionalRequestTemplates property throws an error', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const globalRestApiResponse = defaults.GlobalRestApi(stack);
+    const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {
+        assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')
+    });
+    const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');
+    const app = () => {
+        defaults.addProxyMethodToApiResource({
+            action: 'Query',
+            service: 'dynamodb',
+            apiResource: apiGatewayResource,
+            apiGatewayRole,
+            apiMethod: 'GET',
+            requestTemplate: '{}',
+            additionalRequestTemplates: {
+                'application/json': '{}'
+            }
+        });
+    };
+    expect(app).toThrow('Request Template for the application/json content-type must be specified in the requestTemplate property and not in the additionalRequestTemplates property');
+});
+test('Test CheckApiProps', () => {
+    const apiWithKeyProps = {
+        handler: {},
+        defaultMethodOptions: {
+            apiKeyRequired: true
+        }
+    };
+    const apiWithNoKeyProps = {
+        handler: {},
+    };
+    const noErrApp = () => {
+        defaults.CheckApiProps({
+            apiGatewayProps: apiWithNoKeyProps,
+            createUsagePlan: false
+        });
+    };
+    expect(noErrApp).not.toThrow();
+    const app = () => {
+        defaults.CheckApiProps({
+            apiGatewayProps: apiWithKeyProps,
+            createUsagePlan: false
+        });
+    };
+    expect(app).toThrow('Error - if API key is required, then the Usage plan must be created\n');
+});
+test('Correctly generate a SpecRestApi', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const myApiDefinition = api.ApiDefinition.fromAsset('./test/openapi/apiDefinition.json');
+    defaults.CreateSpecRestApi(stack, {
+        apiDefinition: myApiDefinition
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs("AWS::ApiGateway::RestApi", 1);
+    template.resourceCountIs("AWS::ApiGateway::Deployment", 1);
+    template.resourceCountIs("AWS::ApiGateway::Stage", 1);
+    template.resourceCountIs("AWS::ApiGateway::UsagePlan", 1);
+    template.hasResourceProperties("AWS::ApiGateway::RestApi", {
+        BodyS3Location: {
+            Bucket: assertions_1.Match.anyValue()
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apigateway-helper.test.js","sourceRoot":"","sources":["apigateway-helper.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 { Stack } from 'aws-cdk-lib';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as api from 'aws-cdk-lib/aws-apigateway';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as defaults from '../index';\nimport { Match, Template } from 'aws-cdk-lib/assertions';\n\nfunction deployRegionalApiGateway(stack: 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  const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);\n\n  return defaults.RegionalLambdaRestApi(stack, fn, undefined);\n}\n\nfunction setupRestApi(stack: Stack, apiProps?: any, createUsagePlan: boolean = true): void {\n  const globalRestApiResponse = defaults.GlobalRestApi(stack, apiProps, undefined, createUsagePlan);\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');\n  // Setup the API Gateway Integration\n  const apiGatewayIntegration = new api.AwsIntegration({\n    service: \"sqs\",\n    integrationHttpMethod: \"POST\",\n    options: {\n      passthroughBehavior: api.PassthroughBehavior.NEVER,\n      requestParameters: {\n        \"integration.request.header.Content-Type\": \"'application/x-www-form-urlencoded'\"\n      },\n      requestTemplates: {\n        \"application/x-www-form-urlencoded\": \"Action=SendMessage&MessageBody=$util.urlEncode(\\\"$input.body\\\")&MessageAttribute.1.Name=queryParam1&MessageAttribute.1.Value.StringValue=$input.params(\\\"query_param_1\\\")&MessageAttribute.1.Value.DataType=String\"\n      },\n      integrationResponses: [\n        {\n          statusCode: \"200\",\n          responseTemplates: {\n            \"text/html\": \"Success\"\n          }\n        },\n        {\n          statusCode: \"500\",\n          responseTemplates: {\n            \"text/html\": \"Error\"\n          },\n          selectionPattern: \"500\"\n        }\n      ]\n    },\n    path: '11112222/thisqueuequeueName'\n  });\n  // Setup the API Gateway method(s)\n  apiGatewayResource.addMethod('POST', apiGatewayIntegration, {\n    requestParameters: {\n      \"method.request.querystring.query_param_1\": true\n    },\n    methodResponses: [\n      {\n        statusCode: \"200\",\n        responseParameters: {\n          \"method.response.header.Content-Type\": true\n        }\n      },\n      {\n        statusCode: \"500\",\n        responseParameters: {\n          \"method.response.header.Content-Type\": true\n        },\n      }\n    ]\n  });\n}\n\ntest('Test override for RegionalApiGateway', () => {\n  const stack = new Stack();\n\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  const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);\n\n  defaults.RegionalLambdaRestApi(stack, fn, {\n    handler: fn,\n    description: 'Hello World'\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResource('AWS::ApiGateway::RestApi', {\n    Type: \"AWS::ApiGateway::RestApi\",\n    Properties: {\n      Description: \"Hello World\",\n      EndpointConfiguration: {\n        Types: [\n          \"REGIONAL\"\n        ]\n      },\n      Name: \"LambdaRestApi\"\n    }\n  });\n  template.hasResource(\"AWS::ApiGateway::UsagePlan\", {});\n});\n\ntest('Test override for GlobalApiGateway', () => {\n  const stack = new Stack();\n\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  const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);\n\n  defaults.GlobalLambdaRestApi(stack, fn, {\n    handler: fn,\n    restApiName: \"HelloWorld\"\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResource('AWS::ApiGateway::RestApi', {\n    Type: \"AWS::ApiGateway::RestApi\",\n    Properties: {\n      EndpointConfiguration: {\n        Types: [\n          \"EDGE\"\n        ]\n      },\n      Name: \"HelloWorld\"\n    }\n  });\n  template.hasResource(\"AWS::ApiGateway::UsagePlan\", {});\n});\n\ntest('Test ApiGateway::Account resource for RegionalApiGateway', () => {\n  const stack = new 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  const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);\n\n  defaults.RegionalLambdaRestApi(stack, fn);\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::Account', {\n    CloudWatchRoleArn: {\n      \"Fn::GetAtt\": [\n        \"LambdaRestApiCloudWatchRoleF339D4E6\",\n        \"Arn\"\n      ]\n    }\n  });\n});\n\ntest('Test ApiGateway::Account resource for GlobalApiGateway', () => {\n  const stack = new 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  const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);\n\n  defaults.GlobalLambdaRestApi(stack, fn);\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::Account', {\n    CloudWatchRoleArn: {\n      \"Fn::GetAtt\": [\n        \"LambdaRestApiCloudWatchRoleF339D4E6\",\n        \"Arn\"\n      ]\n    }\n  });\n});\n\ntest('Test default RestApi deployment w/ ApiGatewayProps', () => {\n  const stack = new Stack();\n  setupRestApi(stack, {\n    restApiName: \"customRestApi\"\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::RestApi', {\n    Name: \"customRestApi\"\n  });\n});\n\ntest('Test suppress UsagePlan', () => {\n  const stack = new Stack();\n  setupRestApi(stack, {\n    restApiName: \"customRestApi\"\n  },\n    false);\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::RestApi', {\n    Name: \"customRestApi\"\n  });\n  template.resourceCountIs(\"AWS::ApiGateway::UsagePlan\", 0);\n});\n\ntest('Test default RestApi deployment w/ cloudWatchRole set to false', () => {\n  const stack = new Stack();\n  setupRestApi(stack, {\n    cloudWatchRole: false\n  });\n\n  const template = Template.fromStack(stack);\n  template.resourceCountIs(\"AWS::ApiGateway::Account\", 0);\n  template.hasResource(\"AWS::ApiGateway::UsagePlan\", {});\n});\n\ntest('Test default RestApi deployment for Cloudwatch loggroup', () => {\n  const stack = new Stack();\n  deployRegionalApiGateway(stack);\n\n  const template = Template.fromStack(stack);\n  template.hasResource('AWS::Logs::LogGroup', {\n    UpdateReplacePolicy: \"Retain\",\n    DeletionPolicy: \"Retain\"\n  });\n\n  template.hasResourceProperties('AWS::ApiGateway::Stage', {\n    AccessLogSetting: {\n      DestinationArn: {\n        \"Fn::GetAtt\": [\n          \"ApiAccessLogGroupCEA70788\",\n          \"Arn\"\n        ]\n      },\n      Format: \"{\\\"requestId\\\":\\\"$context.requestId\\\",\\\"ip\\\":\\\"$context.identity.sourceIp\\\",\\\"user\\\":\\\"$context.identity.user\\\",\\\"caller\\\":\\\"$context.identity.caller\\\",\\\"requestTime\\\":\\\"$context.requestTime\\\",\\\"httpMethod\\\":\\\"$context.httpMethod\\\",\\\"resourcePath\\\":\\\"$context.resourcePath\\\",\\\"status\\\":\\\"$context.status\\\",\\\"protocol\\\":\\\"$context.protocol\\\",\\\"responseLength\\\":\\\"$context.responseLength\\\"}\",\n    },\n  });\n});\n\ntest('Test addMethodToApiResource with action', () => {\n  const stack = new Stack();\n  const globalRestApiResponse = defaults.GlobalRestApi(stack);\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');\n  const getRequestTemplate = \"{}\";\n\n  // Add Method\n  defaults.addProxyMethodToApiResource({\n    action: \"Query\",\n    service: \"dynamodb\",\n    apiResource: apiGatewayResource,\n    apiGatewayRole,\n    apiMethod: \"GET\",\n    requestTemplate: getRequestTemplate\n  });\n\n  // Add Method\n  defaults.addProxyMethodToApiResource({\n    path: '11112222/thisqueuequeueName',\n    service: \"sqs\",\n    apiResource: apiGatewayResource,\n    apiGatewayRole,\n    apiMethod: \"PUT\",\n    requestTemplate: getRequestTemplate\n  });\n\n  // Error scenario: missing action and path\n  try {\n    defaults.addProxyMethodToApiResource({\n      service: \"sqs\",\n      apiResource: apiGatewayResource,\n      apiGatewayRole,\n      apiMethod: \"DELETE\",\n      requestTemplate: getRequestTemplate\n    });\n  } catch (e) {\n    expect(e).toBeInstanceOf(Error);\n  }\n});\n\ntest('Test default RestApi w/ request model and validator', () => {\n  const stack = new Stack();\n  const globalRestApiResponse = defaults.GlobalRestApi(stack);\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');\n\n  const validator = globalRestApiResponse.api.addRequestValidator('default-validator', {\n    requestValidatorName: 'default-validator',\n    validateRequestBody: true\n  });\n\n  defaults.addProxyMethodToApiResource({\n    service: \"kinesis\",\n    action: \"PutRecord\",\n    apiGatewayRole,\n    apiMethod: 'POST',\n    apiResource: apiGatewayResource,\n    requestTemplate: \"{}\",\n    contentType: \"'x-amz-json-1.1'\",\n    methodOptions: {\n      requestValidator: validator,\n      requestModels: { \"application/json\": api.Model.EMPTY_MODEL }\n    }\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::RequestValidator', {\n    Name: \"default-validator\",\n    ValidateRequestBody: true\n  });\n\n  template.hasResourceProperties('AWS::ApiGateway::Method', {\n    RequestModels: { \"application/json\": \"Empty\" }\n  });\n});\n\n// -----------------------------------------------------------------------\n// Test for Regional ApiGateway Creation\n// -----------------------------------------------------------------------\ntest('Test for RegionalRestApiGateway', () => {\n  const stack = new Stack();\n\n  const regionalRestApiResponse = defaults.RegionalRestApi(stack, {\n    restApiName: \"HelloWorld-RegionalApi\"\n  });\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = regionalRestApiResponse.api.root.addResource('hello');\n\n  defaults.addProxyMethodToApiResource(\n    {\n      service: 'iotdata',\n      path: 'hello',\n      apiGatewayRole,\n      apiMethod: 'POST',\n      apiResource: apiGatewayResource,\n      requestTemplate: \"$input.json('$')\"\n    });\n\n  const template = Template.fromStack(stack);\n  template.hasResource('AWS::ApiGateway::RestApi', {\n    Type: \"AWS::ApiGateway::RestApi\",\n    Properties: {\n      EndpointConfiguration: {\n        Types: [\n          \"REGIONAL\"\n        ]\n      },\n      Name: \"HelloWorld-RegionalApi\"\n    }\n  });\n});\n\ntest('Test supporess usage plan in RegionalRestApiGateway', () => {\n  const stack = new Stack();\n\n  const regionalRestApiResponse = defaults.RegionalRestApi(stack, {\n    restApiName: \"HelloWorld-RegionalApi\"\n  }, undefined, false);\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = regionalRestApiResponse.api.root.addResource('hello');\n\n  defaults.addProxyMethodToApiResource(\n    {\n      service: 'iotdata',\n      path: 'hello',\n      apiGatewayRole,\n      apiMethod: 'POST',\n      apiResource: apiGatewayResource,\n      requestTemplate: \"$input.json('$')\"\n    });\n\n  const template = Template.fromStack(stack);\n  template.resourceCountIs(\"AWS::ApiGateway::UsagePlan\", 0);\n});\n// -----------------------------------------------------------------------\n// Tests for exception while overriding restApiProps using endPointTypes\n// -----------------------------------------------------------------------\ntest('Test for Exception while overriding restApiProps using endPointTypes', () => {\n  const stack = new Stack();\n  try {\n    defaults.RegionalRestApi(stack, {\n      endpointTypes: [api.EndpointType.REGIONAL]\n    });\n  } catch (e) {\n    expect(e).toBeInstanceOf(Error);\n  }\n});\n\n// -----------------------------------------------------------------------\n// Tests for exception while overriding LambdaRestApiProps using endPointTypes\n// -----------------------------------------------------------------------\ntest('Test for Exception while overriding LambdaRestApiProps using endPointTypes', () => {\n  const stack = new 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  const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);\n\n  try {\n    defaults.GlobalLambdaRestApi(stack, fn, {\n      handler: fn,\n      endpointTypes: [api.EndpointType.REGIONAL]\n    });\n  } catch (e) {\n    expect(e).toBeInstanceOf(Error);\n  }\n});\n\n// -----------------------------------------------------------------------\n// Test for Integration Request Props Override\n// -----------------------------------------------------------------------\ntest('Test for Integration Request Props Override', () => {\n  const stack = new Stack();\n\n  const regionalRestApiResponse = defaults.RegionalRestApi(stack);\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = regionalRestApiResponse.api.root.addResource('hello');\n  const integReqParams = { 'integration.request.path.topic-level-1': \"'method.request.path.topic-level-1'\" };\n  const integResp: api.IntegrationResponse[] = [\n    {\n      statusCode: \"200\",\n      selectionPattern: \"2\\\\d{2}\",\n      responseTemplates: {\n        \"application/json\": \"$input.json('$')\"\n      }\n    }];\n  // Override the default Integration Request Props\n  const integrationReqProps = {\n    subdomain: 'abcdefgh12345',\n    options: {\n      requestParameters: integReqParams,\n      integrationResponses: integResp,\n      passthroughBehavior: api.PassthroughBehavior.WHEN_NO_MATCH\n    }\n  };\n  defaults.addProxyMethodToApiResource(\n    {\n      service: 'iotdata',\n      path: 'hello',\n      apiGatewayRole,\n      apiMethod: 'POST',\n      apiResource: apiGatewayResource,\n      requestTemplate: \"$input.json('$')\",\n      awsIntegrationProps: integrationReqProps\n    });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties(\"AWS::ApiGateway::Method\", {\n    HttpMethod: \"POST\",\n    AuthorizationType: \"AWS_IAM\",\n    Integration: {\n      IntegrationHttpMethod: \"POST\",\n      IntegrationResponses: [\n        {\n          ResponseTemplates: {\n            \"application/json\": \"$input.json('$')\"\n          },\n          SelectionPattern: \"2\\\\d{2}\",\n          StatusCode: \"200\"\n        }\n      ],\n      PassthroughBehavior: \"WHEN_NO_MATCH\",\n      RequestParameters: {\n        \"integration.request.header.Content-Type\": \"'application/json'\",\n        \"integration.request.path.topic-level-1\": \"'method.request.path.topic-level-1'\",\n      },\n      RequestTemplates: {\n        \"application/json\": \"$input.json('$')\"\n      },\n      Type: \"AWS\",\n      Uri: {\n        \"Fn::Join\": [\n          \"\",\n          [\n            \"arn:\",\n            {\n              Ref: \"AWS::Partition\"\n            },\n            \":apigateway:\",\n            {\n              Ref: \"AWS::Region\"\n            },\n            `:abcdefgh12345.iotdata:path/hello`\n          ]\n        ]\n      }\n    },\n    MethodResponses: [\n      {\n        StatusCode: \"200\",\n        ResponseParameters: {\n          \"method.response.header.Content-Type\": true\n        }\n      },\n      {\n        StatusCode: \"500\",\n        ResponseParameters: {\n          \"method.response.header.Content-Type\": true\n        }\n      }\n    ]\n  });\n});\n\n// -----------------------------------------------------------------------\n// Test for Method Options Override\n// -----------------------------------------------------------------------\ntest('Test for Method Request Props Override', () => {\n  const stack = new Stack();\n\n  const globalRestApiResponse = defaults.GlobalRestApi(stack);\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('hello');\n  const methodReqParams = { 'method.request.path.topic-level-1': true };\n  const methodResp: api.MethodResponse[] = [\n    {\n      statusCode: \"403\"\n    }\n  ];\n  const resourceMethodOptions = {\n    requestParameters: methodReqParams,\n    methodResponses: methodResp,\n  };\n  defaults.addProxyMethodToApiResource(\n    {\n      service: 'iotdata',\n      path: 'hello',\n      apiGatewayRole,\n      apiMethod: 'POST',\n      apiResource: apiGatewayResource,\n      requestTemplate: \"$input.json('$')\",\n      methodOptions: resourceMethodOptions\n    });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties(\"AWS::ApiGateway::Method\", {\n    HttpMethod: \"POST\",\n    AuthorizationType: \"AWS_IAM\",\n    Integration: {\n      IntegrationHttpMethod: \"POST\",\n      IntegrationResponses: [\n        {\n          StatusCode: \"200\"\n        },\n        {\n          StatusCode: \"500\",\n          ResponseTemplates: {\n            \"text/html\": \"Error\"\n          },\n          SelectionPattern: \"500\"\n        }\n      ],\n      PassthroughBehavior: \"NEVER\",\n      RequestParameters: {\n        \"integration.request.header.Content-Type\": \"'application/json'\",\n      },\n      RequestTemplates: {\n        \"application/json\": \"$input.json('$')\"\n      },\n      Type: \"AWS\",\n      Uri: {\n        \"Fn::Join\": [\n          \"\",\n          [\n            \"arn:\",\n            {\n              Ref: \"AWS::Partition\"\n            },\n            \":apigateway:\",\n            {\n              Ref: \"AWS::Region\"\n            },\n            `:iotdata:path/hello`\n          ]\n        ]\n      }\n    },\n    MethodResponses: [\n      {\n        StatusCode: \"403\"\n      }\n    ],\n    RequestParameters: {\n      \"method.request.path.topic-level-1\": true\n    }\n  });\n});\n\n// -----------------------------------------------------------------------\n// Test for ApiKey Creation of RestApi\n// -----------------------------------------------------------------------\ntest('Test for ApiKey creation using restApiProps', () => {\n  const stack = new Stack();\n  const globalRestApiResponse = defaults.GlobalRestApi(stack, {\n    defaultMethodOptions: {\n      apiKeyRequired: true\n    }\n  });\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('hello');\n\n  defaults.addProxyMethodToApiResource(\n    {\n      service: 'iotdata',\n      path: 'hello',\n      apiGatewayRole,\n      apiMethod: 'POST',\n      apiResource: apiGatewayResource,\n      requestTemplate: \"$input.json('$')\"\n    });\n  const template = Template.fromStack(stack);\n  // Assertion to check for ApiKey\n  template.hasResourceProperties(\"AWS::ApiGateway::Method\", {\n    ApiKeyRequired: true\n  });\n  template.hasResourceProperties(\"AWS::ApiGateway::ApiKey\", {\n    Enabled: true\n  });\n  // Assertion to check for UsagePlan Api Key Mapping\n  template.hasResourceProperties(\"AWS::ApiGateway::UsagePlanKey\", {\n    KeyType: \"API_KEY\"\n  });\n});\n\n// -----------------------------------------------------------------------\n// Test for ApiKey Creation of LambdaRestApi\n// -----------------------------------------------------------------------\ntest('Test for ApiKey creation using lambdaApiProps', () => {\n  const stack = new 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  const fn = defaults.deployLambdaFunction(stack, lambdaFunctionProps);\n  defaults.RegionalLambdaRestApi(stack, fn, {\n    handler: fn,\n    defaultMethodOptions: {\n      apiKeyRequired: true\n    }\n  });\n\n  const template = Template.fromStack(stack);\n  // Assertion to check for ApiKey\n  template.hasResourceProperties(\"AWS::ApiGateway::Method\", {\n    ApiKeyRequired: true\n  });\n  template.hasResourceProperties(\"AWS::ApiGateway::ApiKey\", {\n    Enabled: true\n  });\n  // Assertion to check for UsagePlan Api Key Mapping\n  template.hasResourceProperties(\"AWS::ApiGateway::UsagePlanKey\", {\n    KeyType: \"API_KEY\"\n  });\n});\n\ntest('Additional request templates can be specified on addMethodToApiResource method', () => {\n  const stack = new Stack();\n  const globalRestApiResponse = defaults.GlobalRestApi(stack);\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');\n  const requestTemplate = '{}';\n  const additionalRequestTemplates = {\n    'text/plain': 'additional-request-template'\n  };\n\n  // Add Method\n  defaults.addProxyMethodToApiResource({\n    action: \"Query\",\n    service: \"dynamodb\",\n    apiResource: apiGatewayResource,\n    apiGatewayRole,\n    apiMethod: \"GET\",\n    requestTemplate,\n    additionalRequestTemplates\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::Method', {\n    HttpMethod: 'GET',\n    Integration: {\n      RequestTemplates: {\n        'application/json': `{}`,\n        'text/plain': 'additional-request-template'\n      }\n    }\n  });\n});\n\ntest('Default integration responses are used on addMethodToApiResource method', () => {\n  const stack = new Stack();\n  const globalRestApiResponse = defaults.GlobalRestApi(stack);\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');\n\n  // Add Method\n  defaults.addProxyMethodToApiResource({\n    action: 'Query',\n    service: 'dynamodb',\n    apiResource: apiGatewayResource,\n    apiGatewayRole,\n    apiMethod: 'GET',\n    requestTemplate: '{}',\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::Method', {\n    HttpMethod: 'GET',\n    Integration: {\n      IntegrationResponses: [\n        {\n          StatusCode: '200'\n        },\n        {\n          ResponseTemplates: {\n            'text/html': 'Error'\n          },\n          SelectionPattern: '500',\n          StatusCode: '500'\n        }\n      ]\n    }\n  });\n});\n\ntest('Can override integration responses on addMethodToApiResource method', () => {\n  const stack = new Stack();\n  const globalRestApiResponse = defaults.GlobalRestApi(stack);\n\n  // Setup the API Gateway role\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  // Setup the API Gateway resource\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');\n\n  // Add Method\n  defaults.addProxyMethodToApiResource({\n    action: 'Query',\n    service: 'dynamodb',\n    apiResource: apiGatewayResource,\n    apiGatewayRole,\n    apiMethod: 'GET',\n    requestTemplate: '{}',\n    integrationResponses: [\n      {\n        statusCode: \"200\",\n        responseTemplates: {\n          \"text/html\": \"OK\"\n        }\n      }\n    ]\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::ApiGateway::Method', {\n    HttpMethod: 'GET',\n    Integration: {\n      IntegrationResponses: [\n        {\n          ResponseTemplates: {\n            'text/html': 'OK'\n          },\n          StatusCode: '200'\n        }\n      ],\n    }\n  });\n});\n\ntest('Specifying application/json content-type in additionalRequestTemplates property throws an error', () => {\n  const stack = new Stack();\n  const globalRestApiResponse = defaults.GlobalRestApi(stack);\n\n  const apiGatewayRole = new iam.Role(stack, 'api-gateway-role', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com')\n  });\n\n  const apiGatewayResource = globalRestApiResponse.api.root.addResource('api-gateway-resource');\n\n  const app = () => {\n    defaults.addProxyMethodToApiResource({\n      action: 'Query',\n      service: 'dynamodb',\n      apiResource: apiGatewayResource,\n      apiGatewayRole,\n      apiMethod: 'GET',\n      requestTemplate: '{}',\n      additionalRequestTemplates: {\n        'application/json': '{}'\n      }\n    });\n  };\n\n  expect(app).toThrow('Request Template for the application/json content-type must be specified in the requestTemplate property and not in the additionalRequestTemplates property');\n});\n\ntest('Test CheckApiProps', () => {\n  const apiWithKeyProps: api.LambdaRestApiProps = {\n    handler: {} as lambda.Function,\n    defaultMethodOptions: {\n      apiKeyRequired: true\n    }\n\n  };\n\n  const apiWithNoKeyProps: api.LambdaRestApiProps = {\n    handler: {} as lambda.Function,\n  };\n\n  const noErrApp = () => {\n    defaults.CheckApiProps({\n      apiGatewayProps: apiWithNoKeyProps,\n      createUsagePlan: false\n    });\n  };\n  expect(noErrApp).not.toThrow();\n\n  const app = () => {\n    defaults.CheckApiProps({\n      apiGatewayProps: apiWithKeyProps,\n      createUsagePlan: false\n    });\n  };\n  expect(app).toThrow('Error - if API key is required, then the Usage plan must be created\\n');\n});\n\ntest('Correctly generate a SpecRestApi', () => {\n  const stack = new Stack();\n\n  const myApiDefinition = api.ApiDefinition.fromAsset('./test/openapi/apiDefinition.json');\n\n  defaults.CreateSpecRestApi(stack, {\n    apiDefinition: myApiDefinition\n  });\n  const template = Template.fromStack(stack);\n  template.resourceCountIs(\"AWS::ApiGateway::RestApi\", 1);\n  template.resourceCountIs(\"AWS::ApiGateway::Deployment\", 1);\n  template.resourceCountIs(\"AWS::ApiGateway::Stage\", 1);\n  template.resourceCountIs(\"AWS::ApiGateway::UsagePlan\", 1);\n  template.hasResourceProperties(\"AWS::ApiGateway::RestApi\", {\n    BodyS3Location: {\n      Bucket: Match.anyValue()\n    }\n  });\n});\n"]}