@aws-solutions-constructs/aws-sqs-pipes-stepfunctions 2.73.0

package/test/lambda/index.js

@@ -0,0 +1,9 @@
+exports.handler = async (event) => { 
+  console.log(event); 
+  const response = event.map((x) =>{
+    const body = JSON.parse(x.body);
+    body.newAttrib = "content";
+    return body;
+  });
+  return response;
+}

package/test/sqs-pipes-stepfunctions.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ *  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.
+ */
+export {};

package/test/sqs-pipes-stepfunctions.test.js

@@ -0,0 +1,394 @@
+"use strict";
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const lib_1 = require("../lib");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const sqs = require("aws-cdk-lib/aws-sqs");
+const defaults = require("@aws-solutions-constructs/core");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+test('Test default behaviors', () => {
+    // Initial Setup
+    const stack = new aws_cdk_lib_1.Stack();
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')
+        }
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    expect(construct.pipe).toBeDefined();
+    expect(construct.pipeRole).toBeDefined();
+    template.hasResourceProperties('AWS::IAM::Role', {
+        AssumeRolePolicyDocument: {
+            Statement: [
+                {
+                    Action: "sts:AssumeRole",
+                    Effect: "Allow",
+                    Principal: {
+                        Service: "pipes.amazonaws.com"
+                    }
+                }
+            ],
+            Version: "2012-10-17"
+        },
+        Policies: [
+            {
+                PolicyDocument: {
+                    Statement: [
+                        {
+                            Action: [
+                                "sqs:ReceiveMessage",
+                                "sqs:DeleteMessage",
+                                "sqs:GetQueueAttributes"
+                            ],
+                            Effect: "Allow",
+                            Resource: {
+                                "Fn::GetAtt": [
+                                    assertions_1.Match.stringLikeRegexp(`testsqspipesstatesqueue.*`),
+                                    "Arn"
+                                ]
+                            }
+                        }
+                    ],
+                    Version: "2012-10-17"
+                },
+                PolicyName: "sourcePolicy"
+            },
+            {
+                PolicyDocument: {
+                    Statement: [
+                        {
+                            Action: "states:StartExecution",
+                            Effect: "Allow",
+                            Resource: {
+                                Ref: assertions_1.Match.stringLikeRegexp(`testsqspipesstatesStateMachine.*`)
+                            }
+                        }
+                    ],
+                    Version: "2012-10-17"
+                },
+                PolicyName: "targetPolicy"
+            }
+        ]
+    });
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        Source: {
+            "Fn::GetAtt": [
+                assertions_1.Match.stringLikeRegexp(`testsqspipesstatesqueue.*`),
+                "Arn"
+            ]
+        },
+        Target: {
+            Ref: assertions_1.Match.stringLikeRegexp(`testsqspipesstatesStateMachine.*`),
+        },
+    });
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        LogConfiguration: {
+            CloudwatchLogsLogDestination: {
+                LogGroupArn: {
+                    "Fn::GetAtt": [
+                        assertions_1.Match.stringLikeRegexp(`testsqspipesstatesLogGrouptestsqspipesstates.*`),
+                        "Arn"
+                    ]
+                }
+            },
+            Level: "INFO"
+        }
+    });
+    template.hasResourceProperties('AWS::Logs::LogGroup', {
+        LogGroupName: {
+            "Fn::Join": [
+                "",
+                [
+                    assertions_1.Match.stringLikeRegexp('\/aws\/vendedlogs\/pipes\/constructs'),
+                    {
+                        "Fn::Select": [
+                            2,
+                            assertions_1.Match.anyValue()
+                        ]
+                    }
+                ]
+            ]
+        },
+    });
+});
+test('Test queue and state machine aspects of construct', () => {
+    // Initial Setup
+    const stack = new aws_cdk_lib_1.Stack();
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')
+        }
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    expect(construct.sqsQueue).toBeDefined();
+    expect(construct.deadLetterQueue).toBeDefined();
+    template.resourceCountIs("AWS::SQS::Queue", 2);
+    template.hasResourceProperties('AWS::SQS::Queue', {
+        KmsMasterKeyId: "alias/aws/sqs"
+    });
+    const stateMachine = construct.stateMachine;
+    expect(stateMachine).toBeDefined();
+    const cwAlarm = construct.cloudwatchAlarms;
+    expect(cwAlarm).toBeDefined();
+    expect(construct.stateMachineLogGroup).toBeDefined();
+});
+test('Test existing queue', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const existingQueue = new sqs.Queue(stack, 'existing-queue', {});
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')
+        },
+        existingQueueObj: existingQueue,
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    expect(construct.sqsQueue.queueArn).toEqual(existingQueue.queueArn);
+});
+test('Test filter', () => {
+    // Stack
+    const stack = new aws_cdk_lib_1.Stack();
+    const testFilterPattern = `{
+    "body": {
+      "state": ["open"]
+    }
+  }`;
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')
+        },
+        pipeProps: {
+            sourceParameters: {
+                filterCriteria: {
+                    filters: [{ pattern: testFilterPattern }],
+                },
+            }
+        }
+    };
+    new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        SourceParameters: {
+            FilterCriteria: {
+                Filters: [
+                    {
+                        Pattern: testFilterPattern
+                    }
+                ]
+            }
+        }
+    });
+});
+test('Test target parameters?', () => {
+    const testMessageGroupId = "test-id";
+    // Stack
+    const stack = new aws_cdk_lib_1.Stack();
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')
+        },
+        pipeProps: {
+            // We realize that this would not launch because the target is not
+            // a queue, but it tests the functionality
+            targetParameters: {
+                sqsQueueParameters: {
+                    messageGroupId: testMessageGroupId,
+                }
+            }
+        }
+    };
+    new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        TargetParameters: {
+            SqsQueueParameters: {
+                MessageGroupId: testMessageGroupId,
+            }
+        }
+    });
+});
+test('test state machine enrichment', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const enrichmentStateMachine = defaults.CreateTestStateMachine(stack, 'enrichment-state-machine');
+    const props = {
+        enrichmentStateMachine,
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')
+        }
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test', props);
+    expect(construct.pipe).toBeDefined();
+    expect(construct.pipeRole).toBeDefined();
+    const template = assertions_1.Template.fromStack(stack);
+    // Look for additional enrichment permision
+    template.hasResourceProperties('AWS::IAM::Policy', {
+        PolicyDocument: {
+            Statement: [
+                {
+                    Action: "states:StartSyncExecution",
+                    Effect: "Allow",
+                    Resource: {
+                        Ref: assertions_1.Match.stringLikeRegexp('enrichmentstatemachine.*'),
+                    }
+                }
+            ],
+            Version: "2012-10-17"
+        },
+        PolicyName: assertions_1.Match.stringLikeRegexp(`testenrichmentpolicytest.*`),
+        Roles: [
+            {
+                Ref: assertions_1.Match.stringLikeRegexp(`testPipeRoletest.*`)
+            }
+        ]
+    });
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        Enrichment: {
+            Ref: assertions_1.Match.stringLikeRegexp("enrichmentstatemachine.*")
+        },
+    });
+});
+test('Test lambda function enrichment', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const enrichmentFunction = new lambda.Function(stack, 'enrichment-function', {
+        runtime: lambda.Runtime.NODEJS_20_X,
+        handler: 'index.handler',
+        code: lambda.Code.fromInline(`exports.handler = async (event) => {return;}`)
+    });
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')
+        },
+        enrichmentFunction
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'enrichment-function-test', props);
+    const template = assertions_1.Template.fromStack(stack);
+    expect(construct.pipe).toBeDefined();
+    expect(construct.pipeRole).toBeDefined();
+    template.hasResourceProperties('AWS::IAM::Policy', {
+        PolicyDocument: {
+            Statement: [
+                {
+                    Action: "lambda:InvokeFunction",
+                    Effect: "Allow",
+                    Resource: {
+                        "Fn::GetAtt": [
+                            assertions_1.Match.stringLikeRegexp('enrichmentfunction.*'),
+                            "Arn"
+                        ]
+                    }
+                }
+            ],
+            Version: "2012-10-17"
+        },
+        PolicyName: assertions_1.Match.stringLikeRegexp(`enrichmentfunctiontestenrichmentpolicyenrichmentfunctiontest.*`),
+        Roles: [
+            {
+                Ref: assertions_1.Match.stringLikeRegexp(`enrichmentfunctiontestPipeRoleenrichmentfunctiontest.*`)
+            }
+        ]
+    });
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        Enrichment: {
+            "Fn::GetAtt": [
+                assertions_1.Match.stringLikeRegexp("enrichmentfunction.*"),
+                "Arn"
+            ]
+        },
+    });
+});
+test('Test custom log level', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')
+        },
+        logLevel: defaults.PipesLogLevel.TRACE
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    expect(construct.pipe).toBeDefined();
+    expect(construct.pipeRole).toBeDefined();
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        LogConfiguration: {
+            Level: "TRACE",
+        }
+    });
+});
+test('Test log level OFF', () => {
+    const stack = new aws_cdk_lib_1.Stack();
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')
+        },
+        logLevel: defaults.PipesLogLevel.OFF
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    expect(construct.pipe).toBeDefined();
+    expect(construct.pipeRole).toBeDefined();
+    // Should be no LogConfiguration
+    template.resourcePropertiesCountIs('AWS::Pipes::Pipe', { LogConfiguration: {} }, 0);
+    // One log group for the state machine, none for the pipe
+    template.resourceCountIs('AWS::Logs::LogGroup', 1);
+});
+test('Test custom pipe log props', () => {
+    const testRetention = aws_logs_1.RetentionDays.FOUR_MONTHS;
+    const stack = new aws_cdk_lib_1.Stack();
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')
+        },
+        pipeLogProps: {
+            retention: testRetention
+        }
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    expect(construct.pipe).toBeDefined();
+    expect(construct.pipeRole).toBeDefined();
+    template.hasResourceProperties('AWS::Logs::LogGroup', {
+        RetentionInDays: 120,
+    });
+});
+test('Test setting source parameters like batchSize', () => {
+    const testBatchSize = 123;
+    const stack = new aws_cdk_lib_1.Stack();
+    const props = {
+        stateMachineProps: {
+            definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')
+        },
+        pipeProps: {
+            sourceParameters: {
+                sqsQueueParameters: {
+                    batchSize: testBatchSize,
+                },
+            }
+        }
+    };
+    const construct = new lib_1.SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);
+    const template = assertions_1.Template.fromStack(stack);
+    expect(construct.pipe).toBeDefined();
+    expect(construct.pipeRole).toBeDefined();
+    template.hasResourceProperties('AWS::Pipes::Pipe', {
+        SourceParameters: {
+            SqsQueueParameters: {
+                BatchSize: testBatchSize,
+            }
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sqs-pipes-stepfunctions.test.js","sourceRoot":"","sources":["sqs-pipes-stepfunctions.test.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { Stack } from \"aws-cdk-lib\";\nimport { SqsToPipesToStepfunctions, SqsToPipesToStepfunctionsProps } from \"../lib\";\nimport { Match, Template } from 'aws-cdk-lib/assertions';\nimport * as sqs from 'aws-cdk-lib/aws-sqs';\nimport * as defaults from '@aws-solutions-constructs/core';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport { RetentionDays } from \"aws-cdk-lib/aws-logs\";\n\ntest('Test default behaviors', () => {\n  // Initial Setup\n  const stack = new Stack();\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')\n    }\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n\n  expect(construct.pipe).toBeDefined();\n  expect(construct.pipeRole).toBeDefined();\n\n  template.hasResourceProperties('AWS::IAM::Role', {\n    AssumeRolePolicyDocument: {\n      Statement: [\n        {\n          Action: \"sts:AssumeRole\",\n          Effect: \"Allow\",\n          Principal: {\n            Service: \"pipes.amazonaws.com\"\n          }\n        }\n      ],\n      Version: \"2012-10-17\"\n    },\n    Policies: [\n      {\n        PolicyDocument: {\n          Statement: [\n            {\n              Action: [\n                \"sqs:ReceiveMessage\",\n                \"sqs:DeleteMessage\",\n                \"sqs:GetQueueAttributes\"\n              ],\n              Effect: \"Allow\",\n              Resource: {\n                \"Fn::GetAtt\": [\n                  Match.stringLikeRegexp(`testsqspipesstatesqueue.*`),\n                  \"Arn\"\n                ]\n              }\n            }\n          ],\n          Version: \"2012-10-17\"\n        },\n        PolicyName: \"sourcePolicy\"\n      },\n      {\n        PolicyDocument: {\n          Statement: [\n            {\n              Action: \"states:StartExecution\",\n              Effect: \"Allow\",\n              Resource: {\n                Ref: Match.stringLikeRegexp(`testsqspipesstatesStateMachine.*`)\n              }\n            }\n          ],\n          Version: \"2012-10-17\"\n        },\n        PolicyName: \"targetPolicy\"\n      }\n    ]\n  });\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    Source: {\n      \"Fn::GetAtt\": [\n        Match.stringLikeRegexp(`testsqspipesstatesqueue.*`),\n        \"Arn\"\n      ]\n    },\n    Target: {\n      Ref: Match.stringLikeRegexp(`testsqspipesstatesStateMachine.*`),\n    },\n  });\n\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    LogConfiguration: {\n      CloudwatchLogsLogDestination: {\n        LogGroupArn: {\n          \"Fn::GetAtt\": [\n            Match.stringLikeRegexp(`testsqspipesstatesLogGrouptestsqspipesstates.*`),\n            \"Arn\"\n          ]\n        }\n      },\n      Level: \"INFO\"\n    }\n  });\n  template.hasResourceProperties('AWS::Logs::LogGroup', {\n    LogGroupName: {\n      \"Fn::Join\": [\n        \"\",\n        [\n          Match.stringLikeRegexp('\\/aws\\/vendedlogs\\/pipes\\/constructs'),\n          {\n            \"Fn::Select\": [\n              2,\n              Match.anyValue()\n            ]\n          }\n        ]\n      ]\n    },\n  });\n\n});\n\ntest('Test queue and state machine aspects of construct', () => {\n  // Initial Setup\n  const stack = new Stack();\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')\n    }\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n\n  expect(construct.sqsQueue).toBeDefined();\n  expect(construct.deadLetterQueue).toBeDefined();\n  template.resourceCountIs(\"AWS::SQS::Queue\", 2);\n  template.hasResourceProperties('AWS::SQS::Queue', {\n    KmsMasterKeyId: \"alias/aws/sqs\"\n  });\n\n  const stateMachine = construct.stateMachine;\n  expect(stateMachine).toBeDefined();\n  const cwAlarm = construct.cloudwatchAlarms;\n  expect(cwAlarm).toBeDefined();\n  expect(construct.stateMachineLogGroup).toBeDefined();\n});\n\ntest('Test existing queue', () => {\n  const stack = new Stack();\n  const existingQueue = new sqs.Queue(stack, 'existing-queue', {});\n\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')\n    },\n    existingQueueObj: existingQueue,\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  expect(construct.sqsQueue.queueArn).toEqual(existingQueue.queueArn);\n});\n\ntest('Test filter', () => {\n  // Stack\n  const stack = new Stack();\n  const testFilterPattern = `{\n    \"body\": {\n      \"state\": [\"open\"]\n    }\n  }`;\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')\n    },\n    pipeProps: {\n      sourceParameters: {\n        filterCriteria: {\n          filters: [{ pattern: testFilterPattern }],\n        },\n      }\n    }\n  };\n  new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    SourceParameters: {\n      FilterCriteria: {\n        Filters: [\n          {\n            Pattern: testFilterPattern\n          }\n        ]\n      }\n    }\n  });\n\n});\n\ntest('Test target parameters?', () => {\n  const testMessageGroupId = \"test-id\";\n  // Stack\n  const stack = new Stack();\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'lamstp-test')\n    },\n    pipeProps: {\n      // We realize that this would not launch because the target is not\n      // a queue, but it tests the functionality\n      targetParameters: {\n        sqsQueueParameters: {\n          messageGroupId: testMessageGroupId,\n        }\n      }\n    }\n  };\n  new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    TargetParameters: {\n      SqsQueueParameters: {\n        MessageGroupId: testMessageGroupId,\n      }\n    }\n  });\n});\n\ntest('test state machine enrichment', () => {\n  const stack = new Stack();\n  const enrichmentStateMachine = defaults.CreateTestStateMachine(stack, 'enrichment-state-machine');\n  const props: SqsToPipesToStepfunctionsProps = {\n    enrichmentStateMachine,\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')\n    }\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test', props);\n\n  expect(construct.pipe).toBeDefined();\n  expect(construct.pipeRole).toBeDefined();\n\n  const template = Template.fromStack(stack);\n\n  // Look for additional enrichment permision\n  template.hasResourceProperties('AWS::IAM::Policy', {\n    PolicyDocument: {\n      Statement: [\n        {\n          Action: \"states:StartSyncExecution\",\n          Effect: \"Allow\",\n          Resource: {\n            Ref: Match.stringLikeRegexp('enrichmentstatemachine.*'),\n          }\n        }\n      ],\n      Version: \"2012-10-17\"\n    },\n    PolicyName: Match.stringLikeRegexp(`testenrichmentpolicytest.*`),\n    Roles: [\n      {\n        Ref: Match.stringLikeRegexp(`testPipeRoletest.*`)\n      }\n    ]\n  });\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    Enrichment: {\n      Ref: Match.stringLikeRegexp(\"enrichmentstatemachine.*\")\n    },\n  });\n});\n\ntest('Test lambda function enrichment', () => {\n  const stack = new Stack();\n  const enrichmentFunction = new lambda.Function(stack, 'enrichment-function', {\n    runtime: lambda.Runtime.NODEJS_20_X,\n    handler: 'index.handler',\n    code: lambda.Code.fromInline(`exports.handler = async (event) => {return;}`)\n  });\n\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')\n    },\n    enrichmentFunction\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'enrichment-function-test', props);\n  const template = Template.fromStack(stack);\n\n  expect(construct.pipe).toBeDefined();\n  expect(construct.pipeRole).toBeDefined();\n\n  template.hasResourceProperties('AWS::IAM::Policy', {\n    PolicyDocument: {\n      Statement: [\n        {\n          Action: \"lambda:InvokeFunction\",\n          Effect: \"Allow\",\n          Resource: {\n            \"Fn::GetAtt\": [\n              Match.stringLikeRegexp('enrichmentfunction.*'),\n              \"Arn\"\n            ]\n          }\n        }\n      ],\n      Version: \"2012-10-17\"\n    },\n    PolicyName: Match.stringLikeRegexp(`enrichmentfunctiontestenrichmentpolicyenrichmentfunctiontest.*`),\n    Roles: [\n      {\n        Ref: Match.stringLikeRegexp(`enrichmentfunctiontestPipeRoleenrichmentfunctiontest.*`)\n      }\n    ]\n  });\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    Enrichment: {\n      \"Fn::GetAtt\": [\n        Match.stringLikeRegexp(\"enrichmentfunction.*\"),\n        \"Arn\"\n      ]\n    },\n  });\n});\n\ntest('Test custom log level', () => {\n  const stack = new Stack();\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')\n    },\n    logLevel: defaults.PipesLogLevel.TRACE\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n\n  expect(construct.pipe).toBeDefined();\n  expect(construct.pipeRole).toBeDefined();\n\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    LogConfiguration: {\n      Level: \"TRACE\",\n    }\n  });\n});\n\ntest('Test log level OFF', () => {\n  const stack = new Stack();\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')\n    },\n    logLevel: defaults.PipesLogLevel.OFF\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n\n  expect(construct.pipe).toBeDefined();\n  expect(construct.pipeRole).toBeDefined();\n\n  // Should be no LogConfiguration\n  template.resourcePropertiesCountIs('AWS::Pipes::Pipe', { LogConfiguration: {}}, 0);\n\n  // One log group for the state machine, none for the pipe\n  template.resourceCountIs('AWS::Logs::LogGroup', 1);\n});\n\ntest('Test custom pipe log props', () => {\n  const testRetention = RetentionDays.FOUR_MONTHS;\n  const stack = new Stack();\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')\n    },\n    pipeLogProps: {\n      retention: testRetention\n    }\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n\n  expect(construct.pipe).toBeDefined();\n  expect(construct.pipeRole).toBeDefined();\n  template.hasResourceProperties('AWS::Logs::LogGroup', {\n    RetentionInDays: 120,\n  });\n});\n\ntest('Test setting source parameters like batchSize', () => {\n  const testBatchSize = 123;\n  const stack = new Stack();\n  const props: SqsToPipesToStepfunctionsProps = {\n    stateMachineProps: {\n      definitionBody: defaults.CreateTestStateMachineDefinitionBody(stack, 'pipes-test')\n    },\n    pipeProps: {\n      sourceParameters: {\n        sqsQueueParameters: {\n          batchSize: testBatchSize,\n        },\n      }\n    }\n  };\n  const construct = new SqsToPipesToStepfunctions(stack, 'test-sqs-pipes-states', props);\n  const template = Template.fromStack(stack);\n\n  expect(construct.pipe).toBeDefined();\n  expect(construct.pipeRole).toBeDefined();\n  template.hasResourceProperties('AWS::Pipes::Pipe', {\n    SourceParameters: {\n      SqsQueueParameters: {\n        BatchSize: testBatchSize,\n      }\n    }\n  });\n});\n"]}