do not retry within and session (#1633)

* hide err.stack if stack is undefined

* don't retry session and within

* Add test to retryFailedStep plugin

Author: tsuemura

lib/listener/trace.js

@@ -26,6 +26,10 @@ module.exports = function () {
       err.stack = ''; // hide internal error stack trace in non-verbose mode
     }
 
+    if (err.stack === undefined) {
+      err.stack = '';
+    }
+
     err.stack = msg + err.stack;
     test.err = err;
   });

lib/recorder.js

@@ -113,8 +113,11 @@ module.exports = {
    * @param {*} taskName
    * @param {*} fn
    * @param {*} force
+   * @param {boolean} retry -
+   *     true: it will retries if `retryOpts` set.
+   *     false: ignore `retryOpts` and won't retry.
    */
-  add(taskName, fn = undefined, force = false) {
+  add(taskName, fn = undefined, force = false, retry = true) {
     if (typeof taskName === 'function') {
       fn = taskName;
       taskName = fn.toString();
@@ -129,7 +132,7 @@ module.exports = {
     return promise = Promise.resolve(promise).then((res) => {
       const retryOpts = this.retries.slice(-1).pop();
       // no retries or unnamed tasks
-      if (!retryOpts || !taskName) {
+      if (!retryOpts || !taskName || !retry) {
         return Promise.resolve(res).then(fn);
       }
 

lib/session.js

@@ -117,7 +117,7 @@ function session(sessionName, config, fn) {
     }
     finalize();
     return recorder.promise().then(() => res);
-  });
+  }, false, false);
 }
 
 

lib/within.js

@@ -58,7 +58,7 @@ function within(context, fn) {
     }
     finalize();
     return recorder.promise().then(() => res);
-  });
+  }, false, false);
 }
 
 module.exports = within;

test/unit/plugin/retryFailedStep_test.js

@@ -0,0 +1,74 @@
+const retryFailedStep = require('../../../lib/plugin/retryFailedStep');
+const sinon = require('sinon');
+const within = require('../../../lib/within');
+const session = require('../../../lib/session');
+const container = require('../../../lib/container');
+const event = require('../../../lib/event');
+const recorder = require('../../../lib/recorder');
+const assert = require('assert');
+
+describe('retryFailedStep', () => {
+  beforeEach(() => {
+    container.clear({
+      mock: {
+        _session: () => {},
+      },
+    });
+    recorder.start();
+  });
+  it('should retry failed step', async () => {
+    retryFailedStep({ retries: 2, minTimeout: 1 });
+    event.dispatcher.emit(event.test.before);
+
+    let counter = 0;
+    recorder.add(() => {
+      counter++;
+      if (counter < 3) {
+        throw new Error();
+      }
+    });
+    return recorder.promise();
+  });
+  it('should not retry within', async () => {
+    retryFailedStep({ retries: 1, minTimeout: 1 });
+    event.dispatcher.emit(event.test.before);
+
+    let counter = 0;
+
+    try {
+      within('foo', () => {
+        recorder.add(() => {
+          counter++;
+          throw new Error();
+        });
+      });
+      await recorder.promise();
+    } catch (e) {
+      recorder.catchWithoutStop((err) => {});
+    }
+
+    // expects to retry only once
+    counter.should.equal(2);
+  });
+  it('should not retry session', async () => {
+    retryFailedStep({ retries: 1, minTimeout: 1 });
+    event.dispatcher.emit(event.test.before);
+
+    let counter = 0;
+
+    try {
+      session('foo', () => {
+        recorder.add(() => {
+          counter++;
+          throw new Error();
+        });
+      });
+      await recorder.promise();
+    } catch (e) {
+      recorder.catchWithoutStop((err) => {});
+    }
+
+    // expects to retry only once
+    counter.should.equal(2);
+  });
+});