fix: fix bug when there're no lambda versions

Author: theburningmonk

lib/deploy/stepFunctions/compileStateMachines.test.js

@@ -849,98 +849,131 @@ describe('#compileStateMachines', () => {
     expect(lambda2Param).to.eql({ 'Fn::GetAtt': ['HelloDashworldLambdaFunction', 'Arn'] });
   });
 
-  it('should support using exact versions of functions', () => {
-    serverless.service.stepFunctions = {
-      stateMachines: {
-        myStateMachine1: {
-          id: 'Test',
-          useExactVersion: true,
-          definition: {
-            StartAt: 'Lambda1',
-            States: {
-              Lambda1: {
-                Type: 'Task',
-                Resource: 'arn:aws:states:::lambda:invoke',
-                Parameters: {
-                  FunctionName: {
-                    Ref: 'HelloLambdaFunction',
-                  },
-                  Payload: {
-                    'ExecutionName.$': '$$.Execution.Name',
+  describe('#useExactVersions', () => {
+    beforeEach(() => {
+      serverless.service.stepFunctions = {
+        stateMachines: {
+          myStateMachine1: {
+            id: 'Test',
+            useExactVersion: true,
+            definition: {
+              StartAt: 'Lambda1',
+              States: {
+                Lambda1: {
+                  Type: 'Task',
+                  Resource: 'arn:aws:states:::lambda:invoke',
+                  Parameters: {
+                    FunctionName: {
+                      Ref: 'HelloLambdaFunction',
+                    },
+                    Payload: {
+                      'ExecutionName.$': '$$.Execution.Name',
+                    },
                   },
+                  Next: 'Lambda2',
                 },
-                Next: 'Lambda2',
-              },
-              Lambda2: {
-                Type: 'Task',
-                Resource: {
-                  'Fn::GetAtt': ['WorldLambdaFunction', 'Arn'],
+                Lambda2: {
+                  Type: 'Task',
+                  Resource: {
+                    'Fn::GetAtt': ['WorldLambdaFunction', 'Arn'],
+                  },
+                  End: true,
                 },
-                End: true,
               },
             },
           },
         },
-      },
-    };
-
-    serverlessStepFunctions.serverless.service
-      .provider.compiledCloudFormationTemplate.Resources
-      .HelloLambdaFunction = {
-        Type: 'AWS::Lambda::Function',
-      };
-
-    serverlessStepFunctions.serverless.service
-      .provider.compiledCloudFormationTemplate.Resources
-      .Lambda1Version13579 = {
-        Type: 'AWS::Lambda::Version',
-        Properties: {
-          FunctionName: {
-            Ref: 'HelloLambdaFunction',
-          },
-        },
       };
 
-    serverlessStepFunctions.serverless.service
-      .provider.compiledCloudFormationTemplate.Resources
-      .WorldLambdaFunction = {
-        Type: 'AWS::Lambda::Function',
-      };
+      serverlessStepFunctions.serverless.service
+        .provider.compiledCloudFormationTemplate.Resources
+        .HelloLambdaFunction = {
+          Type: 'AWS::Lambda::Function',
+        };
+
+      serverlessStepFunctions.serverless.service
+        .provider.compiledCloudFormationTemplate.Resources
+        .WorldLambdaFunction = {
+          Type: 'AWS::Lambda::Function',
+        };
+    });
+
+    const compileStateMachines = () => {
+      serverlessStepFunctions.compileStateMachines();
+      const stateMachine = serverlessStepFunctions.serverless.service
+        .provider.compiledCloudFormationTemplate.Resources
+        .Test;
+
+      expect(stateMachine.Properties.DefinitionString).to.haveOwnProperty('Fn::Sub');
+      expect(stateMachine.Properties.DefinitionString['Fn::Sub']).to.have.lengthOf(2);
+
+      const [json, params] = stateMachine.Properties.DefinitionString['Fn::Sub'];
+      const modifiedDefinition = JSON.parse(json);
+
+      const lambda1 = modifiedDefinition.States.Lambda1;
+      expect(lambda1.Parameters.FunctionName.startsWith('${')).to.eq(true);
+      const lambda1ParamName = lambda1.Parameters.FunctionName.replace(/[${}]/g, '');
+      expect(params).to.haveOwnProperty(lambda1ParamName);
+      const lambda1Param = params[lambda1ParamName];
+
+      const lambda2 = modifiedDefinition.States.Lambda2;
+      expect(lambda2.Resource.startsWith('${')).to.eq(true);
+      const lambda2ParamName = lambda2.Resource.replace(/[${}]/g, '');
+      expect(params).to.haveOwnProperty(lambda2ParamName);
+      const lambda2Param = params[lambda2ParamName];
+
+      return { lambda1Param, lambda2Param };
+    };
 
-    serverlessStepFunctions.serverless.service
-      .provider.compiledCloudFormationTemplate.Resources
-      .Lambda2Version24680 = {
-        Type: 'AWS::Lambda::Version',
-        Properties: {
-          FunctionName: {
-            Ref: 'WorldLambdaFunction',
+    it('should change refs to lambda version when useExactVersion is true', () => {
+      serverlessStepFunctions.serverless.service
+        .provider.compiledCloudFormationTemplate.Resources
+        .Lambda1Version13579 = {
+          Type: 'AWS::Lambda::Version',
+          Properties: {
+            FunctionName: {
+              Ref: 'HelloLambdaFunction',
+            },
           },
-        },
-      };
-
-    serverlessStepFunctions.compileStateMachines();
-    const stateMachine = serverlessStepFunctions.serverless.service
-      .provider.compiledCloudFormationTemplate.Resources
-      .Test;
-
-    expect(stateMachine.Properties.DefinitionString).to.haveOwnProperty('Fn::Sub');
-    expect(stateMachine.Properties.DefinitionString['Fn::Sub']).to.have.lengthOf(2);
-
-    const [json, params] = stateMachine.Properties.DefinitionString['Fn::Sub'];
-    const modifiedDefinition = JSON.parse(json);
-
-    const lambda1 = modifiedDefinition.States.Lambda1;
-    expect(lambda1.Parameters.FunctionName.startsWith('${')).to.eq(true);
-    const lambda1ParamName = lambda1.Parameters.FunctionName.replace(/[${}]/g, '');
-    expect(params).to.haveOwnProperty(lambda1ParamName);
-    const lambda1Param = params[lambda1ParamName];
-    expect(lambda1Param).to.eql({ Ref: 'Lambda1Version13579' });
-
-    const lambda2 = modifiedDefinition.States.Lambda2;
-    expect(lambda2.Resource.startsWith('${')).to.eq(true);
-    const lambda2ParamName = lambda2.Resource.replace(/[${}]/g, '');
-    expect(params).to.haveOwnProperty(lambda2ParamName);
-    const lambda2Param = params[lambda2ParamName];
-    expect(lambda2Param).to.eql({ Ref: 'Lambda2Version24680' });
+        };
+
+      serverlessStepFunctions.serverless.service
+        .provider.compiledCloudFormationTemplate.Resources
+        .Lambda2Version24680 = {
+          Type: 'AWS::Lambda::Version',
+          Properties: {
+            FunctionName: {
+              Ref: 'WorldLambdaFunction',
+            },
+          },
+        };
+
+      const { lambda1Param, lambda2Param } = compileStateMachines();
+      expect(lambda1Param).to.eql({ Ref: 'Lambda1Version13579' });
+      expect(lambda2Param).to.eql({ Ref: 'Lambda2Version24680' });
+    });
+
+    it('should not change refs to lambda version if version is not found, even if useExactVersion is true', () => {
+      const { lambda1Param, lambda2Param } = compileStateMachines();
+      expect(lambda1Param).to.eql({ Ref: 'HelloLambdaFunction' });
+      expect(lambda2Param).to.eql({ 'Fn::GetAtt': ['WorldLambdaFunction', 'Arn'] });
+    });
+
+    it('should not change refs to lambda version if not using intrinsic functions, even if useExactVersion is true', () => {
+      const states = serverless.service.stepFunctions
+        .stateMachines.myStateMachine1.definition.States;
+      states.Lambda1.Parameters.FunctionName = 'hello';
+      states.Lambda2.Resource = 'arn:aws:lambda:us-east-1:1234567890:function:world';
+
+      serverlessStepFunctions.compileStateMachines();
+      const stateMachine = serverlessStepFunctions.serverless.service
+        .provider.compiledCloudFormationTemplate.Resources
+        .Test;
+
+      const definition = JSON.parse(stateMachine.Properties.DefinitionString);
+      expect(definition.States.Lambda1.Parameters.FunctionName).to.equal('hello');
+      expect(definition.States.Lambda2.Resource)
+        .to.equal('arn:aws:lambda:us-east-1:1234567890:function:world');
+    });
   });
 });

lib/utils/aws.js

@@ -51,21 +51,25 @@ function convertToFunctionVersion(value) {
       return version[0];
     }
 
-    return logicalId;
+    return null;
   };
 
   if (_.has(value, 'Ref') && isFunction(value.Ref)) {
-    return {
-      Ref: getVersion(value.Ref),
-    };
+    const version = getVersion(value.Ref);
+    if (version) {
+      return { Ref: version };
+    }
+    return value;
   }
 
   // for Lambda function, Get::Att can only return the ARN
   // but for Lambda version, you need Ref to get its ARN, hence why we return Ref here
   if (_.has(value, 'Fn::GetAtt') && isFunction(value['Fn::GetAtt'][0])) {
-    return {
-      Ref: getVersion(value['Fn::GetAtt'][0]),
-    };
+    const version = getVersion(value['Fn::GetAtt'][0]);
+    if (version) {
+      return { Ref: version };
+    }
+    return value;
   }
 
   return value;