@aws-solutions-constructs/aws-lambda-opensearch 2.26.0

package/test/lambda-opensearch.test.js

@@ -0,0 +1,495 @@
+"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 });
+const lib_1 = require("../lib");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const cdk = require("aws-cdk-lib");
+require("@aws-cdk/assert/jest");
+const defaults = require("@aws-solutions-constructs/core");
+const core_1 = require("@aws-solutions-constructs/core");
+function deployLambdaToOpenSearch(stack) {
+    const props = {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain'
+    };
+    return new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);
+}
+function getDefaultTestLambdaProps() {
+    return {
+        code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+        runtime: lambda.Runtime.NODEJS_14_X,
+        handler: 'index.handler',
+    };
+}
+test('Check pattern properties', () => {
+    const stack = new cdk.Stack();
+    const construct = deployLambdaToOpenSearch(stack);
+    expect(construct.lambdaFunction).toBeDefined();
+    expect(construct.openSearchDomain).toBeDefined();
+    expect(construct.identityPool).toBeDefined();
+    expect(construct.userPool).toBeDefined();
+    expect(construct.userPoolClient).toBeDefined();
+    expect(construct.cloudWatchAlarms).toBeDefined();
+    expect(construct.openSearchRole).toBeDefined();
+});
+test('Check properties with no CloudWatch alarms ', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        createCloudWatchAlarms: false
+    };
+    const construct = new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);
+    expect(construct.lambdaFunction).toBeDefined();
+    expect(construct.openSearchDomain).toBeDefined();
+    expect(construct.identityPool).toBeDefined();
+    expect(construct.userPool).toBeDefined();
+    expect(construct.userPoolClient).toBeDefined();
+    expect(construct.cloudWatchAlarms).toBeUndefined();
+    expect(construct.openSearchRole).toBeDefined();
+});
+test('Check for an existing Lambda object', () => {
+    const stack = new cdk.Stack();
+    const existingLambdaObj = defaults.buildLambdaFunction(stack, {
+        lambdaFunctionProps: {
+            code: lambda.Code.fromAsset(`${__dirname}/lambda`),
+            runtime: lambda.Runtime.NODEJS_14_X,
+            handler: 'index.handler',
+            functionName: 'test-function'
+        }
+    });
+    const props = {
+        openSearchDomainName: 'test-domain',
+        existingLambdaObj
+    };
+    new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);
+    expect(stack).toHaveResource('AWS::Lambda::Function', {
+        FunctionName: 'test-function'
+    });
+});
+test('Check Lambda function custom environment variable', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        domainEndpointEnvironmentVariableName: 'CUSTOM_DOMAIN_ENDPOINT'
+    };
+    new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);
+    expect(stack).toHaveResource('AWS::Lambda::Function', {
+        Handler: 'index.handler',
+        Runtime: 'nodejs14.x',
+        Environment: {
+            Variables: {
+                AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',
+                CUSTOM_DOMAIN_ENDPOINT: {
+                    'Fn::GetAtt': [
+                        'testlambdaopensearchstackOpenSearchDomain46D6A86E',
+                        'DomainEndpoint'
+                    ]
+                }
+            }
+        }
+    });
+});
+test('Check domain name', () => {
+    const stack = new cdk.Stack();
+    deployLambdaToOpenSearch(stack);
+    expect(stack).toHaveResource('AWS::Cognito::UserPoolDomain', {
+        Domain: "test-domain",
+        UserPoolId: {
+            Ref: "testlambdaopensearchstackCognitoUserPoolF5169460"
+        }
+    });
+    expect(stack).toHaveResource('AWS::OpenSearchService::Domain', {
+        DomainName: "test-domain",
+    });
+});
+test('Check cognito domain name override', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        cognitoDomainName: 'test-cogn-domain'
+    };
+    new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);
+    expect(stack).toHaveResource('AWS::Cognito::UserPoolDomain', {
+        Domain: 'test-cogn-domain'
+    });
+});
+test('Check engine version override', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        openSearchDomainProps: {
+            engineVersion: 'OpenSearch_1.0',
+        }
+    };
+    new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);
+    expect(stack).toHaveResource('AWS::OpenSearchService::Domain', {
+        EngineVersion: 'OpenSearch_1.0'
+    });
+});
+test("Test minimal deployment that deploys a VPC in 2 AZ without vpcProps", () => {
+    const stack = new cdk.Stack(undefined, undefined, {});
+    new lib_1.LambdaToOpenSearch(stack, "lambda-opensearch-stack", {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        deployVpc: true,
+    });
+    expect(stack).toHaveResource("AWS::Lambda::Function", {
+        VpcConfig: {
+            SecurityGroupIds: [
+                {
+                    "Fn::GetAtt": [
+                        "lambdaopensearchstackReplaceDefaultSecurityGroupsecuritygroup293B90D7",
+                        "GroupId",
+                    ],
+                },
+            ],
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B",
+                },
+                {
+                    Ref: "VpcisolatedSubnet2Subnet39217055",
+                }
+            ],
+        },
+    });
+    expect(stack).toHaveResourceLike("AWS::OpenSearchService::Domain", {
+        VPCOptions: {
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B"
+                },
+                {
+                    Ref: "VpcisolatedSubnet2Subnet39217055"
+                }
+            ]
+        }
+    });
+    expect(stack).toHaveResource("AWS::EC2::VPC", {
+        EnableDnsHostnames: true,
+        EnableDnsSupport: true,
+    });
+});
+test("Test minimal deployment that deploys a VPC in 3 AZ without vpcProps", () => {
+    const stack = new cdk.Stack(undefined, undefined, {
+        env: { account: "123456789012", region: 'us-east-1' },
+    });
+    new lib_1.LambdaToOpenSearch(stack, "lambda-opensearch-stack", {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        deployVpc: true,
+    });
+    expect(stack).toHaveResource("AWS::Lambda::Function", {
+        VpcConfig: {
+            SecurityGroupIds: [
+                {
+                    "Fn::GetAtt": [
+                        "lambdaopensearchstackReplaceDefaultSecurityGroupsecuritygroup293B90D7",
+                        "GroupId",
+                    ],
+                },
+            ],
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B",
+                },
+                {
+                    Ref: "VpcisolatedSubnet2Subnet39217055",
+                },
+                {
+                    Ref: "VpcisolatedSubnet3Subnet44F2537D",
+                },
+            ],
+        },
+    });
+    expect(stack).toHaveResourceLike("AWS::OpenSearchService::Domain", {
+        VPCOptions: {
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B"
+                },
+                {
+                    Ref: "VpcisolatedSubnet2Subnet39217055"
+                },
+                {
+                    Ref: "VpcisolatedSubnet3Subnet44F2537D"
+                }
+            ]
+        }
+    });
+    expect(stack).toHaveResource("AWS::EC2::VPC", {
+        EnableDnsHostnames: true,
+        EnableDnsSupport: true,
+    });
+});
+test("Test cluster deploy to 1 AZ when user set zoneAwarenessEnabled to false", () => {
+    const stack = new cdk.Stack(undefined, undefined, {
+        env: { account: "123456789012", region: 'us-east-1' },
+    });
+    const openSearchDomainProps = {
+        clusterConfig: {
+            dedicatedMasterCount: 3,
+            dedicatedMasterEnabled: true,
+            zoneAwarenessEnabled: false,
+            instanceCount: 3
+        }
+    };
+    new lib_1.LambdaToOpenSearch(stack, "lambda-opensearch-stack", {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        openSearchDomainProps,
+        deployVpc: true,
+        vpcProps: {
+            maxAzs: 1
+        }
+    });
+    expect(stack).toHaveResource("AWS::OpenSearchService::Domain", {
+        ClusterConfig: {
+            DedicatedMasterCount: 3,
+            DedicatedMasterEnabled: true,
+            InstanceCount: 3,
+            ZoneAwarenessEnabled: false,
+        }
+    });
+    expect(stack).toHaveResourceLike("AWS::OpenSearchService::Domain", {
+        VPCOptions: {
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B"
+                }
+            ]
+        }
+    });
+});
+test("Test cluster deploy to 2 AZ when user set availabilityZoneCount to 2", () => {
+    const stack = new cdk.Stack(undefined, undefined, {
+        env: { account: "123456789012", region: 'us-east-1' },
+    });
+    const openSearchDomainProps = {
+        clusterConfig: {
+            dedicatedMasterCount: 3,
+            dedicatedMasterEnabled: true,
+            instanceCount: 2,
+            zoneAwarenessEnabled: true,
+            zoneAwarenessConfig: {
+                availabilityZoneCount: 2
+            }
+        }
+    };
+    new lib_1.LambdaToOpenSearch(stack, "lambda-opensearch-stack", {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: 'test-domain',
+        openSearchDomainProps,
+        deployVpc: true,
+        vpcProps: {
+            maxAzs: 2
+        }
+    });
+    expect(stack).toHaveResource("AWS::OpenSearchService::Domain", {
+        ClusterConfig: {
+            DedicatedMasterCount: 3,
+            DedicatedMasterEnabled: true,
+            InstanceCount: 2,
+            ZoneAwarenessConfig: {
+                AvailabilityZoneCount: 2,
+            },
+            ZoneAwarenessEnabled: true,
+        }
+    });
+    expect(stack).toHaveResourceLike("AWS::OpenSearchService::Domain", {
+        VPCOptions: {
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B"
+                },
+                {
+                    Ref: "VpcisolatedSubnet2Subnet39217055"
+                }
+            ]
+        }
+    });
+});
+test('Test minimal deployment with an existing isolated VPC', () => {
+    const stack = new cdk.Stack(undefined, undefined, {
+        env: { account: "123456789012", region: 'us-east-1' },
+    });
+    const vpc = defaults.getTestVpc(stack, false, {
+        vpcName: "existing-isolated-vpc-test"
+    });
+    const construct = new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch', {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: "test",
+        existingVpc: vpc
+    });
+    expect(stack).toHaveResourceLike("AWS::EC2::VPC", {
+        Tags: [
+            {
+                Key: "Name",
+                Value: "existing-isolated-vpc-test"
+            }
+        ]
+    });
+    expect(stack).toHaveResourceLike("AWS::OpenSearchService::Domain", {
+        VPCOptions: {
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B"
+                },
+                {
+                    Ref: "VpcisolatedSubnet2Subnet39217055"
+                },
+                {
+                    Ref: "VpcisolatedSubnet3Subnet44F2537D"
+                }
+            ]
+        }
+    });
+    expect(stack).toCountResources("AWS::EC2::VPC", 1);
+    expect(construct.vpc).toBeDefined();
+});
+test('Test minimal deployment with an existing private VPC', () => {
+    const stack = new cdk.Stack(undefined, undefined, {
+        env: { account: "123456789012", region: 'us-east-1' },
+    });
+    const vpc = core_1.getTestVpc(stack, true, {
+        vpcName: "existing-private-vpc-test"
+    });
+    const construct = new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch', {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: "test",
+        existingVpc: vpc
+    });
+    expect(stack).toHaveResourceLike("AWS::EC2::VPC", {
+        Tags: [
+            {
+                Key: "Name",
+                Value: "existing-private-vpc-test"
+            }
+        ]
+    });
+    expect(stack).toHaveResourceLike("AWS::OpenSearchService::Domain", {
+        VPCOptions: {
+            SubnetIds: [
+                {
+                    Ref: "VpcPrivateSubnet1Subnet536B997A"
+                },
+                {
+                    Ref: "VpcPrivateSubnet2Subnet3788AAA1"
+                },
+                {
+                    Ref: "VpcPrivateSubnet3SubnetF258B56E"
+                }
+            ]
+        }
+    });
+    expect(stack).toCountResources("AWS::EC2::VPC", 1);
+    expect(construct.vpc).toBeDefined();
+});
+test('Test minimal deployment with VPC construct props', () => {
+    const stack = new cdk.Stack(undefined, undefined, {
+        env: { account: "123456789012", region: 'us-east-1' },
+    });
+    const construct = new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch', {
+        lambdaFunctionProps: getDefaultTestLambdaProps(),
+        openSearchDomainName: "test",
+        deployVpc: true,
+        vpcProps: {
+            vpcName: "vpc-props-test"
+        }
+    });
+    expect(stack).toHaveResourceLike("AWS::EC2::VPC", {
+        Tags: [
+            {
+                Key: "Name",
+                Value: "vpc-props-test"
+            }
+        ]
+    });
+    expect(stack).toHaveResourceLike("AWS::OpenSearchService::Domain", {
+        VPCOptions: {
+            SubnetIds: [
+                {
+                    Ref: "VpcisolatedSubnet1SubnetE62B1B9B"
+                },
+                {
+                    Ref: "VpcisolatedSubnet2Subnet39217055"
+                },
+                {
+                    Ref: "VpcisolatedSubnet3Subnet44F2537D"
+                }
+            ]
+        }
+    });
+    expect(stack).toCountResources("AWS::EC2::VPC", 1);
+    expect(construct.vpc).toBeDefined();
+});
+test('Test error for vpcProps and undefined deployVpc prop', () => {
+    const stack = new cdk.Stack();
+    const app = () => {
+        new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch', {
+            lambdaFunctionProps: getDefaultTestLambdaProps(),
+            openSearchDomainName: "test",
+            vpcProps: {
+                vpcName: "existing-vpc-test"
+            }
+        });
+    };
+    expect(app).toThrowError("Error - deployVpc must be true when defining vpcProps");
+});
+test('Test error for Lambda function VPC props', () => {
+    const stack = new cdk.Stack();
+    const vpc = defaults.getTestVpc(stack);
+    const app = () => {
+        new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch', {
+            lambdaFunctionProps: defaults.consolidateProps(getDefaultTestLambdaProps(), { vpc }),
+            openSearchDomainName: "test",
+            deployVpc: true,
+        });
+    };
+    expect(app).toThrowError("Error - Define VPC using construct parameters not Lambda function props");
+});
+test('Test error for the OpenSearch domain VPC props', () => {
+    const stack = new cdk.Stack();
+    const app = () => {
+        new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch', {
+            lambdaFunctionProps: getDefaultTestLambdaProps(),
+            openSearchDomainProps: {
+                vpcOptions: {
+                    subnetIds: ['fake-ids'],
+                    securityGroupIds: ['fake-sgs']
+                }
+            },
+            openSearchDomainName: "test",
+            deployVpc: true,
+        });
+    };
+    expect(app).toThrowError("Error - Define VPC using construct parameters not the OpenSearch Service props");
+});
+test('Test error for missing existingLambdaObj or lambdaFunctionProps', () => {
+    const stack = new cdk.Stack();
+    const props = {
+        openSearchDomainName: 'test-domain'
+    };
+    try {
+        new lib_1.LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(Error);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-opensearch.test.js","sourceRoot":"","sources":["lambda-opensearch.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\nimport { LambdaToOpenSearch, LambdaToOpenSearchProps } from \"../lib\";\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as cdk from \"aws-cdk-lib\";\nimport '@aws-cdk/assert/jest';\nimport * as defaults from '@aws-solutions-constructs/core';\nimport { getTestVpc } from \"@aws-solutions-constructs/core\";\n\nfunction deployLambdaToOpenSearch(stack: cdk.Stack) {\n  const props: LambdaToOpenSearchProps = {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain'\n  };\n\n  return new LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);\n}\n\nfunction getDefaultTestLambdaProps(): lambda.FunctionProps {\n  return {\n    code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n    runtime: lambda.Runtime.NODEJS_14_X,\n    handler: 'index.handler',\n  };\n}\n\ntest('Check pattern properties', () => {\n  const stack = new cdk.Stack();\n\n  const construct: LambdaToOpenSearch = deployLambdaToOpenSearch(stack);\n\n  expect(construct.lambdaFunction).toBeDefined();\n  expect(construct.openSearchDomain).toBeDefined();\n  expect(construct.identityPool).toBeDefined();\n  expect(construct.userPool).toBeDefined();\n  expect(construct.userPoolClient).toBeDefined();\n  expect(construct.cloudWatchAlarms).toBeDefined();\n  expect(construct.openSearchRole).toBeDefined();\n});\n\ntest('Check properties with no CloudWatch alarms ', () => {\n  const stack = new cdk.Stack();\n\n  const props: LambdaToOpenSearchProps = {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    createCloudWatchAlarms: false\n  };\n\n  const construct = new LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);\n\n  expect(construct.lambdaFunction).toBeDefined();\n  expect(construct.openSearchDomain).toBeDefined();\n  expect(construct.identityPool).toBeDefined();\n  expect(construct.userPool).toBeDefined();\n  expect(construct.userPoolClient).toBeDefined();\n  expect(construct.cloudWatchAlarms).toBeUndefined();\n  expect(construct.openSearchRole).toBeDefined();\n});\n\ntest('Check for an existing Lambda object', () => {\n  const stack = new cdk.Stack();\n\n  const existingLambdaObj = defaults.buildLambdaFunction(stack, {\n    lambdaFunctionProps: {\n      code: lambda.Code.fromAsset(`${__dirname}/lambda`),\n      runtime: lambda.Runtime.NODEJS_14_X,\n      handler: 'index.handler',\n      functionName: 'test-function'\n    }\n  });\n\n  const props: LambdaToOpenSearchProps = {\n    openSearchDomainName: 'test-domain',\n    existingLambdaObj\n  };\n\n  new LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);\n\n  expect(stack).toHaveResource('AWS::Lambda::Function', {\n    FunctionName: 'test-function'\n  });\n\n});\n\ntest('Check Lambda function custom environment variable', () => {\n  const stack = new cdk.Stack();\n  const props: LambdaToOpenSearchProps = {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    domainEndpointEnvironmentVariableName: 'CUSTOM_DOMAIN_ENDPOINT'\n  };\n\n  new LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);\n\n  expect(stack).toHaveResource('AWS::Lambda::Function', {\n    Handler: 'index.handler',\n    Runtime: 'nodejs14.x',\n    Environment: {\n      Variables: {\n        AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',\n        CUSTOM_DOMAIN_ENDPOINT: {\n          'Fn::GetAtt': [\n            'testlambdaopensearchstackOpenSearchDomain46D6A86E',\n            'DomainEndpoint'\n          ]\n        }\n      }\n    }\n  });\n});\n\ntest('Check domain name', () => {\n  const stack = new cdk.Stack();\n\n  deployLambdaToOpenSearch(stack);\n\n  expect(stack).toHaveResource('AWS::Cognito::UserPoolDomain', {\n    Domain: \"test-domain\",\n    UserPoolId: {\n      Ref: \"testlambdaopensearchstackCognitoUserPoolF5169460\"\n    }\n  });\n\n  expect(stack).toHaveResource('AWS::OpenSearchService::Domain', {\n    DomainName: \"test-domain\",\n  });\n});\n\ntest('Check cognito domain name override', () => {\n  const stack = new cdk.Stack();\n  const props: LambdaToOpenSearchProps = {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    cognitoDomainName: 'test-cogn-domain'\n  };\n\n  new LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);\n\n  expect(stack).toHaveResource('AWS::Cognito::UserPoolDomain', {\n    Domain: 'test-cogn-domain'\n  });\n});\n\ntest('Check engine version override', () => {\n  const stack = new cdk.Stack();\n  const props: LambdaToOpenSearchProps = {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    openSearchDomainProps: {\n      engineVersion: 'OpenSearch_1.0',\n    }\n  };\n\n  new LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);\n\n  expect(stack).toHaveResource('AWS::OpenSearchService::Domain', {\n    EngineVersion: 'OpenSearch_1.0'\n  });\n});\n\ntest(\"Test minimal deployment that deploys a VPC in 2 AZ without vpcProps\", () => {\n  const stack = new cdk.Stack(undefined, undefined, {});\n\n  new LambdaToOpenSearch(stack, \"lambda-opensearch-stack\", {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    deployVpc: true,\n  });\n\n  expect(stack).toHaveResource(\"AWS::Lambda::Function\", {\n    VpcConfig: {\n      SecurityGroupIds: [\n        {\n          \"Fn::GetAtt\": [\n            \"lambdaopensearchstackReplaceDefaultSecurityGroupsecuritygroup293B90D7\",\n            \"GroupId\",\n          ],\n        },\n      ],\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\",\n        },\n        {\n          Ref: \"VpcisolatedSubnet2Subnet39217055\",\n        }\n      ],\n    },\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::OpenSearchService::Domain\", {\n    VPCOptions: {\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet2Subnet39217055\"\n        }\n      ]\n    }\n  });\n\n  expect(stack).toHaveResource(\"AWS::EC2::VPC\", {\n    EnableDnsHostnames: true,\n    EnableDnsSupport: true,\n  });\n});\n\ntest(\"Test minimal deployment that deploys a VPC in 3 AZ without vpcProps\", () => {\n  const stack = new cdk.Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n\n  new LambdaToOpenSearch(stack, \"lambda-opensearch-stack\", {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    deployVpc: true,\n  });\n\n  expect(stack).toHaveResource(\"AWS::Lambda::Function\", {\n    VpcConfig: {\n      SecurityGroupIds: [\n        {\n          \"Fn::GetAtt\": [\n            \"lambdaopensearchstackReplaceDefaultSecurityGroupsecuritygroup293B90D7\",\n            \"GroupId\",\n          ],\n        },\n      ],\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\",\n        },\n        {\n          Ref: \"VpcisolatedSubnet2Subnet39217055\",\n        },\n        {\n          Ref: \"VpcisolatedSubnet3Subnet44F2537D\",\n        },\n      ],\n    },\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::OpenSearchService::Domain\", {\n    VPCOptions: {\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet2Subnet39217055\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet3Subnet44F2537D\"\n        }\n      ]\n    }\n  });\n\n  expect(stack).toHaveResource(\"AWS::EC2::VPC\", {\n    EnableDnsHostnames: true,\n    EnableDnsSupport: true,\n  });\n});\n\ntest(\"Test cluster deploy to 1 AZ when user set zoneAwarenessEnabled to false\", () => {\n  const stack = new cdk.Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n\n  const openSearchDomainProps = {\n    clusterConfig: {\n      dedicatedMasterCount: 3,\n      dedicatedMasterEnabled: true,\n      zoneAwarenessEnabled: false,\n      instanceCount: 3\n    }\n  };\n\n  new LambdaToOpenSearch(stack, \"lambda-opensearch-stack\", {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    openSearchDomainProps,\n    deployVpc: true,\n    vpcProps: {\n      maxAzs: 1\n    }\n  });\n\n  expect(stack).toHaveResource(\"AWS::OpenSearchService::Domain\", {\n    ClusterConfig: {\n      DedicatedMasterCount: 3,\n      DedicatedMasterEnabled: true,\n      InstanceCount: 3,\n      ZoneAwarenessEnabled: false,\n    }\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::OpenSearchService::Domain\", {\n    VPCOptions: {\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\"\n        }\n      ]\n    }\n  });\n});\n\ntest(\"Test cluster deploy to 2 AZ when user set availabilityZoneCount to 2\", () => {\n  const stack = new cdk.Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n\n  const openSearchDomainProps = {\n    clusterConfig: {\n      dedicatedMasterCount: 3,\n      dedicatedMasterEnabled: true,\n      instanceCount: 2,\n      zoneAwarenessEnabled: true,\n      zoneAwarenessConfig: {\n        availabilityZoneCount: 2\n      }\n    }\n  };\n\n  new LambdaToOpenSearch(stack, \"lambda-opensearch-stack\", {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: 'test-domain',\n    openSearchDomainProps,\n    deployVpc: true,\n    vpcProps: {\n      maxAzs: 2\n    }\n  });\n\n  expect(stack).toHaveResource(\"AWS::OpenSearchService::Domain\", {\n    ClusterConfig: {\n      DedicatedMasterCount: 3,\n      DedicatedMasterEnabled: true,\n      InstanceCount: 2,\n      ZoneAwarenessConfig: {\n        AvailabilityZoneCount: 2,\n      },\n      ZoneAwarenessEnabled: true,\n    }\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::OpenSearchService::Domain\", {\n    VPCOptions: {\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet2Subnet39217055\"\n        }\n      ]\n    }\n  });\n});\n\ntest('Test minimal deployment with an existing isolated VPC', () => {\n  const stack = new cdk.Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n\n  const vpc = defaults.getTestVpc(stack, false, {\n    vpcName: \"existing-isolated-vpc-test\"\n  });\n\n  const construct = new LambdaToOpenSearch(stack, 'test-lambda-opensearch', {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: \"test\",\n    existingVpc: vpc\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::EC2::VPC\", {\n    Tags: [\n      {\n        Key: \"Name\",\n        Value: \"existing-isolated-vpc-test\"\n      }\n    ]\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::OpenSearchService::Domain\", {\n    VPCOptions: {\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet2Subnet39217055\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet3Subnet44F2537D\"\n        }\n      ]\n    }\n  });\n\n  expect(stack).toCountResources(\"AWS::EC2::VPC\", 1);\n  expect(construct.vpc).toBeDefined();\n});\n\ntest('Test minimal deployment with an existing private VPC', () => {\n  const stack = new cdk.Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n\n  const vpc = getTestVpc(stack, true, {\n    vpcName: \"existing-private-vpc-test\"\n  });\n\n  const construct = new LambdaToOpenSearch(stack, 'test-lambda-opensearch', {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: \"test\",\n    existingVpc: vpc\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::EC2::VPC\", {\n    Tags: [\n      {\n        Key: \"Name\",\n        Value: \"existing-private-vpc-test\"\n      }\n    ]\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::OpenSearchService::Domain\", {\n    VPCOptions: {\n      SubnetIds: [\n        {\n          Ref: \"VpcPrivateSubnet1Subnet536B997A\"\n        },\n        {\n          Ref: \"VpcPrivateSubnet2Subnet3788AAA1\"\n        },\n        {\n          Ref: \"VpcPrivateSubnet3SubnetF258B56E\"\n        }\n      ]\n    }\n  });\n\n  expect(stack).toCountResources(\"AWS::EC2::VPC\", 1);\n  expect(construct.vpc).toBeDefined();\n});\n\ntest('Test minimal deployment with VPC construct props', () => {\n  const stack = new cdk.Stack(undefined, undefined, {\n    env: { account: \"123456789012\", region: 'us-east-1' },\n  });\n\n  const construct = new LambdaToOpenSearch(stack, 'test-lambda-opensearch', {\n    lambdaFunctionProps: getDefaultTestLambdaProps(),\n    openSearchDomainName: \"test\",\n    deployVpc: true,\n    vpcProps: {\n      vpcName: \"vpc-props-test\"\n    }\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::EC2::VPC\", {\n    Tags: [\n      {\n        Key: \"Name\",\n        Value: \"vpc-props-test\"\n      }\n    ]\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::OpenSearchService::Domain\", {\n    VPCOptions: {\n      SubnetIds: [\n        {\n          Ref: \"VpcisolatedSubnet1SubnetE62B1B9B\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet2Subnet39217055\"\n        },\n        {\n          Ref: \"VpcisolatedSubnet3Subnet44F2537D\"\n        }\n      ]\n    }\n  });\n\n  expect(stack).toCountResources(\"AWS::EC2::VPC\", 1);\n  expect(construct.vpc).toBeDefined();\n});\n\ntest('Test error for vpcProps and undefined deployVpc prop', () => {\n  const stack = new cdk.Stack();\n\n  const app = () => {\n    new LambdaToOpenSearch(stack, 'test-lambda-opensearch', {\n      lambdaFunctionProps: getDefaultTestLambdaProps(),\n      openSearchDomainName: \"test\",\n      vpcProps: {\n        vpcName: \"existing-vpc-test\"\n      }\n    });\n  };\n\n  expect(app).toThrowError(\"Error - deployVpc must be true when defining vpcProps\");\n});\n\ntest('Test error for Lambda function VPC props', () => {\n  const stack = new cdk.Stack();\n\n  const vpc = defaults.getTestVpc(stack);\n\n  const app = () => {\n    new LambdaToOpenSearch(stack, 'test-lambda-opensearch', {\n      lambdaFunctionProps: defaults.consolidateProps(getDefaultTestLambdaProps(), { vpc }),\n      openSearchDomainName: \"test\",\n      deployVpc: true,\n    });\n  };\n\n  expect(app).toThrowError(\"Error - Define VPC using construct parameters not Lambda function props\");\n});\n\ntest('Test error for the OpenSearch domain VPC props', () => {\n  const stack = new cdk.Stack();\n\n  const app = () => {\n    new LambdaToOpenSearch(stack, 'test-lambda-opensearch', {\n      lambdaFunctionProps: getDefaultTestLambdaProps(),\n      openSearchDomainProps: {\n        vpcOptions: {\n          subnetIds: ['fake-ids'],\n          securityGroupIds: ['fake-sgs']\n        }\n      },\n      openSearchDomainName: \"test\",\n      deployVpc: true,\n    });\n  };\n\n  expect(app).toThrowError(\"Error - Define VPC using construct parameters not the OpenSearch Service props\");\n});\n\ntest('Test error for missing existingLambdaObj or lambdaFunctionProps', () => {\n  const stack = new cdk.Stack();\n\n  const props: LambdaToOpenSearchProps = {\n    openSearchDomainName: 'test-domain'\n  };\n\n  try {\n    new LambdaToOpenSearch(stack, 'test-lambda-opensearch-stack', props);\n  } catch (e) {\n    expect(e).toBeInstanceOf(Error);\n  }\n});\n"]}