Display error log when invocation fail

Author: horike37

index.js

@@ -2,6 +2,7 @@
 const BbPromise = require('bluebird');
 const path = require('path');
 const _ = require('lodash');
+const chalk = require('chalk');
 
 class ServerlessStepFunctions {
   constructor(serverless, options) {
@@ -363,26 +364,48 @@ class ServerlessStepFunctions {
         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 BbPromise.resolve();
     });
   }
 
+  getExecutionHistory() {
+    return this.provider.request('StepFunctions',
+      'getExecutionHistory',
+      {
+        executionArn: this.executionArn,
+      },
+      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();
+    });
+  }
+
   yamlParse() {
     const servicePath = this.serverless.config.servicePath;
 
     if (!servicePath) {
       return BbPromise.resolve();
     }
 
-    let serverlessYmlPath = path.join(servicePath, 'serverless.yml');
-    if (!this.serverless.utils.fileExistsSync(serverlessYmlPath)) {
-      serverlessYmlPath = path
-        .join(this.serverless.config.servicePath, 'serverless.yaml');
-    }
-
+    const serverlessYmlPath = path.join(servicePath, 'serverless.yml');
     return this.serverless.yamlParser
       .parse(serverlessYmlPath)
       .then((serverlessFileParam) => {
@@ -393,7 +416,10 @@ class ServerlessStepFunctions {
 
   compile() {
     if (!this.stepFunctions) {
-      return BbPromise.resolve();
+      const errorMessage = [
+        'stepFunctions statement does not exists in serverless.yml',
+      ].join('');
+      throw new this.serverless.classes.Error(errorMessage);
     }
 
     if (typeof this.stepFunctions[this.options.state] === 'undefined') {

index.test.js

@@ -435,13 +435,34 @@ describe('ServerlessStepFunctions', () => {
 
   describe('#describeExecution()', () => {
     let describeExecutionStub;
-    beforeEach(() => {
+    it('should describeExecution with correct params', () => {
       describeExecutionStub = sinon.stub(serverlessStepFunctions.provider, 'request')
       .returns(BbPromise.resolve({ status: 'SUCCESS' }));
+
+      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);
+        serverlessStepFunctions.provider.request.restore();
+      });
     });
 
-    it('should describeExecution with correct params'
-    , () => serverlessStepFunctions.describeExecution()
+    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(
@@ -453,6 +474,33 @@ describe('ServerlessStepFunctions', () => {
           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()', () => {
+    let getExecutionHistoryStub;
+    beforeEach(() => {
+      getExecutionHistoryStub = sinon.stub(serverlessStepFunctions.provider, 'request')
+      .returns(BbPromise.resolve({ events: [{ executionFailedEventDetails: 'error' }] }));
+    });
+
+    it('should getExecutionHistory with correct params'
+    , () => serverlessStepFunctions.getExecutionHistory()
+      .then(() => {
+        expect(getExecutionHistoryStub.calledOnce).to.be.equal(true);
+        expect(getExecutionHistoryStub.calledWithExactly(
+          'StepFunctions',
+          'getExecutionHistory',
+          {
+            executionArn: serverlessStepFunctions.executionArn,
+          },
+          serverlessStepFunctions.options.stage,
+          serverlessStepFunctions.options.region
+        )).to.be.equal(true);
         serverlessStepFunctions.provider.request.restore();
       })
     );
@@ -473,9 +521,26 @@ describe('ServerlessStepFunctions', () => {
         expect(serverlessStepFunctions.stepFunctions).to.be.equal('stepFunctions');
       })
     );
+
+    it('should return resolve when servicePath does not exists', () => {
+      serverlessStepFunctions.serverless.config.servicePath = null;
+      serverlessStepFunctions.yamlParse()
+      .then(() => {
+        expect(yamlParserStub.callCount).to.be.equal(0);
+      });
+    });
   });
 
   describe('#compile()', () => {
+    it('should throw error when stepFunction state does not exists', () => {
+      expect(() => serverlessStepFunctions.compile()).to.throw(Error);
+    });
+
+    it('should throw error when stateMachine name does not exists', () => {
+      serverlessStepFunctions.stepFunctions = {};
+      expect(() => serverlessStepFunctions.compile()).to.throw(Error);
+    });
+
     it('should comple with correct params', () => {
       serverlessStepFunctions.stepFunctions = {
         stateMachine: {

package.json

@@ -38,6 +38,7 @@
   "dependencies": {
     "lodash": "^4.13.1",
     "aws-sdk": "^2.7.19",
-    "bluebird": "^3.4.0"
+    "bluebird": "^3.4.0",
+    "chalk": "^1.1.1"
   }
 }