@aws-solutions-constructs/aws-route53-apigateway 1.138.0

package/test/integ.dummyTest.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ *  Copyright 2022 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 });
+// Imports
+const core_1 = require("@aws-cdk/core");
+const core_2 = require("@aws-solutions-constructs/core");
+const defaults = require("@aws-solutions-constructs/core");
+// Setup
+const app = new core_1.App();
+const stack = new core_1.Stack(app, core_2.generateIntegStackName(__filename), {});
+stack.templateOptions.description = 'Dummy Integration Test for aws-route53-apigateway';
+// This is an dummy integ test in order to bypass the CodeBuild integ test scans.
+// Route53ToApiGateway construct requires a legitimate DNS and certificate to be deployed.
+// If a fake DNS and certificate is provided, the deployment will hang and cause it to fail.
+// Legitimate DNS and certificate cannot be provided in integ tests as it is user specific
+// and will need to be regenerated.
+// Create dummy integ with at least one resource to pass CFN scan
+const [restApi] = defaults.RegionalRestApi(stack);
+restApi.root.addMethod('GET');
+// Synth
+app.synth();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWcuZHVtbXlUZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW50ZWcuZHVtbXlUZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7Ozs7R0FXRzs7QUFFSCxVQUFVO0FBQ1Ysd0NBQTJDO0FBQzNDLHlEQUF3RTtBQUN4RSwyREFBMkQ7QUFFM0QsUUFBUTtBQUNSLE1BQU0sR0FBRyxHQUFHLElBQUksVUFBRyxFQUFFLENBQUM7QUFDdEIsTUFBTSxLQUFLLEdBQUcsSUFBSSxZQUFLLENBQUMsR0FBRyxFQUFFLDZCQUFzQixDQUFDLFVBQVUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBRXJFLEtBQUssQ0FBQyxlQUFlLENBQUMsV0FBVyxHQUFHLG1EQUFtRCxDQUFDO0FBRXhGLGlGQUFpRjtBQUNqRiwwRkFBMEY7QUFDMUYsNEZBQTRGO0FBQzVGLDBGQUEwRjtBQUMxRixtQ0FBbUM7QUFFbkMsaUVBQWlFO0FBQ2pFLE1BQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxRQUFRLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ2xELE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBRTlCLFFBQVE7QUFDUixHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqICBDb3B5cmlnaHQgMjAyMiBBbWF6b24uY29tLCBJbmMuIG9yIGl0cyBhZmZpbGlhdGVzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqICBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpLiBZb3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlXG4gKiAgd2l0aCB0aGUgTGljZW5zZS4gQSBjb3B5IG9mIHRoZSBMaWNlbnNlIGlzIGxvY2F0ZWQgYXRcbiAqXG4gKiAgICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqICBvciBpbiB0aGUgJ2xpY2Vuc2UnIGZpbGUgYWNjb21wYW55aW5nIHRoaXMgZmlsZS4gVGhpcyBmaWxlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuICdBUyBJUycgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFU1xuICogIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGV4cHJlc3Mgb3IgaW1wbGllZC4gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zXG4gKiAgYW5kIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbi8vIEltcG9ydHNcbmltcG9ydCB7IEFwcCwgU3RhY2sgfSBmcm9tIFwiQGF3cy1jZGsvY29yZVwiO1xuaW1wb3J0IHsgZ2VuZXJhdGVJbnRlZ1N0YWNrTmFtZSB9IGZyb20gJ0Bhd3Mtc29sdXRpb25zLWNvbnN0cnVjdHMvY29yZSc7XG5pbXBvcnQgKiBhcyBkZWZhdWx0cyBmcm9tICdAYXdzLXNvbHV0aW9ucy1jb25zdHJ1Y3RzL2NvcmUnO1xuXG4vLyBTZXR1cFxuY29uc3QgYXBwID0gbmV3IEFwcCgpO1xuY29uc3Qgc3RhY2sgPSBuZXcgU3RhY2soYXBwLCBnZW5lcmF0ZUludGVnU3RhY2tOYW1lKF9fZmlsZW5hbWUpLCB7fSk7XG5cbnN0YWNrLnRlbXBsYXRlT3B0aW9ucy5kZXNjcmlwdGlvbiA9ICdEdW1teSBJbnRlZ3JhdGlvbiBUZXN0IGZvciBhd3Mtcm91dGU1My1hcGlnYXRld2F5JztcblxuLy8gVGhpcyBpcyBhbiBkdW1teSBpbnRlZyB0ZXN0IGluIG9yZGVyIHRvIGJ5cGFzcyB0aGUgQ29kZUJ1aWxkIGludGVnIHRlc3Qgc2NhbnMuXG4vLyBSb3V0ZTUzVG9BcGlHYXRld2F5IGNvbnN0cnVjdCByZXF1aXJlcyBhIGxlZ2l0aW1hdGUgRE5TIGFuZCBjZXJ0aWZpY2F0ZSB0byBiZSBkZXBsb3llZC5cbi8vIElmIGEgZmFrZSBETlMgYW5kIGNlcnRpZmljYXRlIGlzIHByb3ZpZGVkLCB0aGUgZGVwbG95bWVudCB3aWxsIGhhbmcgYW5kIGNhdXNlIGl0IHRvIGZhaWwuXG4vLyBMZWdpdGltYXRlIEROUyBhbmQgY2VydGlmaWNhdGUgY2Fubm90IGJlIHByb3ZpZGVkIGluIGludGVnIHRlc3RzIGFzIGl0IGlzIHVzZXIgc3BlY2lmaWNcbi8vIGFuZCB3aWxsIG5lZWQgdG8gYmUgcmVnZW5lcmF0ZWQuXG5cbi8vIENyZWF0ZSBkdW1teSBpbnRlZyB3aXRoIGF0IGxlYXN0IG9uZSByZXNvdXJjZSB0byBwYXNzIENGTiBzY2FuXG5jb25zdCBbcmVzdEFwaV0gPSBkZWZhdWx0cy5SZWdpb25hbFJlc3RBcGkoc3RhY2spO1xucmVzdEFwaS5yb290LmFkZE1ldGhvZCgnR0VUJyk7XG5cbi8vIFN5bnRoXG5hcHAuc3ludGgoKTtcbiJdfQ==

