fixed invocation error

Author: horike37

index.js

@@ -274,7 +274,25 @@ class ServerlessStepFunctions {
     .then(this.parseInputdate)
     .then(this.getStateMachineArn)
     .then(this.startExecution)
-    .then(this.describeExecution);
+    .then(this.describeExecution)
+    .then((result) => {
+      this.serverless.cli.consoleLog('');
+      this.serverless.cli.consoleLog(chalk.yellow.underline('Execution Result'));
+      this.serverless.cli.consoleLog('');
+      this.serverless.cli.consoleLog(result);
+
+      if (result.status === 'FAILED') {
+        return this.getExecutionHistory()
+        .then((error) => {
+          this.serverless.cli.consoleLog('');
+          this.serverless.cli.consoleLog(chalk.yellow.underline('Error Log'));
+          this.serverless.cli.consoleLog('');
+          this.serverless.cli.consoleLog(error.events[error.events.length - 1]
+          .executionFailedEventDetails);
+        });
+      }
+      return BbPromise.resolve();
+    });
   }
 
   tasksDeploy() {
@@ -549,11 +567,10 @@ class ServerlessStepFunctions {
   }
 
   startExecution() {
-    this.serverless.cli.log(`Start function ${this.options.state}...`);
     return this.provider.request('StepFunctions',
       'startExecution',
       {
-        stateMachineArn: this.stateMachineArn,
+        stateMachineArn: this.stateMachineArns[this.options.state],
         input: this.options.data,
       },
       this.options.stage,
@@ -577,20 +594,10 @@ class ServerlessStepFunctions {
     .then((result) => {
       if (result.status === 'RUNNING') {
         this.serverless.cli.printDot();
-        setTimeout(this.describeExecution.bind(this), 5000);
-      } else {
-        this.serverless.cli.consoleLog('');
-        this.serverless.cli.consoleLog('');
-        const msg = 'Execution Result -----------------------------------------';
-        this.serverless.cli.consoleLog(chalk.yellow(msg));
-        this.serverless.cli.consoleLog('');
-        this.serverless.cli.consoleLog(result);
-
-        if (result.status === 'FAILED') {
-          return this.getExecutionHistory();
-        }
+        return this.setTimeout()
+        .then(() => this.describeExecution());
       }
-      return BbPromise.resolve();
+      return BbPromise.resolve(result);
     });
   }
 
@@ -602,15 +609,7 @@ class ServerlessStepFunctions {
       },
       this.options.stage,
       this.options.region)
-    .then((result) => {
-      this.serverless.cli.consoleLog('');
-      const msg = 'Error Log ------------------------------------------------';
-      this.serverless.cli.consoleLog(chalk.yellow(msg));
-      this.serverless.cli.consoleLog('');
-      this.serverless.cli.consoleLog(result.events[result.events.length - 1]
-      .executionFailedEventDetails);
-      return BbPromise.resolve();
-    });
+    .then((result) => BbPromise.resolve(result));
   }
 
   yamlParse() {

index.test.js

@@ -169,24 +169,60 @@ describe('ServerlessStepFunctions', () => {
 
   describe('#stateMachineInvoke()', () => {
     it('should run promise chain in order', () => {
+      const parseInputdateStub = sinon
+        .stub(serverlessStepFunctions, 'parseInputdate').returns(BbPromise.resolve());
       const getStateMachineArnStub = sinon
         .stub(serverlessStepFunctions, 'getStateMachineArn').returns(BbPromise.resolve());
       const startExecutionStub = sinon
         .stub(serverlessStepFunctions, 'startExecution').returns(BbPromise.resolve());
       const describeExecutionStub = sinon
-        .stub(serverlessStepFunctions, 'describeExecution').returns(BbPromise.resolve());
+        .stub(serverlessStepFunctions, 'describeExecution').returns(BbPromise.resolve({ status: 'SUCCEED' }));
 
       return serverlessStepFunctions.stateMachineInvoke()
         .then(() => {
-          expect(getStateMachineArnStub.calledOnce).to.be.equal(true);
+          expect(parseInputdateStub.calledOnce).to.be.equal(true);
+          expect(getStateMachineArnStub.calledAfter(parseInputdateStub)).to.be.equal(true);
           expect(startExecutionStub.calledAfter(getStateMachineArnStub)).to.be.equal(true);
           expect(describeExecutionStub.calledAfter(startExecutionStub)).to.be.equal(true);
 
+          serverlessStepFunctions.parseInputdate.restore();
           serverlessStepFunctions.getStateMachineArn.restore();
           serverlessStepFunctions.startExecution.restore();
           serverlessStepFunctions.describeExecution.restore();
         });
     });
+
+    it('should run promise chain in order when invocation error occurs', () => {
+      const parseInputdateStub = sinon
+        .stub(serverlessStepFunctions, 'parseInputdate').returns(BbPromise.resolve());
+      const getStateMachineArnStub = sinon
+        .stub(serverlessStepFunctions, 'getStateMachineArn').returns(BbPromise.resolve());
+      const startExecutionStub = sinon
+        .stub(serverlessStepFunctions, 'startExecution').returns(BbPromise.resolve());
+      const describeExecutionStub = sinon
+        .stub(serverlessStepFunctions, 'describeExecution').returns(BbPromise.resolve({ status: 'FAILED' }));
+      const getExecutionHistoryStub = sinon
+        .stub(serverlessStepFunctions, 'getExecutionHistory').returns(BbPromise.resolve({
+          events: [{
+            executionFailedEventDetails: '',
+          }],
+        }));
+
+      return serverlessStepFunctions.stateMachineInvoke()
+        .then(() => {
+          expect(parseInputdateStub.calledOnce).to.be.equal(true);
+          expect(getStateMachineArnStub.calledAfter(parseInputdateStub)).to.be.equal(true);
+          expect(startExecutionStub.calledAfter(getStateMachineArnStub)).to.be.equal(true);
+          expect(describeExecutionStub.calledAfter(startExecutionStub)).to.be.equal(true);
+          expect(getExecutionHistoryStub.calledAfter(describeExecutionStub)).to.be.equal(true);
+
+          serverlessStepFunctions.parseInputdate.restore();
+          serverlessStepFunctions.getStateMachineArn.restore();
+          serverlessStepFunctions.startExecution.restore();
+          serverlessStepFunctions.describeExecution.restore();
+          serverlessStepFunctions.getExecutionHistory.restore();
+        });
+    });
   });
 
   describe('#getIamRoleName', () => {
@@ -490,31 +526,6 @@ describe('ServerlessStepFunctions', () => {
         serverlessStepFunctions.provider.request.restore();
       });
     });
-
-    it('should describeExecution with status FAILED', () => {
-      describeExecutionStub = sinon.stub(serverlessStepFunctions.provider, 'request')
-        .returns(BbPromise.resolve({ status: 'FAILED' }));
-      const getExecutionHistoryStub = sinon
-        .stub(serverlessStepFunctions, 'getExecutionHistory')
-        .returns(BbPromise.resolve({ events: [{ executionFailedEventDetails: 'error' }] }));
-
-      serverlessStepFunctions.describeExecution()
-      .then(() => {
-        expect(describeExecutionStub.calledOnce).to.be.equal(true);
-        expect(describeExecutionStub.calledWithExactly(
-          'StepFunctions',
-          'describeExecution',
-          {
-            executionArn: serverlessStepFunctions.executionArn,
-          },
-          serverlessStepFunctions.options.stage,
-          serverlessStepFunctions.options.region
-        )).to.be.equal(true);
-        expect(getExecutionHistoryStub.calledOnce).to.be.equal(true);
-        serverlessStepFunctions.provider.request.restore();
-        serverlessStepFunctions.getExecutionHistory.restore();
-      });
-    });
   });
 
   describe('#getExecutionHistory()', () => {