@aws-solutions-constructs/core 2.41.0 → 2.43.0

package/test/kendra-helper.test.js

@@ -0,0 +1,489 @@
+"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");
+// import * as defaults from '../index';
+const assertions_1 = require("aws-cdk-lib/assertions");
+const kendra_helper_1 = require("../lib/kendra-helper");
+const kendra = require("aws-cdk-lib/aws-kendra");
+const iam = require("aws-cdk-lib/aws-iam");
+// import { Construct } from 'constructs';
+test('Launch Kendra index with defaults', () => {
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Kendra::Index', {});
+    template.resourceCountIs("AWS::IAM::Role", 1);
+});
+test('Confirm kendra has log wrting privileges', () => {
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties("AWS::IAM::Role", {
+        Description: "Allow Kendra index to write CloudWatch Logs",
+        Policies: [
+            {
+                PolicyDocument: {
+                    Statement: [
+                        {
+                            Action: "cloudwatch:PutMetricData",
+                            Condition: {
+                                StringEquals: {
+                                    "cloudwatch:namespace": "AWS/Kendra"
+                                }
+                            },
+                            Effect: "Allow",
+                            Resource: "*"
+                        },
+                        {
+                            Action: "logs:CreateLogGroup",
+                            Effect: "Allow",
+                            Resource: {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:aws:logs:",
+                                        {
+                                            Ref: "AWS::Region"
+                                        },
+                                        ":",
+                                        {
+                                            Ref: "AWS::AccountId"
+                                        },
+                                        ":log-group:/aws/kendra/*"
+                                    ]
+                                ]
+                            }
+                        },
+                        {
+                            Action: "logs:DescribeLogGroups",
+                            Effect: "Allow",
+                            Resource: {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        {
+                                            Ref: "AWS::Partition"
+                                        },
+                                        ":logs:",
+                                        {
+                                            Ref: "AWS::Region"
+                                        },
+                                        ":",
+                                        {
+                                            Ref: "AWS::AccountId"
+                                        },
+                                        ":log-group:/aws/kendra/*"
+                                    ]
+                                ]
+                            }
+                        },
+                        {
+                            Action: [
+                                "logs:CreateLogStream",
+                                "logs:PutLogEvents",
+                                "logs:DescribeLogStream"
+                            ],
+                            Effect: "Allow",
+                            Resource: {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        {
+                                            Ref: "AWS::Partition"
+                                        },
+                                        ":logs:",
+                                        {
+                                            Ref: "AWS::Region"
+                                        },
+                                        ":",
+                                        {
+                                            Ref: "AWS::AccountId"
+                                        },
+                                        ":log-group:/aws/kendra/*:log-stream:*"
+                                    ]
+                                ]
+                            }
+                        }
+                    ],
+                    Version: "2012-10-17"
+                },
+                PolicyName: "AllowLogging"
+            }
+        ],
+    });
+});
+test('Launch Kendra index with custom properties', () => {
+    const testName = 'test-index-name';
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    kendra_helper_1.buildKendraIndex(stack, 'test', {
+        kendraIndexProps: {
+            name: testName
+        }
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Kendra::Index', {
+        Name: testName
+    });
+    template.resourceCountIs("AWS::IAM::Role", 1);
+});
+test('Launch Kendra index with existing role', () => {
+    const fakeRoleArn = 'fake-arn';
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    kendra_helper_1.buildKendraIndex(stack, 'test', {
+        kendraIndexProps: {
+            roleArn: fakeRoleArn
+        }
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Kendra::Index', {
+        RoleArn: fakeRoleArn
+    });
+    template.resourceCountIs("AWS::IAM::Role", 0);
+});
+test('use existing Kendra index', () => {
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const indexProps = {
+        edition: 'DEVELOPER_EDITION',
+        name: 'kendra-test',
+        roleArn: 'fake-arn'
+    };
+    const testIndex = new kendra.CfnIndex(stack, `test`, indexProps);
+    kendra_helper_1.buildKendraIndex(stack, 'test', {
+        existingIndexObj: testIndex
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs('AWS::Kendra::Index', 1);
+});
+test('Launch Kendra index with an S3 data source', () => {
+    const testName = 'test-name';
+    const testBucketName = 'test-bucket-name';
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const newIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    kendra_helper_1.AddKendraDataSource(stack, 'testSource', newIndex, {
+        type: 'S3',
+        name: testName,
+        dataSourceConfiguration: {
+            s3Configuration: {
+                bucketName: testBucketName,
+            }
+        },
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs('AWS::Kendra::Index', 1);
+    template.resourceCountIs("AWS::Kendra::DataSource", 1);
+    template.resourceCountIs("AWS::IAM::Role", 2);
+    template.hasResourceProperties("AWS::Kendra::DataSource", {
+        Name: testName,
+        RoleArn: assertions_1.Match.anyValue(),
+        Type: 'S3',
+        DataSourceConfiguration: {
+            S3Configuration: {
+                BucketName: testBucketName
+            }
+        }
+    });
+    template.hasResourceProperties("AWS::IAM::Role", {
+        AssumeRolePolicyDocument: {
+            Statement: [
+                {
+                    Action: "sts:AssumeRole",
+                    Effect: "Allow",
+                    Principal: {
+                        Service: "kendra.amazonaws.com"
+                    }
+                }
+            ],
+            Version: "2012-10-17"
+        },
+        Policies: [
+            {
+                PolicyDocument: {
+                    Statement: [
+                        {
+                            Action: "s3:GetObject",
+                            Effect: "Allow",
+                            Resource: `arn:aws:s3:::${testBucketName}/*`
+                        },
+                        {
+                            Action: "s3:ListBucket",
+                            Effect: "Allow",
+                            Resource: `arn:aws:s3:::${testBucketName}`
+                        },
+                        {
+                            Action: [
+                                "kendra:BatchPutDocument",
+                                "kendra:BatchDeleteDocument"
+                            ],
+                            Effect: "Allow",
+                            Resource: {
+                                "Fn::GetAtt": [
+                                    "kendraindextest",
+                                    "Arn"
+                                ]
+                            }
+                        }
+                    ],
+                    Version: "2012-10-17"
+                },
+                PolicyName: "s3CrawlPolicy"
+            }
+        ]
+    });
+});
+test('Launch Kendra index with a customized S3 data source', () => {
+    const testName = 'test-name';
+    const testBucketName = 'test-bucket-name';
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const newIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    kendra_helper_1.AddKendraDataSource(stack, 'testSource', newIndex, {
+        type: 'S3',
+        name: testName,
+        dataSourceConfiguration: {
+            s3Configuration: {
+                bucketName: testBucketName,
+                inclusionPatterns: ['IncludeThis'],
+            }
+        },
+    });
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties("AWS::Kendra::DataSource", {
+        DataSourceConfiguration: {
+            S3Configuration: {
+                BucketName: "test-bucket-name",
+                InclusionPatterns: ['IncludeThis'],
+            }
+        },
+    });
+    template.resourceCountIs('AWS::Kendra::Index', 1);
+    template.resourceCountIs("AWS::Kendra::DataSource", 1);
+    template.resourceCountIs("AWS::IAM::Role", 2);
+});
+test('Launch Kendra index with non-implemented data source', () => {
+    const nonImplementedSourceType = "WEBCRAWLER";
+    const nonImplementedSourceName = "test-other-source";
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const testIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    // Create a role
+    const fakeRole = new iam.Role(stack, 'fakeRole', {
+        assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),
+        roleName: 'externalFakeRole'
+    });
+    // Create data source props
+    const dataSourceProps = {
+        name: nonImplementedSourceName,
+        roleArn: fakeRole.roleArn,
+        type: nonImplementedSourceType,
+    };
+    // Add a data source
+    kendra_helper_1.AddKendraDataSource(stack, 'test-other-source', testIndex, dataSourceProps);
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs('AWS::Kendra::Index', 1);
+    template.resourceCountIs('AWS::Kendra::DataSource', 1);
+    template.resourceCountIs('AWS::IAM::Role', 2);
+    template.hasResourceProperties("AWS::Kendra::DataSource", {
+        Name: nonImplementedSourceName,
+        Type: nonImplementedSourceType
+    });
+});
+test('Confirm error if client supplies an index in the DataSource props', () => {
+    const nonImplementedSourceType = "WEBCRAWLER";
+    const nonImplementedSourceName = "test-other-source";
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const testIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    // Create a role
+    const fakeRole = new iam.Role(stack, 'fakeRole', {
+        assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),
+        roleName: 'externalFakeRole'
+    });
+    // Create data source props
+    const dataSourceProps = {
+        name: nonImplementedSourceName,
+        roleArn: fakeRole.roleArn,
+        type: nonImplementedSourceType,
+        indexId: testIndex.attrId,
+    };
+    // Add a data source
+    const app = () => {
+        kendra_helper_1.AddKendraDataSource(stack, 'test-other-source', testIndex, dataSourceProps);
+    };
+    expect(app).toThrowError(/Invalid DataSource prop specified - Construct must set the indexId prop/);
+});
+test('Confirm error if does not provide DataSource configuration', () => {
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const testIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    // Create data source props
+    const dataSourceProps = {
+        type: "S3"
+    };
+    // Add a data source
+    const app = () => {
+        kendra_helper_1.AddKendraDataSource(stack, 'test-bad-source', testIndex, dataSourceProps);
+    };
+    expect(app).toThrowError(/Error - an S3 Kendra DataSource requires an DataSourceCofiguration prop/);
+});
+test('Confirm error if does not provide S3 DataSource configuration', () => {
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const testIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    // Create data source props
+    const dataSourceProps = {
+        type: "S3",
+        dataSourceConfiguration: {}
+    };
+    // Add a data source
+    const app = () => {
+        kendra_helper_1.AddKendraDataSource(stack, 'test-bad-source', testIndex, dataSourceProps);
+    };
+    expect(app).toThrowError(/Error - an S3 Kendra DataSource requires an DataSourceCofiguration.S3Configuration prop/);
+});
+test('Confirm error if does not provide S3 Bucketname', () => {
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const testIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    // Create data source props
+    const dataSourceProps = {
+        type: "S3",
+        dataSourceConfiguration: {
+            s3Configuration: {
+            // Going through some hoops here to force this conditiion, but since we
+            // allow | any for props, a client could do this
+            }
+        }
+    };
+    // Add a data source
+    const app = () => {
+        kendra_helper_1.AddKendraDataSource(stack, 'test-bad-source', testIndex, dataSourceProps);
+    };
+    expect(app).toThrowError(/Error - an S3 Kendra DataSource requires the DataSourceCofiguration.S3Configuration.bucketName prop/);
+});
+test('Launch Kendra index with multiple data sources', () => {
+    const testName = 'test-name';
+    const testBucketName = 'test-bucket-name';
+    const nonImplementedSourceType = "WEBCRAWLER";
+    const nonImplementedSourceName = "test-other-source";
+    const stack = new aws_cdk_lib_1.Stack(undefined, undefined);
+    const newIndex = kendra_helper_1.buildKendraIndex(stack, 'test', {});
+    const s3DataSourceProps = {
+        type: 'S3',
+        name: testName,
+        dataSourceConfiguration: {
+            s3Configuration: {
+                bucketName: testBucketName,
+            }
+        },
+    };
+    // Create a role
+    const fakeRole = new iam.Role(stack, 'fakeRole', {
+        assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),
+        roleName: 'externalFakeRole'
+    });
+    // Create data source props
+    const otherDataSourceProps = {
+        name: nonImplementedSourceName,
+        roleArn: fakeRole.roleArn,
+        type: nonImplementedSourceType
+    };
+    // Add a data source
+    const sourceObjects = kendra_helper_1.AddMultipleKendraDataSources(stack, 'test-other-source', newIndex, [
+        s3DataSourceProps,
+        otherDataSourceProps
+    ]);
+    expect(sourceObjects.length).toEqual(2);
+    expect(sourceObjects[0].type).toEqual('S3');
+    expect(sourceObjects[1].name).toEqual(nonImplementedSourceName);
+    const template = assertions_1.Template.fromStack(stack);
+    template.resourceCountIs('AWS::Kendra::Index', 1);
+    template.resourceCountIs('AWS::Kendra::DataSource', 2);
+    template.resourceCountIs('AWS::IAM::Role', 3);
+    // Look for S3 data source
+    template.hasResourceProperties("AWS::Kendra::DataSource", {
+        Name: testName,
+        RoleArn: assertions_1.Match.anyValue(),
+        Type: 'S3',
+        DataSourceConfiguration: {
+            S3Configuration: {
+                BucketName: testBucketName
+            }
+        }
+    });
+    template.hasResourceProperties("AWS::IAM::Role", {
+        AssumeRolePolicyDocument: {
+            Statement: [
+                {
+                    Action: "sts:AssumeRole",
+                    Effect: "Allow",
+                    Principal: {
+                        Service: "kendra.amazonaws.com"
+                    }
+                }
+            ],
+            Version: "2012-10-17"
+        },
+        Policies: [
+            {
+                PolicyDocument: {
+                    Statement: [
+                        {
+                            Action: "s3:GetObject",
+                            Effect: "Allow",
+                            Resource: `arn:aws:s3:::${testBucketName}/*`
+                        },
+                        {
+                            Action: "s3:ListBucket",
+                            Effect: "Allow",
+                            Resource: `arn:aws:s3:::${testBucketName}`
+                        },
+                        {
+                            Action: [
+                                "kendra:BatchPutDocument",
+                                "kendra:BatchDeleteDocument"
+                            ],
+                            Effect: "Allow",
+                            Resource: {
+                                "Fn::GetAtt": [
+                                    "kendraindextest",
+                                    "Arn"
+                                ]
+                            }
+                        }
+                    ],
+                    Version: "2012-10-17"
+                },
+                PolicyName: "s3CrawlPolicy"
+            }
+        ]
+    });
+    // Look for non-implemented data source
+    template.hasResourceProperties("AWS::Kendra::DataSource", {
+        Name: nonImplementedSourceName,
+        Type: nonImplementedSourceType,
+        IndexId: assertions_1.Match.anyValue()
+    });
+});
+test('Confirm Errof for bad kendra Permission in normalizeKendraPermissions()', () => {
+    const inputs = ["read", "submitfeedback", "write"];
+    const outputs = kendra_helper_1.normalizeKendraPermissions(inputs);
+    expect(outputs.includes("READ")).toBeTruthy();
+    expect(outputs.includes("SUBMITFEEDBACK")).toBeTruthy();
+    expect(outputs.includes("WRITE")).toBeTruthy();
+});
+test('Confirm successful operation of normalizeKendraPermissions()', () => {
+    const inputs = ["badvalue", "write"];
+    const app = () => {
+        kendra_helper_1.normalizeKendraPermissions(inputs);
+    };
+    expect(app).toThrowError(/Invalid indexPermission value - valid values are "READ", "SUBMITFEEDBACK" and "WRITE"/);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kendra-helper.test.js","sourceRoot":"","sources":["kendra-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';\n// import * as defaults from '../index';\nimport { Match, Template } from 'aws-cdk-lib/assertions';\nimport { buildKendraIndex, AddKendraDataSource, AddMultipleKendraDataSources, normalizeKendraPermissions } from '../lib/kendra-helper';\nimport * as kendra from 'aws-cdk-lib/aws-kendra';\nimport * as iam from 'aws-cdk-lib/aws-iam';\n\n// import { Construct } from 'constructs';\n\ntest('Launch Kendra index with defaults', () => {\n  const stack = new Stack(undefined, undefined);\n\n  buildKendraIndex(stack, 'test', {});\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::Kendra::Index', {});\n  template.resourceCountIs(\"AWS::IAM::Role\", 1);\n});\n\ntest('Confirm kendra has log wrting privileges', () => {\n  const stack = new Stack(undefined, undefined);\n\n  buildKendraIndex(stack, 'test', {});\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties(\"AWS::IAM::Role\", {\n    Description: \"Allow Kendra index to write CloudWatch Logs\",\n    Policies: [\n      {\n        PolicyDocument: {\n          Statement: [\n            {\n              Action: \"cloudwatch:PutMetricData\",\n              Condition: {\n                StringEquals: {\n                  \"cloudwatch:namespace\": \"AWS/Kendra\"\n                }\n              },\n              Effect: \"Allow\",\n              Resource: \"*\"\n            },\n            {\n              Action: \"logs:CreateLogGroup\",\n              Effect: \"Allow\",\n              Resource: {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:aws:logs:\",\n                    {\n                      Ref: \"AWS::Region\"\n                    },\n                    \":\",\n                    {\n                      Ref: \"AWS::AccountId\"\n                    },\n                    \":log-group:/aws/kendra/*\"\n                  ]\n                ]\n              }\n            },\n            {\n              Action: \"logs:DescribeLogGroups\",\n              Effect: \"Allow\",\n              Resource: {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    {\n                      Ref: \"AWS::Partition\"\n                    },\n                    \":logs:\",\n                    {\n                      Ref: \"AWS::Region\"\n                    },\n                    \":\",\n                    {\n                      Ref: \"AWS::AccountId\"\n                    },\n                    \":log-group:/aws/kendra/*\"\n                  ]\n                ]\n              }\n            },\n            {\n              Action: [\n                \"logs:CreateLogStream\",\n                \"logs:PutLogEvents\",\n                \"logs:DescribeLogStream\"\n              ],\n              Effect: \"Allow\",\n              Resource: {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    {\n                      Ref: \"AWS::Partition\"\n                    },\n                    \":logs:\",\n                    {\n                      Ref: \"AWS::Region\"\n                    },\n                    \":\",\n                    {\n                      Ref: \"AWS::AccountId\"\n                    },\n                    \":log-group:/aws/kendra/*:log-stream:*\"\n                  ]\n                ]\n              }\n            }\n          ],\n          Version: \"2012-10-17\"\n        },\n        PolicyName: \"AllowLogging\"\n      }\n    ],\n  });\n});\n\ntest('Launch Kendra index with custom properties', () => {\n  const testName = 'test-index-name';\n  const stack = new Stack(undefined, undefined);\n\n  buildKendraIndex(stack, 'test', {\n    kendraIndexProps: {\n      name: testName\n    }\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::Kendra::Index', {\n    Name: testName\n  });\n  template.resourceCountIs(\"AWS::IAM::Role\", 1);\n});\n\ntest('Launch Kendra index with existing role', () => {\n  const fakeRoleArn = 'fake-arn';\n  const stack = new Stack(undefined, undefined);\n\n  buildKendraIndex(stack, 'test', {\n    kendraIndexProps: {\n      roleArn: fakeRoleArn\n    }\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::Kendra::Index', {\n    RoleArn: fakeRoleArn\n  });\n  template.resourceCountIs(\"AWS::IAM::Role\", 0);\n});\n\ntest('use existing Kendra index', () => {\n  const stack = new Stack(undefined, undefined);\n\n  const indexProps: kendra.CfnIndexProps = {\n    edition: 'DEVELOPER_EDITION',\n    name: 'kendra-test',\n    roleArn: 'fake-arn'\n  };\n\n  const testIndex = new kendra.CfnIndex(stack, `test`, indexProps);\n\n  buildKendraIndex(stack, 'test', {\n    existingIndexObj: testIndex\n  });\n\n  const template = Template.fromStack(stack);\n  template.resourceCountIs('AWS::Kendra::Index', 1);\n});\n\ntest('Launch Kendra index with an S3 data source', () => {\n  const testName = 'test-name';\n  const testBucketName = 'test-bucket-name';\n  const stack = new Stack(undefined, undefined);\n\n  const newIndex = buildKendraIndex(stack, 'test', {});\n\n  AddKendraDataSource(stack, 'testSource', newIndex, {\n    type: 'S3',\n    name: testName,\n    dataSourceConfiguration: {\n      s3Configuration: {\n        bucketName: testBucketName,\n      }\n    },\n  });\n\n  const template = Template.fromStack(stack);\n  template.resourceCountIs('AWS::Kendra::Index', 1);\n  template.resourceCountIs(\"AWS::Kendra::DataSource\", 1);\n  template.resourceCountIs(\"AWS::IAM::Role\", 2);\n  template.hasResourceProperties(\"AWS::Kendra::DataSource\", {\n    Name: testName,\n    RoleArn: Match.anyValue(),\n    Type: 'S3',\n    DataSourceConfiguration: {\n      S3Configuration: {\n        BucketName: testBucketName\n      }\n    }\n  });\n  template.hasResourceProperties(\"AWS::IAM::Role\", {\n    AssumeRolePolicyDocument: {\n      Statement: [\n        {\n          Action: \"sts:AssumeRole\",\n          Effect: \"Allow\",\n          Principal: {\n            Service: \"kendra.amazonaws.com\"\n          }\n        }\n      ],\n      Version: \"2012-10-17\"\n    },\n    Policies: [\n      {\n        PolicyDocument: {\n          Statement: [\n            {\n              Action: \"s3:GetObject\",\n              Effect: \"Allow\",\n              Resource: `arn:aws:s3:::${testBucketName}/*`\n            },\n            {\n              Action: \"s3:ListBucket\",\n              Effect: \"Allow\",\n              Resource: `arn:aws:s3:::${testBucketName}`\n            },\n            {\n              Action: [\n                \"kendra:BatchPutDocument\",\n                \"kendra:BatchDeleteDocument\"\n              ],\n              Effect: \"Allow\",\n              Resource: {\n                \"Fn::GetAtt\": [\n                  \"kendraindextest\",\n                  \"Arn\"\n                ]\n              }\n            }\n          ],\n          Version: \"2012-10-17\"\n        },\n        PolicyName: \"s3CrawlPolicy\"\n      }\n    ]\n  });\n});\n\ntest('Launch Kendra index with a customized S3 data source', () => {\n  const testName = 'test-name';\n  const testBucketName = 'test-bucket-name';\n  const stack = new Stack(undefined, undefined);\n\n  const newIndex = buildKendraIndex(stack, 'test', {});\n\n  AddKendraDataSource(stack, 'testSource', newIndex, {\n    type: 'S3',\n    name: testName,\n    dataSourceConfiguration: {\n      s3Configuration: {\n        bucketName: testBucketName,\n        inclusionPatterns: ['IncludeThis'],\n      }\n    },\n  });\n\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties(\"AWS::Kendra::DataSource\", {\n    DataSourceConfiguration: {\n      S3Configuration: {\n        BucketName: \"test-bucket-name\",\n        InclusionPatterns: ['IncludeThis'],\n      }\n    },\n  });\n  template.resourceCountIs('AWS::Kendra::Index', 1);\n  template.resourceCountIs(\"AWS::Kendra::DataSource\", 1);\n  template.resourceCountIs(\"AWS::IAM::Role\", 2);\n});\n\ntest('Launch Kendra index with non-implemented data source', () => {\n  const nonImplementedSourceType = \"WEBCRAWLER\";\n  const nonImplementedSourceName = \"test-other-source\";\n  const stack = new Stack(undefined, undefined);\n  const testIndex = buildKendraIndex(stack, 'test', {});\n\n  // Create a role\n  const fakeRole = new iam.Role(stack, 'fakeRole', {\n    assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),\n    roleName: 'externalFakeRole'\n  });\n\n  // Create data source props\n  const dataSourceProps: Partial<kendra.CfnDataSourceProps> = {\n    name: nonImplementedSourceName,\n    roleArn: fakeRole.roleArn,\n    type: nonImplementedSourceType,\n  };\n\n  // Add a data source\n  AddKendraDataSource(stack, 'test-other-source', testIndex, dataSourceProps);\n\n  const template = Template.fromStack(stack);\n  template.resourceCountIs('AWS::Kendra::Index', 1);\n  template.resourceCountIs('AWS::Kendra::DataSource', 1);\n  template.resourceCountIs('AWS::IAM::Role', 2);\n  template.hasResourceProperties(\"AWS::Kendra::DataSource\", {\n    Name: nonImplementedSourceName,\n    Type: nonImplementedSourceType\n  });\n});\n\ntest('Confirm error if client supplies an index in the DataSource props', () => {\n  const nonImplementedSourceType = \"WEBCRAWLER\";\n  const nonImplementedSourceName = \"test-other-source\";\n  const stack = new Stack(undefined, undefined);\n  const testIndex = buildKendraIndex(stack, 'test', {});\n\n  // Create a role\n  const fakeRole = new iam.Role(stack, 'fakeRole', {\n    assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),\n    roleName: 'externalFakeRole'\n  });\n\n  // Create data source props\n  const dataSourceProps: Partial<kendra.CfnDataSourceProps> = {\n    name: nonImplementedSourceName,\n    roleArn: fakeRole.roleArn,\n    type: nonImplementedSourceType,\n    indexId: testIndex.attrId,\n  };\n\n  // Add a data source\n  const app = () => {\n    AddKendraDataSource(stack, 'test-other-source', testIndex, dataSourceProps);\n  };\n\n  expect(app).toThrowError(/Invalid DataSource prop specified - Construct must set the indexId prop/);\n});\n\ntest('Confirm error if does not provide DataSource configuration', () => {\n  const stack = new Stack(undefined, undefined);\n  const testIndex = buildKendraIndex(stack, 'test', {});\n\n  // Create data source props\n  const dataSourceProps: Partial<kendra.CfnDataSourceProps> = {\n    type: \"S3\"\n  };\n\n  // Add a data source\n  const app = () => {\n    AddKendraDataSource(stack, 'test-bad-source', testIndex, dataSourceProps);\n  };\n\n  expect(app).toThrowError(/Error - an S3 Kendra DataSource requires an DataSourceCofiguration prop/);\n});\n\ntest('Confirm error if does not provide S3 DataSource configuration', () => {\n  const stack = new Stack(undefined, undefined);\n  const testIndex = buildKendraIndex(stack, 'test', {});\n\n  // Create data source props\n  const dataSourceProps: Partial<kendra.CfnDataSourceProps> = {\n    type: \"S3\",\n    dataSourceConfiguration: {\n\n    }\n  };\n\n  // Add a data source\n  const app = () => {\n    AddKendraDataSource(stack, 'test-bad-source', testIndex, dataSourceProps);\n  };\n\n  expect(app).toThrowError(/Error - an S3 Kendra DataSource requires an DataSourceCofiguration.S3Configuration prop/);\n});\n\ntest('Confirm error if does not provide S3 Bucketname', () => {\n  const stack = new Stack(undefined, undefined);\n  const testIndex = buildKendraIndex(stack, 'test', {});\n\n  // Create data source props\n  const dataSourceProps: Partial<kendra.CfnDataSourceProps> = {\n    type: \"S3\",\n    dataSourceConfiguration: {\n      s3Configuration: {\n        // Going through some hoops here to force this conditiion, but since we\n        // allow | any for props, a client could do this\n      } as kendra.CfnDataSource.S3DataSourceConfigurationProperty\n    }\n  };\n\n  // Add a data source\n  const app = () => {\n    AddKendraDataSource(stack, 'test-bad-source', testIndex, dataSourceProps);\n  };\n\n  expect(app).toThrowError(/Error - an S3 Kendra DataSource requires the DataSourceCofiguration.S3Configuration.bucketName prop/);\n});\n\ntest('Launch Kendra index with multiple data sources', () => {\n  const testName = 'test-name';\n  const testBucketName = 'test-bucket-name';\n  const nonImplementedSourceType = \"WEBCRAWLER\";\n  const nonImplementedSourceName = \"test-other-source\";\n  const stack = new Stack(undefined, undefined);\n\n  const newIndex = buildKendraIndex(stack, 'test', {});\n\n  const s3DataSourceProps = {\n    type: 'S3',\n    name: testName,\n    dataSourceConfiguration: {\n      s3Configuration: {\n        bucketName: testBucketName,\n      }\n    },\n  };\n\n  // Create a role\n  const fakeRole = new iam.Role(stack, 'fakeRole', {\n    assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),\n    roleName: 'externalFakeRole'\n  });\n\n  // Create data source props\n  const otherDataSourceProps: Partial<kendra.CfnDataSourceProps> = {\n    name: nonImplementedSourceName,\n    roleArn: fakeRole.roleArn,\n    type: nonImplementedSourceType\n  };\n\n  // Add a data source\n  const sourceObjects = AddMultipleKendraDataSources(stack, 'test-other-source', newIndex, [\n    s3DataSourceProps,\n    otherDataSourceProps\n  ]\n  );\n\n  expect(sourceObjects.length).toEqual(2);\n  expect(sourceObjects[0].type).toEqual('S3');\n  expect(sourceObjects[1].name).toEqual(nonImplementedSourceName);\n\n  const template = Template.fromStack(stack);\n  template.resourceCountIs('AWS::Kendra::Index', 1);\n  template.resourceCountIs('AWS::Kendra::DataSource', 2);\n  template.resourceCountIs('AWS::IAM::Role', 3);\n\n  // Look for S3 data source\n  template.hasResourceProperties(\"AWS::Kendra::DataSource\", {\n    Name: testName,\n    RoleArn: Match.anyValue(),\n    Type: 'S3',\n    DataSourceConfiguration: {\n      S3Configuration: {\n        BucketName: testBucketName\n      }\n    }\n  });\n  template.hasResourceProperties(\"AWS::IAM::Role\", {\n    AssumeRolePolicyDocument: {\n      Statement: [\n        {\n          Action: \"sts:AssumeRole\",\n          Effect: \"Allow\",\n          Principal: {\n            Service: \"kendra.amazonaws.com\"\n          }\n        }\n      ],\n      Version: \"2012-10-17\"\n    },\n    Policies: [\n      {\n        PolicyDocument: {\n          Statement: [\n            {\n              Action: \"s3:GetObject\",\n              Effect: \"Allow\",\n              Resource: `arn:aws:s3:::${testBucketName}/*`\n            },\n            {\n              Action: \"s3:ListBucket\",\n              Effect: \"Allow\",\n              Resource: `arn:aws:s3:::${testBucketName}`\n            },\n            {\n              Action: [\n                \"kendra:BatchPutDocument\",\n                \"kendra:BatchDeleteDocument\"\n              ],\n              Effect: \"Allow\",\n              Resource: {\n                \"Fn::GetAtt\": [\n                  \"kendraindextest\",\n                  \"Arn\"\n                ]\n              }\n            }\n          ],\n          Version: \"2012-10-17\"\n        },\n        PolicyName: \"s3CrawlPolicy\"\n      }\n    ]\n  });\n\n  // Look for non-implemented data source\n  template.hasResourceProperties(\"AWS::Kendra::DataSource\", {\n    Name: nonImplementedSourceName,\n    Type: nonImplementedSourceType,\n    IndexId: Match.anyValue()\n  });\n\n});\n\ntest('Confirm Errof for bad kendra Permission in normalizeKendraPermissions()', () => {\n  const inputs = [\"read\", \"submitfeedback\", \"write\"];\n\n  const outputs = normalizeKendraPermissions(inputs);\n\n  expect(outputs.includes(\"READ\")).toBeTruthy();\n  expect(outputs.includes(\"SUBMITFEEDBACK\")).toBeTruthy();\n  expect(outputs.includes(\"WRITE\")).toBeTruthy();\n});\n\ntest('Confirm successful operation of normalizeKendraPermissions()', () => {\n  const inputs = [\"badvalue\", \"write\"];\n\n  const app = () => {\n    normalizeKendraPermissions(inputs);\n  };\n\n  expect(app).toThrowError(/Invalid indexPermission value - valid values are \"READ\", \"SUBMITFEEDBACK\" and \"WRITE\"/);\n});"]}