test: added tests

Author: theburningmonk

lib/deploy/stepFunctions/compileIamRole.test.js

@@ -1726,4 +1726,51 @@ describe('#compileIamRole', () => {
     ];
     expect(lambdaPermissions[0].Resource).to.deep.equal(lambdaArns);
   });
+
+  it('should give CloudWatch Logs permissions for Express Workflow', () => {
+    serverless.service.stepFunctions = {
+      stateMachines: {
+        myStateMachine1: {
+          name: 'stateMachineBeta1',
+          type: 'EXPRESS',
+          loggingConfig: {
+            destinations: [
+              {
+                'Fn::GetAtt': ['MyLogGroup', 'Arn'],
+              },
+            ],
+          },
+          definition: {
+            StartAt: 'A',
+            States: {
+              A: {
+                Type: 'Task',
+                Resource: 'arn:aws:lambda:#{AWS::Region}:#{AWS::AccountId}:function:hello',
+                End: true,
+              },
+            },
+          },
+        },
+      },
+    };
+
+    serverlessStepFunctions.compileIamRole();
+    const statements = serverlessStepFunctions.serverless.service
+      .provider.compiledCloudFormationTemplate.Resources.IamRoleStateMachineExecution
+      .Properties.Policies[0].PolicyDocument.Statement;
+
+    const logsPermissions = statements.filter(s => s.Action.includes('logs:CreateLogDelivery'));
+    expect(logsPermissions).to.have.lengthOf(1);
+    expect(logsPermissions[0].Resource).to.equal('*');
+    expect(logsPermissions[0].Action).to.deep.equal([
+      'logs:CreateLogDelivery',
+      'logs:GetLogDelivery',
+      'logs:UpdateLogDelivery',
+      'logs:DeleteLogDelivery',
+      'logs:ListLogDeliveries',
+      'logs:PutResourcePolicy',
+      'logs:DescribeResourcePolicies',
+      'logs:DescribeLogGroups',
+    ]);
+  });
 });

lib/deploy/stepFunctions/compileNotifications.js

@@ -313,7 +313,7 @@ function validateConfig(serverless, stateMachineName, stateMachineObj, notificat
 
   if (stateMachineObj.type === 'EXPRESS') {
     serverless.cli.consoleLog(
-      `State machine [${stateMachineName}] : notifications is not enabled on Express Workflows. `
+      `State machine [${stateMachineName}] : notifications are not supported on Express Workflows. `
       + 'Please see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html for difference between Step Functions Standard and Express Workflow.',
     );
     return false;

lib/deploy/stepFunctions/compileNotifications.test.js

@@ -433,4 +433,40 @@ describe('#compileNotifications', () => {
     expect(logMessage.startsWith('State machine [Beta1] : notifications config is malformed.'))
       .to.equal(true);
   });
+
+  it('should log the validation errors if state machine is an Express Workflow', () => {
+    const genStateMachine = name => ({
+      name,
+      type: 'EXPRESS',
+      definition: {
+        StartAt: 'A',
+        States: {
+          A: {
+            Type: 'Pass',
+            End: true,
+          },
+        },
+      },
+      notifications: {
+        ABORTED: [{ sns: 'SNS_TOPIC_ARN' }],
+      },
+    });
+
+    serverless.service.stepFunctions = {
+      stateMachines: {
+        beta1: genStateMachine('Beta1'),
+      },
+    };
+
+    serverlessStepFunctions.compileNotifications();
+    const resources = serverlessStepFunctions.serverless.service
+      .provider.compiledCloudFormationTemplate.Resources;
+    expect(_.keys(resources)).to.have.lengthOf(0);
+
+    expect(consoleLogSpy.callCount).equal(1);
+    const { args } = consoleLogSpy.lastCall;
+    const [logMessage] = args;
+    expect(logMessage.startsWith('State machine [Beta1] : notifications are not supported on Express Workflows.'))
+      .to.equal(true);
+  });
 });

lib/deploy/stepFunctions/compileStateMachines.js

@@ -99,7 +99,7 @@ module.exports = {
         let LoggingConfiguration;
         const Tags = toTags(this.serverless.service.provider.tags);
 
-        const { error } = Joi.validate(stateMachineObj, schema, { allowUnknown: false });
+        const { error, value } = Joi.validate(stateMachineObj, schema, { allowUnknown: false });
         if (error) {
           const errorMessage = `State machine [${stateMachineName}] is malformed. `
             + 'Please check the README for more info. '
@@ -182,16 +182,16 @@ module.exports = {
           _.forEach(stateMachineTags, tag => Tags.push(tag));
         }
 
-        if (stateMachineObj.type === 'EXPRESS' && stateMachineObj.loggingConfig) {
-          const Destinations = (stateMachineObj.loggingConfig.destinations || [])
+        if (value.type === 'EXPRESS' && value.loggingConfig) {
+          const Destinations = (value.loggingConfig.destinations || [])
             .map(arn => ({
               CloudWatchLogsLogGroup: {
                 LogGroupArn: arn,
               },
             }));
           LoggingConfiguration = {
-            Level: stateMachineObj.loggingConfig.level,
-            IncludeExecutionData: stateMachineObj.loggingConfig.includeExecutionData,
+            Level: value.loggingConfig.level,
+            IncludeExecutionData: value.loggingConfig.includeExecutionData,
             Destinations,
           };
         }

lib/deploy/stepFunctions/compileStateMachines.test.js

@@ -1175,4 +1175,57 @@ describe('#compileStateMachines', () => {
     expect(definitionString).to.contain('${AWS::AccountId}');
     expect(definitionString).to.not.contain('#{AWS::AccountId}');
   });
+
+  it('should compile logging configuration for Express Workflows', () => {
+    serverless.service.stepFunctions = {
+      stateMachines: {
+        myStateMachine1: {
+          name: 'stateMachineBeta1',
+          type: 'EXPRESS',
+          loggingConfig: {
+            destinations: [
+              {
+                'Fn::GetAtt': ['MyLogGroup', 'Arn'],
+              },
+            ],
+          },
+          definition: {
+            StartAt: 'A',
+            States: {
+              A: {
+                Type: 'Task',
+                Resource: 'arn:aws:lambda:#{AWS::Region}:#{AWS::AccountId}:function:hello',
+                End: true,
+              },
+            },
+          },
+        },
+      },
+    };
+
+    serverlessStepFunctions.compileStateMachines();
+    const actual = serverlessStepFunctions
+      .serverless
+      .service
+      .provider
+      .compiledCloudFormationTemplate
+      .Resources
+      .StateMachineBeta1
+      .Properties;
+
+    expect(actual.StateMachineType).to.equal('EXPRESS');
+    expect(actual).to.haveOwnProperty('LoggingConfiguration');
+    expect(actual.LoggingConfiguration.Level).to.equal('OFF'); // default value
+    expect(actual.LoggingConfiguration.IncludeExecutionData).to.equal(false); // default value
+    expect(actual.LoggingConfiguration.Destinations).to.have.length(1);
+
+    const loggingDestination = actual.LoggingConfiguration.Destinations[0];
+    expect(loggingDestination).to.deep.equal({
+      CloudWatchLogsLogGroup: {
+        LogGroupArn: {
+          'Fn::GetAtt': ['MyLogGroup', 'Arn'],
+        },
+      },
+    });
+  });
 });