@aws-solutions-constructs/aws-fargate-stepfunctions 1.155.0

package/test/fargate-stepfunctions.test.js

@@ -0,0 +1,266 @@
+"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 });
+require("@aws-cdk/assert/jest");
+const defaults = require("@aws-solutions-constructs/core");
+const cdk = require("@aws-cdk/core");
+const lib_1 = require("../lib");
+const stepfunctions = require("@aws-cdk/aws-stepfunctions");
+const ecs = require("@aws-cdk/aws-ecs");
+const clusterName = "custom-cluster-name";
+const containerName = "custom-container-name";
+const serviceName = "custom-service-name";
+const familyName = "family-name";
+const testCidr = "172.0.0.0/16";
+test('Check for construct properties', () => {
+    const stack = new cdk.Stack();
+    const publicApi = true;
+    const construct = createFargateConstructWithNewResources(stack, publicApi);
+    expect(construct.vpc).toBeDefined();
+    expect(construct.service).toBeDefined();
+    expect(construct.container).toBeDefined();
+    expect(construct.stateMachine).toBeDefined();
+    expect(construct.stateMachineLogGroup).toBeDefined();
+    expect(construct.cloudwatchAlarms).toBeDefined();
+});
+test('Check for new service', () => {
+    const stack = new cdk.Stack();
+    const publicApi = false;
+    createFargateConstructWithNewResources(stack, publicApi);
+    expect(stack).toHaveResourceLike("AWS::ECS::Service", {
+        ServiceName: serviceName,
+        LaunchType: 'FARGATE',
+        DesiredCount: 2,
+        DeploymentConfiguration: {
+            MaximumPercent: 150,
+            MinimumHealthyPercent: 75
+        },
+        PlatformVersion: ecs.FargatePlatformVersion.LATEST,
+    });
+});
+test('Check for an existing service', () => {
+    const stack = new cdk.Stack();
+    const publicApi = true;
+    const existingVpc = defaults.getTestVpc(stack);
+    const [testService, testContainer] = defaults.CreateFargateService(stack, 'test', existingVpc, { clusterName }, defaults.fakeEcrRepoArn, undefined, { family: familyName }, { containerName }, { serviceName });
+    new lib_1.FargateToStepfunctions(stack, 'test-construct', {
+        publicApi,
+        existingFargateServiceObject: testService,
+        existingContainerDefinitionObject: testContainer,
+        existingVpc,
+        stateMachineProps: testStateMachineProps(stack)
+    });
+    expect(stack).toHaveResourceLike("AWS::ECS::Service", {
+        ServiceName: serviceName,
+        LaunchType: 'FARGATE',
+        DesiredCount: 2,
+        DeploymentConfiguration: {
+            MaximumPercent: 150,
+            MinimumHealthyPercent: 75
+        },
+        PlatformVersion: ecs.FargatePlatformVersion.LATEST,
+    });
+});
+test('Check for IAM startExecution policy', () => {
+    const stack = new cdk.Stack();
+    const publicApi = false;
+    createFargateConstructWithNewResources(stack, publicApi);
+    expect(stack).toHaveResourceLike("AWS::IAM::Policy", {
+        PolicyDocument: {
+            Statement: [
+                {
+                    Action: "states:StartExecution",
+                    Effect: "Allow",
+                    Resource: {
+                        Ref: "testconstructStateMachine3333AAA9"
+                    }
+                }
+            ],
+            Version: "2012-10-17"
+        },
+        PolicyName: "testconstructtaskdefTaskRoleDefaultPolicyF34A1535",
+        Roles: [
+            {
+                Ref: "testconstructtaskdefTaskRoleC60414C4"
+            }
+        ]
+    });
+});
+test('Check for public/private VPC', () => {
+    const stack = new cdk.Stack();
+    const publicApi = true;
+    createFargateConstructWithNewResources(stack, publicApi);
+    expect(stack).toHaveResourceLike("AWS::EC2::VPC", {
+        CidrBlock: testCidr
+    });
+    expect(stack).toHaveResourceLike('AWS::EC2::InternetGateway', {});
+    expect(stack).toCountResources('AWS::EC2::VPC', 1);
+    expect(stack).toCountResources('AWS::StepFunctions::StateMachine', 1);
+    expect(stack).toCountResources('AWS::ECS::Service', 1);
+});
+test('Check for isolated VPC', () => {
+    const stack = new cdk.Stack();
+    const publicApi = false;
+    createFargateConstructWithNewResources(stack, publicApi);
+    expect(stack).toHaveResourceLike("AWS::EC2::VPC", {
+        CidrBlock: testCidr
+    });
+    expect(stack).not.toHaveResourceLike('AWS::EC2::InternetGateway', {});
+    expect(stack).toCountResources('AWS::EC2::VPC', 1);
+    expect(stack).toCountResources('AWS::StepFunctions::StateMachine', 1);
+    expect(stack).toCountResources('AWS::ECS::Service', 1);
+});
+test('Check for an existing VPC', () => {
+    const stack = new cdk.Stack();
+    const publicApi = false;
+    const existingVpc = defaults.getTestVpc(stack, publicApi);
+    new lib_1.FargateToStepfunctions(stack, 'test-construct', {
+        publicApi,
+        ecrRepositoryArn: defaults.fakeEcrRepoArn,
+        clusterProps: { clusterName },
+        containerDefinitionProps: { containerName },
+        fargateTaskDefinitionProps: { family: familyName },
+        fargateServiceProps: { serviceName },
+        existingVpc,
+        stateMachineProps: testStateMachineProps(stack)
+    });
+    expect(stack).toHaveResourceLike("AWS::EC2::VPC", {
+        CidrBlock: "172.168.0.0/16"
+    });
+    expect(stack).toCountResources("AWS::EC2::VPC", 1);
+});
+test('Check for custom ARN resource', () => {
+    const stack = new cdk.Stack();
+    const publicApi = true;
+    const customEnvName = "TEST_CUSTOM_ARN";
+    new lib_1.FargateToStepfunctions(stack, 'test-construct', {
+        publicApi,
+        ecrRepositoryArn: defaults.fakeEcrRepoArn,
+        vpcProps: { cidr: testCidr },
+        clusterProps: { clusterName },
+        containerDefinitionProps: { containerName },
+        fargateTaskDefinitionProps: { family: familyName },
+        fargateServiceProps: { serviceName },
+        stateMachineProps: testStateMachineProps(stack),
+        stateMachineEnvironmentVariableName: customEnvName
+    });
+    expect(stack).toHaveResourceLike("AWS::ECS::TaskDefinition", {
+        Family: familyName,
+        ContainerDefinitions: [
+            {
+                Environment: [
+                    {
+                        Name: customEnvName,
+                        Value: {
+                            Ref: "testconstructStateMachine3333AAA9"
+                        }
+                    }
+                ],
+                Essential: true,
+                Image: {
+                    "Fn::Join": [
+                        "",
+                        [
+                            "123456789012.dkr.ecr.us-east-1.",
+                            {
+                                Ref: "AWS::URLSuffix"
+                            },
+                            "/fake-repo:latest"
+                        ]
+                    ]
+                },
+                MemoryReservation: 512,
+                Name: containerName,
+                PortMappings: [
+                    {
+                        ContainerPort: 8080,
+                        Protocol: "tcp"
+                    }
+                ]
+            }
+        ]
+    });
+});
+test('Check for no cloudwatch creation', () => {
+    const stack = new cdk.Stack();
+    const publicApi = true;
+    const construct = new lib_1.FargateToStepfunctions(stack, 'test-construct', {
+        publicApi,
+        ecrRepositoryArn: defaults.fakeEcrRepoArn,
+        vpcProps: { cidr: testCidr },
+        clusterProps: { clusterName },
+        containerDefinitionProps: { containerName },
+        fargateTaskDefinitionProps: { family: familyName },
+        fargateServiceProps: { serviceName },
+        stateMachineProps: testStateMachineProps(stack),
+        createCloudWatchAlarms: false
+    });
+    expect(construct.cloudwatchAlarms).not.toBeDefined();
+    expect(stack).not.toHaveResource("AWS::CloudWatch::Alarm", {
+        ComparisonOperator: "GreaterThanOrEqualToThreshold",
+        EvaluationPeriods: 1,
+        AlarmDescription: "Alarm for the number of executions that aborted exceeded the threshold of 1. ",
+        Dimensions: [
+            {
+                Name: "StateMachineArn",
+                Value: {
+                    Ref: "testconstructStateMachine3333AAA9"
+                }
+            }
+        ],
+        MetricName: "ExecutionsAborted",
+        Namespace: "AWS/States",
+        Period: 300,
+        Statistic: "Maximum",
+        Threshold: 1
+    });
+});
+test('Check for custom log group props', () => {
+    const stack = new cdk.Stack();
+    const publicApi = true;
+    const logGroupName = "custom-log-group";
+    new lib_1.FargateToStepfunctions(stack, 'test-construct', {
+        publicApi,
+        ecrRepositoryArn: defaults.fakeEcrRepoArn,
+        vpcProps: { cidr: testCidr },
+        clusterProps: { clusterName },
+        containerDefinitionProps: { containerName },
+        fargateTaskDefinitionProps: { family: familyName },
+        fargateServiceProps: { serviceName },
+        stateMachineProps: testStateMachineProps(stack),
+        logGroupProps: {
+            logGroupName
+        }
+    });
+    expect(stack).toHaveResourceLike("AWS::Logs::LogGroup", {
+        LogGroupName: logGroupName
+    });
+});
+function createFargateConstructWithNewResources(stack, publicApi) {
+    return new lib_1.FargateToStepfunctions(stack, 'test-construct', {
+        publicApi,
+        ecrRepositoryArn: defaults.fakeEcrRepoArn,
+        vpcProps: { cidr: testCidr },
+        clusterProps: { clusterName },
+        containerDefinitionProps: { containerName },
+        fargateTaskDefinitionProps: { family: familyName },
+        fargateServiceProps: { serviceName },
+        stateMachineProps: testStateMachineProps(stack),
+    });
+}
+function testStateMachineProps(stack, userProps) {
+    const defaultTestProp = { definition: new stepfunctions.Pass(stack, 'StartState') };
+    return defaults.consolidateProps(defaultTestProp, userProps);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate-stepfunctions.test.js","sourceRoot":"","sources":["fargate-stepfunctions.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 '@aws-cdk/assert/jest';\nimport * as defaults from '@aws-solutions-constructs/core';\nimport * as cdk from \"@aws-cdk/core\";\nimport { FargateToStepfunctions } from \"../lib\";\nimport * as stepfunctions from '@aws-cdk/aws-stepfunctions';\nimport * as ecs from '@aws-cdk/aws-ecs';\n\nconst clusterName = \"custom-cluster-name\";\nconst containerName = \"custom-container-name\";\nconst serviceName = \"custom-service-name\";\nconst familyName = \"family-name\";\nconst testCidr = \"172.0.0.0/16\";\n\ntest('Check for construct properties', () => {\n  const stack = new cdk.Stack();\n  const publicApi = true;\n\n  const construct = createFargateConstructWithNewResources(stack, publicApi);\n\n  expect(construct.vpc).toBeDefined();\n  expect(construct.service).toBeDefined();\n  expect(construct.container).toBeDefined();\n  expect(construct.stateMachine).toBeDefined();\n  expect(construct.stateMachineLogGroup).toBeDefined();\n  expect(construct.cloudwatchAlarms).toBeDefined();\n});\n\ntest('Check for new service', () => {\n  const stack = new cdk.Stack();\n  const publicApi = false;\n\n  createFargateConstructWithNewResources(stack, publicApi);\n\n  expect(stack).toHaveResourceLike(\"AWS::ECS::Service\", {\n    ServiceName: serviceName,\n    LaunchType: 'FARGATE',\n    DesiredCount: 2,\n    DeploymentConfiguration: {\n      MaximumPercent: 150,\n      MinimumHealthyPercent: 75\n    },\n    PlatformVersion: ecs.FargatePlatformVersion.LATEST,\n  });\n});\n\ntest('Check for an existing service', () => {\n  const stack = new cdk.Stack();\n  const publicApi = true;\n\n  const existingVpc = defaults.getTestVpc(stack);\n\n  const [testService, testContainer] = defaults.CreateFargateService(stack,\n    'test',\n    existingVpc,\n    { clusterName },\n    defaults.fakeEcrRepoArn,\n    undefined,\n    { family: familyName },\n    { containerName },\n    { serviceName });\n\n  new FargateToStepfunctions(stack, 'test-construct', {\n    publicApi,\n    existingFargateServiceObject: testService,\n    existingContainerDefinitionObject: testContainer,\n    existingVpc,\n    stateMachineProps: testStateMachineProps(stack)\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::ECS::Service\", {\n    ServiceName: serviceName,\n    LaunchType: 'FARGATE',\n    DesiredCount: 2,\n    DeploymentConfiguration: {\n      MaximumPercent: 150,\n      MinimumHealthyPercent: 75\n    },\n    PlatformVersion: ecs.FargatePlatformVersion.LATEST,\n  });\n});\n\ntest('Check for IAM startExecution policy', () => {\n  const stack = new cdk.Stack();\n  const publicApi = false;\n\n  createFargateConstructWithNewResources(stack, publicApi);\n\n  expect(stack).toHaveResourceLike(\"AWS::IAM::Policy\", {\n    PolicyDocument: {\n      Statement: [\n        {\n          Action: \"states:StartExecution\",\n          Effect: \"Allow\",\n          Resource: {\n            Ref: \"testconstructStateMachine3333AAA9\"\n          }\n        }\n      ],\n      Version: \"2012-10-17\"\n    },\n    PolicyName: \"testconstructtaskdefTaskRoleDefaultPolicyF34A1535\",\n    Roles: [\n      {\n        Ref: \"testconstructtaskdefTaskRoleC60414C4\"\n      }\n    ]\n  });\n});\n\ntest('Check for public/private VPC', () => {\n  const stack = new cdk.Stack();\n  const publicApi = true;\n\n  createFargateConstructWithNewResources(stack, publicApi);\n\n  expect(stack).toHaveResourceLike(\"AWS::EC2::VPC\", {\n    CidrBlock: testCidr\n  });\n\n  expect(stack).toHaveResourceLike('AWS::EC2::InternetGateway', {});\n  expect(stack).toCountResources('AWS::EC2::VPC', 1);\n  expect(stack).toCountResources('AWS::StepFunctions::StateMachine', 1);\n  expect(stack).toCountResources('AWS::ECS::Service', 1);\n});\n\ntest('Check for isolated VPC', () => {\n  const stack = new cdk.Stack();\n  const publicApi = false;\n\n  createFargateConstructWithNewResources(stack, publicApi);\n\n  expect(stack).toHaveResourceLike(\"AWS::EC2::VPC\", {\n    CidrBlock: testCidr\n  });\n\n  expect(stack).not.toHaveResourceLike('AWS::EC2::InternetGateway', {});\n  expect(stack).toCountResources('AWS::EC2::VPC', 1);\n  expect(stack).toCountResources('AWS::StepFunctions::StateMachine', 1);\n  expect(stack).toCountResources('AWS::ECS::Service', 1);\n});\n\ntest('Check for an existing VPC', () => {\n  const stack = new cdk.Stack();\n  const publicApi = false;\n\n  const existingVpc = defaults.getTestVpc(stack, publicApi);\n\n  new FargateToStepfunctions(stack, 'test-construct', {\n    publicApi,\n    ecrRepositoryArn: defaults.fakeEcrRepoArn,\n    clusterProps: { clusterName },\n    containerDefinitionProps: { containerName },\n    fargateTaskDefinitionProps: { family: familyName },\n    fargateServiceProps: { serviceName },\n    existingVpc,\n    stateMachineProps: testStateMachineProps(stack)\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::EC2::VPC\", {\n    CidrBlock: \"172.168.0.0/16\"\n  });\n\n  expect(stack).toCountResources(\"AWS::EC2::VPC\", 1);\n});\n\ntest('Check for custom ARN resource', () => {\n  const stack = new cdk.Stack();\n  const publicApi = true;\n  const customEnvName = \"TEST_CUSTOM_ARN\";\n\n  new FargateToStepfunctions(stack, 'test-construct', {\n    publicApi,\n    ecrRepositoryArn: defaults.fakeEcrRepoArn,\n    vpcProps: { cidr: testCidr },\n    clusterProps: { clusterName },\n    containerDefinitionProps: { containerName },\n    fargateTaskDefinitionProps: { family: familyName },\n    fargateServiceProps: { serviceName },\n    stateMachineProps: testStateMachineProps(stack),\n    stateMachineEnvironmentVariableName: customEnvName\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::ECS::TaskDefinition\", {\n    Family: familyName,\n    ContainerDefinitions: [\n      {\n        Environment: [\n          {\n            Name: customEnvName,\n            Value: {\n              Ref: \"testconstructStateMachine3333AAA9\"\n            }\n          }\n        ],\n        Essential: true,\n        Image: {\n          \"Fn::Join\": [\n            \"\",\n            [\n              \"123456789012.dkr.ecr.us-east-1.\",\n              {\n                Ref: \"AWS::URLSuffix\"\n              },\n              \"/fake-repo:latest\"\n            ]\n          ]\n        },\n        MemoryReservation: 512,\n        Name: containerName,\n        PortMappings: [\n          {\n            ContainerPort: 8080,\n            Protocol: \"tcp\"\n          }\n        ]\n      }\n    ]\n  });\n});\n\ntest('Check for no cloudwatch creation', () => {\n  const stack = new cdk.Stack();\n  const publicApi = true;\n\n  const construct = new FargateToStepfunctions(stack, 'test-construct', {\n    publicApi,\n    ecrRepositoryArn: defaults.fakeEcrRepoArn,\n    vpcProps: { cidr: testCidr },\n    clusterProps: { clusterName },\n    containerDefinitionProps: { containerName },\n    fargateTaskDefinitionProps: { family: familyName },\n    fargateServiceProps: { serviceName },\n    stateMachineProps: testStateMachineProps(stack),\n    createCloudWatchAlarms: false\n  });\n\n  expect(construct.cloudwatchAlarms).not.toBeDefined();\n  expect(stack).not.toHaveResource(\"AWS::CloudWatch::Alarm\", {\n    ComparisonOperator: \"GreaterThanOrEqualToThreshold\",\n    EvaluationPeriods: 1,\n    AlarmDescription: \"Alarm for the number of executions that aborted exceeded the threshold of 1. \",\n    Dimensions: [\n      {\n        Name: \"StateMachineArn\",\n        Value: {\n          Ref: \"testconstructStateMachine3333AAA9\"\n        }\n      }\n    ],\n    MetricName: \"ExecutionsAborted\",\n    Namespace: \"AWS/States\",\n    Period: 300,\n    Statistic: \"Maximum\",\n    Threshold: 1\n  });\n});\n\ntest('Check for custom log group props', () => {\n  const stack = new cdk.Stack();\n  const publicApi = true;\n  const logGroupName = \"custom-log-group\";\n\n  new FargateToStepfunctions(stack, 'test-construct', {\n    publicApi,\n    ecrRepositoryArn: defaults.fakeEcrRepoArn,\n    vpcProps: { cidr: testCidr },\n    clusterProps: { clusterName },\n    containerDefinitionProps: { containerName },\n    fargateTaskDefinitionProps: { family: familyName },\n    fargateServiceProps: { serviceName },\n    stateMachineProps: testStateMachineProps(stack),\n    logGroupProps: {\n      logGroupName\n    }\n  });\n\n  expect(stack).toHaveResourceLike(\"AWS::Logs::LogGroup\", {\n    LogGroupName: logGroupName\n  });\n});\n\nfunction createFargateConstructWithNewResources(stack: cdk.Stack, publicApi: boolean) {\n  return new FargateToStepfunctions(stack, 'test-construct', {\n    publicApi,\n    ecrRepositoryArn: defaults.fakeEcrRepoArn,\n    vpcProps: { cidr: testCidr },\n    clusterProps: { clusterName },\n    containerDefinitionProps: { containerName },\n    fargateTaskDefinitionProps: { family: familyName },\n    fargateServiceProps: { serviceName },\n    stateMachineProps: testStateMachineProps(stack),\n  });\n}\n\nfunction testStateMachineProps(stack: cdk.Stack, userProps?: stepfunctions.StateMachineProps):\n  stepfunctions.StateMachineProps {\n  const defaultTestProp = { definition: new stepfunctions.Pass(stack, 'StartState') };\n\n  return defaults.consolidateProps(defaultTestProp, userProps);\n}"]}

package/test/integ.new-resources.d.ts

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