update test code

Author: horike37

index.js

@@ -153,7 +153,7 @@ class ServerlessStepFunctions {
       if (error.statusCode === 404) {
         return this.createIamRole();
       }
-      return BbPromise.reject();
+      throw new this.serverless.classes.Error(error.message);
     });
   }
 

index.test.js

@@ -18,6 +18,7 @@ describe('ServerlessStepFunctions', () => {
     serverless.service.functions = {
       first: {
         handler: true,
+        name: 'first',
       },
     };
     const options = {
@@ -27,6 +28,7 @@ describe('ServerlessStepFunctions', () => {
       functionObj: {
         name: 'first',
       },
+      state: 'stateMachine',
     };
     serverless.init();
     serverless.setProvider('aws', new AwsProvider(serverless));
@@ -180,4 +182,126 @@ describe('ServerlessStepFunctions', () => {
         });
     });
   });
+
+  describe('#getIamRole()', () => {
+    let getRoleStub;
+    beforeEach(() => {
+      getRoleStub = sinon.stub(serverlessStepFunctions.provider, 'request')
+      .returns(BbPromise.resolve({Role:{Arn:'roleArn'}}));
+    });
+
+    it('should getIamRole with correct params', () => serverlessStepFunctions.getIamRole()
+      .then(() => {
+        expect(getRoleStub.calledOnce).to.be.equal(true);
+        expect(getRoleStub.calledWithExactly(
+          'IAM',
+          'getRole',
+          {
+            RoleName: 'serverless-step-functions-executerole-us-east-1',
+          },
+          serverlessStepFunctions.options.stage,
+          serverlessStepFunctions.options.region
+        )).to.be.equal(true);
+        expect(serverlessStepFunctions.iamRoleArn).to.be.equal('roleArn');
+        serverlessStepFunctions.provider.request.restore();
+      })
+    );
+
+    it('should createRole when statusCode is 404', () => {
+      serverlessStepFunctions.provider.request.restore();
+      const getRoleErrorStub = sinon.stub(serverlessStepFunctions.provider, 'request')
+       .returns(BbPromise.reject({statusCode: 404}));
+      const createIamRoleStub = sinon
+        .stub(serverlessStepFunctions, 'createIamRole').returns(BbPromise.resolve());
+
+      serverlessStepFunctions.getIamRole().catch((error) => {
+        expect(createIamRole.calledOnce).to.be.equal(true);
+        serverlessStepFunctions.provider.request.restore();
+        serverlessStepFunctions.createIamRole.restore();
+      });
+    });
+
+    it('should throw error when statusCode is not 404', () => {
+      serverlessStepFunctions.provider.request.restore();
+      const getRoleErrorStub = sinon.stub(serverlessStepFunctions.provider, 'request')
+       .returns(BbPromise.reject({statusCode: 502}));
+
+      serverlessStepFunctions.getIamRole().catch((error) => {
+        expect(error.name).to.be.equal('ServerlessError');
+        serverlessStepFunctions.provider.request.restore();
+      });
+    });
+  });
+
+  describe('#getFunctionArns()', () => {
+    let getCallerIdentityStub;
+    beforeEach(() => {
+      getCallerIdentityStub = sinon.stub(serverlessStepFunctions.provider, 'request')
+      .returns(BbPromise.resolve({Account:1234}));
+    });
+
+    it('should getFunctionArns with correct params', () => serverlessStepFunctions.getFunctionArns()
+      .then(() => {
+        expect(getCallerIdentityStub.calledOnce).to.be.equal(true);
+        expect(getCallerIdentityStub.calledWithExactly(
+          'STS',
+          'getCallerIdentity',
+          {},
+          serverlessStepFunctions.options.stage,
+          serverlessStepFunctions.options.region
+        )).to.be.equal(true);
+        expect(serverlessStepFunctions.functionArns.first).to.be
+        .equal('arn:aws:lambda:us-east-1:1234:function:first');
+        serverlessStepFunctions.provider.request.restore();
+      })
+    );
+  });
+
+  describe('#createIamRole()', () => {
+    let createIamRoleStub;
+    beforeEach(() => {
+      createIamRoleStub = sinon.stub(serverlessStepFunctions.provider, 'request');
+      createIamRoleStub.onFirstCall().returns(BbPromise.resolve({Role:{Arn:'roleArn'}}));
+      createIamRoleStub.onSecondCall().returns(BbPromise.resolve({Policy:{Arn:'policyArn'}}));
+      createIamRoleStub.onThirdCall().returns(BbPromise.resolve());
+    });
+
+    it('should createIamRole with correct params', () => serverlessStepFunctions.createIamRole()
+      .then(() => {
+        expect(createIamRoleStub.calledThrice).to.be.equal(true);
+        expect(createIamRoleStub.args[0][0]).to.be.equal('IAM');
+        expect(createIamRoleStub.args[0][1]).to.be.equal('createRole');
+        expect(createIamRoleStub.args[1][0]).to.be.equal('IAM');
+        expect(createIamRoleStub.args[1][1]).to.be.equal('createPolicy');
+        expect(createIamRoleStub.args[2][0]).to.be.equal('IAM');
+        expect(createIamRoleStub.args[2][1]).to.be.equal('attachRolePolicy');
+        serverlessStepFunctions.provider.request.restore();
+      })
+    );
+  });
+
+  describe('#getStateMachineArn()', () => {
+    let getStateMachineStub;
+    beforeEach(() => {
+      getStateMachineStub = sinon.stub(serverlessStepFunctions.provider, 'request')
+      .returns(BbPromise.resolve({Account:1234}));
+    });
+
+    it('should getStateMachineStub with correct params', () => serverlessStepFunctions.getStateMachineArn()
+      .then(() => {
+        expect(getStateMachineStub.calledOnce).to.be.equal(true);
+        expect(getStateMachineStub.calledWithExactly(
+          'STS',
+          'getCallerIdentity',
+          {},
+          serverlessStepFunctions.options.stage,
+          serverlessStepFunctions.options.region
+        )).to.be.equal(true);
+        expect(serverlessStepFunctions.stateMachineArn).to.be
+        .equal('arn:aws:states:us-east-1:1234:stateMachine:stateMachine-dev');
+        serverlessStepFunctions.provider.request.restore();
+      })
+    );
+  });
 });
+