package/test/test.route53-apigateway.test.d.ts

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

package/test/test.route53-apigateway.test.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ *  Copyright 2022 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 });
+// Imports
+const cdk = require("@aws-cdk/core");
+const lib_1 = require("../lib");
+const route53 = require("@aws-cdk/aws-route53");
+const defaults = require("@aws-solutions-constructs/core");
+const acm = require("@aws-cdk/aws-certificatemanager");
+require("@aws-cdk/assert/jest");
+// Deploying Public/Private Existing Hosted Zones
+function deployApi(stack, publicApi) {
+    const [restApi] = defaults.RegionalRestApi(stack);
+    restApi.root.addMethod('GET');
+    const domainName = "www.test-example.com";
+    let newZone;
+    if (publicApi) {
+        newZone = new route53.PublicHostedZone(stack, "new-zone", {
+            zoneName: domainName,
+        });
+    }
+    else {
+        const vpc = defaults.buildVpc(stack, {
+            defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
+            constructVpcProps: {
+                enableDnsHostnames: true,
+                enableDnsSupport: true,
+                cidr: "172.168.0.0/16",
+            },
+        });
+        newZone = new route53.PrivateHostedZone(stack, "new-zone", {
+            zoneName: domainName,
+            vpc
+        });
+    }
+    const certificate = acm.Certificate.fromCertificateArn(stack, "fake-cert", "arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012");
+    // Definitions
+    const props = {
+        publicApi,
+        existingHostedZoneInterface: newZone,
+        existingApiGatewayInterface: restApi,
+        existingCertificateInterface: certificate,
+    };
+    return new lib_1.Route53ToApiGateway(stack, "api-stack", props);
+}
+// --------------------------------------------------------------
+// Check for pattern props
+// --------------------------------------------------------------
+test("Test for default params construct props", () => {
+    // Initial Setup
+    const stack = new cdk.Stack();
+    const construct = deployApi(stack, false);
+    // Assertion
+    expect(construct.apiGateway).not.toBeNull();
+    expect(construct.hostedZone).not.toBeNull();
+    expect(construct.vpc).not.toBeNull();
+    expect(construct.certificate).not.toBeNull();
+});
+// --------------------------------------------------------------
+// Check for errors when creating a private hosted zone
+// --------------------------------------------------------------
+test("Test for errors when creating a private hosted zone", () => {
+    // Initial Setup
+    const stack = new cdk.Stack();
+    const [restApi] = defaults.RegionalRestApi(stack);
+    const domainName = "www.test-example.com";
+    const vpc = defaults.buildVpc(stack, {
+        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
+        constructVpcProps: {
+            enableDnsHostnames: true,
+            enableDnsSupport: true,
+            cidr: "172.168.0.0/16",
+        },
+    });
+    const newZone = new route53.PrivateHostedZone(stack, "new-zone", {
+        zoneName: domainName,
+        vpc
+    });
+    const certificate = acm.Certificate.fromCertificateArn(stack, "fake-cert", "arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012");
+    let app = () => new lib_1.Route53ToApiGateway(stack, "api-stack1", {
+        publicApi: true,
+        existingApiGatewayInterface: restApi,
+        existingCertificateInterface: certificate
+    });
+    // Assertion 1
+    expect(app).toThrowError("Public APIs require an existingHostedZone be passed in the Props object.");
+    app = () => new lib_1.Route53ToApiGateway(stack, "api-stack2", {
+        publicApi: false,
+        existingApiGatewayInterface: restApi,
+        existingCertificateInterface: certificate
+    });
+    // Assertion 2
+    expect(app).toThrowError("Must provide either existingHostedZoneInterface or privateHostedZoneProps.");
+    app = () => new lib_1.Route53ToApiGateway(stack, "api-stack3", {
+        publicApi: false,
+        privateHostedZoneProps: {
+            zoneName: "test-example.com",
+            vpc,
+        },
+        existingApiGatewayInterface: restApi,
+        existingCertificateInterface: certificate
+    });
+    // Assertion 3
+    expect(app).toThrowError("All VPC specs must be provided at the Construct level in Route53ToApiGatewayProps");
+    app = () => new lib_1.Route53ToApiGateway(stack, "api-stack4", {
+        publicApi: false,
+        existingHostedZoneInterface: newZone,
+        existingVpc: vpc,
+        existingApiGatewayInterface: restApi,
+        existingCertificateInterface: certificate
+    });
+    // Assertion 4
+    expect(app).toThrowError("Cannot provide an existing VPC to an existing Private Hosted Zone.");
+    app = () => new lib_1.Route53ToApiGateway(stack, "api-stack5", {
+        publicApi: false,
+        existingHostedZoneInterface: newZone,
+        existingApiGatewayInterface: restApi,
+        privateHostedZoneProps: {
+            domainName: "test-example.com"
+        },
+        existingCertificateInterface: certificate
+    });
+    // Assertion 5
+    expect(app).toThrowError("Must provide either existingHostedZoneInterface or privateHostedZoneProps, but not both.");
+    app = () => new lib_1.Route53ToApiGateway(stack, "api-stack6", {
+        publicApi: false,
+        privateHostedZoneProps: {
+            domainName: "test.example.com"
+        },
+        existingApiGatewayInterface: restApi,
+        existingCertificateInterface: certificate
+    });
+    // Assertion 6
+    expect(app).toThrowError('Must supply zoneName for Private Hosted Zone Props.');
+    app = () => new lib_1.Route53ToApiGateway(stack, "api-stack7", {
+        publicApi: false,
+        privateHostedZoneProps: {
+            zoneName: "test.example.com"
+        },
+        existingApiGatewayInterface: restApi,
+        existingCertificateInterface: certificate
+    });
+    // Assertion 7
+    expect(app).toThrowError('Must specify an existingVPC for the Private Hosted Zone in the construct props.');
+});
+// --------------------------------------------------------------
+// Check for providing private hosted zone props
+// --------------------------------------------------------------
+test("Test for providing private hosted zone props", () => {
+    // Initial Setup
+    const stack = new cdk.Stack();
+    const [restApi] = defaults.RegionalRestApi(stack);
+    restApi.root.addMethod('GET');
+    const domainName = "www.private-zone.com";
+    const vpc = defaults.buildVpc(stack, {
+        defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),
+        constructVpcProps: {
+            enableDnsHostnames: true,
+            enableDnsSupport: true,
+            cidr: "172.168.0.0/16",
+        },
+    });
+    const certificate = acm.Certificate.fromCertificateArn(stack, "fake-cert", "arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012");
+    new lib_1.Route53ToApiGateway(stack, "api-stack1", {
+        publicApi: false,
+        existingApiGatewayInterface: restApi,
+        privateHostedZoneProps: {
+            zoneName: domainName,
+        },
+        existingVpc: vpc,
+        existingCertificateInterface: certificate
+    });
+    expect(stack).toHaveResource("AWS::Route53::HostedZone", {
+        Name: "www.private-zone.com.",
+        VPCs: [
+            {
+                VPCId: {
+                    Ref: "Vpc8378EB38",
+                },
+                VPCRegion: {
+                    Ref: "AWS::Region",
+                },
+            },
+        ],
+    });
+});
+// --------------------------------------------------------------
+// Check for A record creation in Public Hosted Zone
+// --------------------------------------------------------------
+test("Integration test for A record creation in Public Hosted Zone ", () => {
+    // Initial Setup
+    const stack = new cdk.Stack();
+    deployApi(stack, true);
+    // Assertions
+    expect(stack).toHaveResource("AWS::Route53::RecordSet", {
+        Name: "www.test-example.com.",
+        Type: "A",
+        AliasTarget: {
+            DNSName: {
+                "Fn::GetAtt": [
+                    "RestApiCustomDomainName94F28E16",
+                    "RegionalDomainName",
+                ],
+            },
+            HostedZoneId: {
+                "Fn::GetAtt": [
+                    "RestApiCustomDomainName94F28E16",
+                    "RegionalHostedZoneId",
+                ],
+            },
+        },
+        HostedZoneId: {
+            Ref: "newzone1D011936",
+        },
+    });
+    expect(stack).toHaveResource("AWS::ApiGateway::RestApi", {
+        EndpointConfiguration: {
+            Types: [
+                "REGIONAL"
+            ]
+        },
+        Name: "RestApi"
+    });
+});
+// --------------------------------------------------------------
+// Check for A record creation in Private Hosted Zone
+// --------------------------------------------------------------
+test("Integration test for A record creation in Private Hosted Zone ", () => {
+    // Initial Setup
+    const stack = new cdk.Stack();
+    deployApi(stack, false);
+    // Assertions
+    expect(stack).toHaveResource("AWS::Route53::RecordSet", {
+        Name: "www.test-example.com.",
+        Type: "A",
+        AliasTarget: {
+            DNSName: {
+                "Fn::GetAtt": [
+                    "RestApiCustomDomainName94F28E16",
+                    "RegionalDomainName",
+                ],
+            },
+            HostedZoneId: {
+                "Fn::GetAtt": [
+                    "RestApiCustomDomainName94F28E16",
+                    "RegionalHostedZoneId",
+                ],
+            },
+        },
+        HostedZoneId: {
+            Ref: "newzone1D011936",
+        },
+    });
+    expect(stack).toHaveResource("AWS::Route53::HostedZone", {
+        Name: "www.test-example.com.",
+        VPCs: [
+            {
+                VPCId: {
+                    Ref: "Vpc8378EB38",
+                },
+                VPCRegion: {
+                    Ref: "AWS::Region",
+                },
+            },
+        ],
+    });
+    expect(stack).toHaveResource("AWS::ApiGateway::RestApi", {
+        EndpointConfiguration: {
+            Types: [
+                "REGIONAL"
+            ]
+        },
+        Name: "RestApi"
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.route53-apigateway.test.js","sourceRoot":"","sources":["test.route53-apigateway.test.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2022 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\n// Imports\nimport * as cdk from \"@aws-cdk/core\";\nimport { Route53ToApiGateway, Route53ToApiGatewayProps } from \"../lib\";\nimport * as route53 from \"@aws-cdk/aws-route53\";\nimport * as defaults from \"@aws-solutions-constructs/core\";\nimport * as acm from \"@aws-cdk/aws-certificatemanager\";\nimport \"@aws-cdk/assert/jest\";\n\n// Deploying Public/Private Existing Hosted Zones\nfunction deployApi(\n  stack: cdk.Stack,\n  publicApi: boolean\n) {\n  const [restApi] = defaults.RegionalRestApi(stack);\n  restApi.root.addMethod('GET');\n\n  const domainName = \"www.test-example.com\";\n\n  let newZone: route53.PublicHostedZone | route53.PrivateHostedZone;\n\n  if (publicApi) {\n    newZone = new route53.PublicHostedZone(stack, \"new-zone\", {\n      zoneName: domainName,\n    });\n  } else {\n    const vpc = defaults.buildVpc(stack, {\n      defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n      constructVpcProps: {\n        enableDnsHostnames: true,\n        enableDnsSupport: true,\n        cidr: \"172.168.0.0/16\",\n      },\n    });\n\n    newZone = new route53.PrivateHostedZone(stack, \"new-zone\", {\n      zoneName: domainName,\n      vpc\n    });\n  }\n\n  const certificate = acm.Certificate.fromCertificateArn(\n    stack,\n    \"fake-cert\",\n    \"arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012\"\n  );\n\n  // Definitions\n  const props: Route53ToApiGatewayProps = {\n    publicApi,\n    existingHostedZoneInterface: newZone,\n    existingApiGatewayInterface: restApi,\n    existingCertificateInterface: certificate,\n  };\n\n  return new Route53ToApiGateway(stack, \"api-stack\", props);\n}\n\n// --------------------------------------------------------------\n// Check for pattern props\n// --------------------------------------------------------------\ntest(\"Test for default params construct props\", () => {\n  // Initial Setup\n  const stack = new cdk.Stack();\n  const construct = deployApi(stack, false);\n\n  // Assertion\n  expect(construct.apiGateway).not.toBeNull();\n  expect(construct.hostedZone).not.toBeNull();\n  expect(construct.vpc).not.toBeNull();\n  expect(construct.certificate).not.toBeNull();\n});\n\n// --------------------------------------------------------------\n// Check for errors when creating a private hosted zone\n// --------------------------------------------------------------\ntest(\"Test for errors when creating a private hosted zone\", () => {\n  // Initial Setup\n  const stack = new cdk.Stack();\n  const [restApi] = defaults.RegionalRestApi(stack);\n  const domainName = \"www.test-example.com\";\n\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n    constructVpcProps: {\n      enableDnsHostnames: true,\n      enableDnsSupport: true,\n      cidr: \"172.168.0.0/16\",\n    },\n  });\n\n  const newZone = new route53.PrivateHostedZone(stack, \"new-zone\", {\n    zoneName: domainName,\n    vpc\n  });\n\n  const certificate = acm.Certificate.fromCertificateArn(\n    stack,\n    \"fake-cert\",\n    \"arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012\"\n  );\n\n  let app = () =>\n    new Route53ToApiGateway(stack, \"api-stack1\", {\n      publicApi: true,\n      existingApiGatewayInterface: restApi,\n      existingCertificateInterface: certificate\n    });\n  // Assertion 1\n  expect(app).toThrowError(\n    \"Public APIs require an existingHostedZone be passed in the Props object.\"\n  );\n\n  app = () =>\n    new Route53ToApiGateway(stack, \"api-stack2\", {\n      publicApi: false,\n      existingApiGatewayInterface: restApi,\n      existingCertificateInterface: certificate\n    });\n\n  // Assertion 2\n  expect(app).toThrowError(\n    \"Must provide either existingHostedZoneInterface or privateHostedZoneProps.\"\n  );\n\n  app = () =>\n    new Route53ToApiGateway(stack, \"api-stack3\", {\n      publicApi: false,\n      privateHostedZoneProps: {\n        zoneName: \"test-example.com\",\n        vpc,\n      },\n      existingApiGatewayInterface: restApi,\n      existingCertificateInterface: certificate\n    });\n\n  // Assertion 3\n  expect(app).toThrowError(\n    \"All VPC specs must be provided at the Construct level in Route53ToApiGatewayProps\"\n  );\n\n  app = () =>\n    new Route53ToApiGateway(stack, \"api-stack4\", {\n      publicApi: false,\n      existingHostedZoneInterface: newZone,\n      existingVpc: vpc,\n      existingApiGatewayInterface: restApi,\n      existingCertificateInterface: certificate\n    });\n\n  // Assertion 4\n  expect(app).toThrowError(\n    \"Cannot provide an existing VPC to an existing Private Hosted Zone.\"\n  );\n\n  app = () =>\n    new Route53ToApiGateway(stack, \"api-stack5\", {\n      publicApi: false,\n      existingHostedZoneInterface: newZone,\n      existingApiGatewayInterface: restApi,\n      privateHostedZoneProps: {\n        domainName: \"test-example.com\"\n      },\n      existingCertificateInterface: certificate\n    });\n\n  // Assertion 5\n  expect(app).toThrowError(\n    \"Must provide either existingHostedZoneInterface or privateHostedZoneProps, but not both.\"\n  );\n\n  app = () =>\n    new Route53ToApiGateway(stack, \"api-stack6\", {\n      publicApi: false,\n      privateHostedZoneProps: {\n        domainName: \"test.example.com\"\n      },\n      existingApiGatewayInterface: restApi,\n      existingCertificateInterface: certificate\n    });\n\n  // Assertion 6\n  expect(app).toThrowError(\n    'Must supply zoneName for Private Hosted Zone Props.'\n  );\n\n  app = () =>\n    new Route53ToApiGateway(stack, \"api-stack7\", {\n      publicApi: false,\n      privateHostedZoneProps: {\n        zoneName: \"test.example.com\"\n      },\n      existingApiGatewayInterface: restApi,\n      existingCertificateInterface: certificate\n    });\n\n  // Assertion 7\n  expect(app).toThrowError(\n    'Must specify an existingVPC for the Private Hosted Zone in the construct props.'\n  );\n});\n\n// --------------------------------------------------------------\n// Check for providing private hosted zone props\n// --------------------------------------------------------------\ntest(\"Test for providing private hosted zone props\", () => {\n  // Initial Setup\n  const stack = new cdk.Stack();\n  const [restApi] = defaults.RegionalRestApi(stack);\n  restApi.root.addMethod('GET');\n\n  const domainName = \"www.private-zone.com\";\n\n  const vpc = defaults.buildVpc(stack, {\n    defaultVpcProps: defaults.DefaultPublicPrivateVpcProps(),\n    constructVpcProps: {\n      enableDnsHostnames: true,\n      enableDnsSupport: true,\n      cidr: \"172.168.0.0/16\",\n    },\n  });\n\n  const certificate = acm.Certificate.fromCertificateArn(\n    stack,\n    \"fake-cert\",\n    \"arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012\"\n  );\n\n  new Route53ToApiGateway(stack, \"api-stack1\", {\n    publicApi: false,\n    existingApiGatewayInterface: restApi,\n    privateHostedZoneProps: {\n      zoneName: domainName,\n    },\n    existingVpc: vpc,\n    existingCertificateInterface: certificate\n  });\n\n  expect(stack).toHaveResource(\"AWS::Route53::HostedZone\", {\n    Name: \"www.private-zone.com.\",\n    VPCs: [\n      {\n        VPCId: {\n          Ref: \"Vpc8378EB38\",\n        },\n        VPCRegion: {\n          Ref: \"AWS::Region\",\n        },\n      },\n    ],\n  });\n});\n\n// --------------------------------------------------------------\n// Check for A record creation in Public Hosted Zone\n// --------------------------------------------------------------\ntest(\"Integration test for A record creation in Public Hosted Zone \", () => {\n  // Initial Setup\n  const stack = new cdk.Stack();\n  deployApi(stack, true);\n\n  // Assertions\n  expect(stack).toHaveResource(\"AWS::Route53::RecordSet\", {\n    Name: \"www.test-example.com.\",\n    Type: \"A\",\n    AliasTarget: {\n      DNSName: {\n        \"Fn::GetAtt\": [\n          \"RestApiCustomDomainName94F28E16\",\n          \"RegionalDomainName\",\n        ],\n      },\n      HostedZoneId: {\n        \"Fn::GetAtt\": [\n          \"RestApiCustomDomainName94F28E16\",\n          \"RegionalHostedZoneId\",\n        ],\n      },\n    },\n    HostedZoneId: {\n      Ref: \"newzone1D011936\",\n    },\n  });\n\n  expect(stack).toHaveResource(\"AWS::ApiGateway::RestApi\", {\n    EndpointConfiguration: {\n      Types: [\n        \"REGIONAL\"\n      ]\n    },\n    Name: \"RestApi\"\n  });\n});\n\n// --------------------------------------------------------------\n// Check for A record creation in Private Hosted Zone\n// --------------------------------------------------------------\ntest(\"Integration test for A record creation in Private Hosted Zone \", () => {\n  // Initial Setup\n  const stack = new cdk.Stack();\n  deployApi(stack, false);\n\n  // Assertions\n  expect(stack).toHaveResource(\"AWS::Route53::RecordSet\", {\n    Name: \"www.test-example.com.\",\n    Type: \"A\",\n    AliasTarget: {\n      DNSName: {\n        \"Fn::GetAtt\": [\n          \"RestApiCustomDomainName94F28E16\",\n          \"RegionalDomainName\",\n        ],\n      },\n      HostedZoneId: {\n        \"Fn::GetAtt\": [\n          \"RestApiCustomDomainName94F28E16\",\n          \"RegionalHostedZoneId\",\n        ],\n      },\n    },\n    HostedZoneId: {\n      Ref: \"newzone1D011936\",\n    },\n  });\n\n  expect(stack).toHaveResource(\"AWS::Route53::HostedZone\", {\n    Name: \"www.test-example.com.\",\n    VPCs: [\n      {\n        VPCId: {\n          Ref: \"Vpc8378EB38\",\n        },\n        VPCRegion: {\n          Ref: \"AWS::Region\",\n        },\n      },\n    ],\n  });\n\n  expect(stack).toHaveResource(\"AWS::ApiGateway::RestApi\", {\n    EndpointConfiguration: {\n      Types: [\n        \"REGIONAL\"\n      ]\n    },\n    Name: \"RestApi\"\n  });\n});"]}