codeceptjs 4.0.0-beta.4 → 4.0.0-beta.5

package/lib/recorder.js

@@ -1,27 +1,27 @@
-const debug = require('debug')('codeceptjs:recorder');
-const promiseRetry = require('promise-retry');
-const chalk = require('chalk');
-const { printObjectProperties } = require('./utils');
-const { log } = require('./output');
-
-const MAX_TASKS = 100;
-
-let promise;
-let running = false;
-let errFn;
-let queueId = 0;
-let sessionId = null;
-let asyncErr = null;
-let ignoredErrs = [];
-
-let tasks = [];
-let oldPromises = [];
+const debug = require('debug')('codeceptjs:recorder')
+const promiseRetry = require('promise-retry')
+const chalk = require('chalk')
+const { printObjectProperties } = require('./utils')
+const { log } = require('./output')
+const { TimeoutError } = require('./timeout')
+const MAX_TASKS = 100
+
+let promise
+let running = false
+let errFn
+let queueId = 0
+let sessionId = null
+let asyncErr = null
+let ignoredErrs = []
+
+let tasks = []
+let oldPromises = []
 
 const defaultRetryOptions = {
   retries: 0,
   minTimeout: 150,
   maxTimeout: 10000,
-};
+}
 
 /**
  * Singleton object to record all test steps as promises and run them in chain.
@@ -29,7 +29,6 @@ const defaultRetryOptions = {
  * @interface
  */
 module.exports = {
-
   /**
    * @type {Array<Object<string, *>>}
    * @inner
@@ -43,11 +42,11 @@ module.exports = {
    * @inner
    */
   start() {
-    debug('Starting recording promises');
-    running = true;
-    asyncErr = null;
-    errFn = null;
-    this.reset();
+    debug('Starting recording promises')
+    running = true
+    asyncErr = null
+    errFn = null
+    this.reset()
   },
 
   /**
@@ -55,7 +54,7 @@ module.exports = {
    * @inner
    */
   isRunning() {
-    return running;
+    return running
   },
 
   /**
@@ -64,7 +63,7 @@ module.exports = {
    */
   startUnlessRunning() {
     if (!this.isRunning()) {
-      this.start();
+      this.start()
     }
   },
 
@@ -76,7 +75,7 @@ module.exports = {
    * @inner
    */
   errHandler(fn) {
-    errFn = fn;
+    errFn = fn
   },
 
   /**
@@ -87,16 +86,16 @@ module.exports = {
    * @inner
    */
   reset() {
-    if (promise && running) this.catch();
-    queueId++;
-    sessionId = null;
-    asyncErr = null;
-    log(`${currentQueue()} Starting recording promises`);
-    promise = Promise.resolve();
-    oldPromises = [];
-    tasks = [];
-    ignoredErrs = [];
-    this.session.running = false;
+    if (promise && running) this.catch()
+    queueId++
+    sessionId = null
+    asyncErr = null
+    log(`${currentQueue()} Starting recording promises`)
+    promise = Promise.resolve()
+    oldPromises = []
+    tasks = []
+    ignoredErrs = []
+    this.session.running = false
     // reset this retries makes the retryFailedStep plugin won't work if there is Before/BeforeSuit block due to retries is undefined on Scenario
     // this.retries = [];
   },
@@ -123,12 +122,16 @@ module.exports = {
      * @inner
      */
     start(name) {
-      debug(`${currentQueue()}Starting <${name}> session`);
-      tasks.push('--->');
-      oldPromises.push(promise);
-      this.running = true;
-      sessionId = name;
-      promise = Promise.resolve();
+      if (sessionId) {
+        debug(`${currentQueue()}Session already started as ${sessionId}`)
+        this.restore(sessionId)
+      }
+      debug(`${currentQueue()}Starting <${name}> session`)
+      tasks.push('--->')
+      oldPromises.push(promise)
+      this.running = true
+      sessionId = name
+      promise = Promise.resolve()
     },
 
     /**
@@ -136,12 +139,12 @@ module.exports = {
      * @inner
      */
     restore(name) {
-      tasks.push('<---');
-      debug(`${currentQueue()}Finalize <${name}> session`);
-      this.running = false;
-      sessionId = null;
-      this.catch(errFn);
-      promise = promise.then(() => oldPromises.pop());
+      tasks.push('<---')
+      debug(`${currentQueue()}Finalize <${name}> session`)
+      this.running = false
+      sessionId = null
+      this.catch(errFn)
+      promise = promise.then(() => oldPromises.pop())
     },
 
     /**
@@ -149,9 +152,8 @@ module.exports = {
      * @inner
      */
     catch(fn) {
-      promise = promise.catch(fn);
+      promise = promise.catch(fn)
     },
-
   },
 
   /**
@@ -171,42 +173,48 @@ module.exports = {
    */
   add(taskName, fn = undefined, force = false, retry = undefined, timeout = undefined) {
     if (typeof taskName === 'function') {
-      fn = taskName;
-      taskName = fn.toString();
-      if (retry === undefined) retry = false;
+      fn = taskName
+      taskName = fn.toString()
+      if (retry === undefined) retry = false
     }
-    if (retry === undefined) retry = true;
+    if (retry === undefined) retry = true
     if (!running && !force) {
-      return;
+      return Promise.resolve()
     }
-    tasks.push(taskName);
-    debug(chalk.gray(`${currentQueue()} Queued | ${taskName}`));
+    tasks.push(taskName)
+    debug(chalk.gray(`${currentQueue()} Queued | ${taskName}`))
 
-    return promise = Promise.resolve(promise).then((res) => {
+    return (promise = Promise.resolve(promise).then(res => {
       // prefer options for non-conditional retries
-      const retryOpts = this.retries.sort((r1, r2) => r1.when && !r2.when).slice(-1).pop();
+      const retryOpts = this.retries
+        .sort((r1, r2) => r1.when && !r2.when)
+        .slice(-1)
+        .pop()
       // no retries or unnamed tasks
+      debug(`${currentQueue()} Running | ${taskName} | Timeout: ${timeout || 'None'}`)
+      if (retryOpts) debug(`${currentQueue()} Retry opts`, JSON.stringify(retryOpts))
+
       if (!retryOpts || !taskName || !retry) {
-        const [promise, timer] = getTimeoutPromise(timeout, taskName);
-        return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer));
+        const [promise, timer] = getTimeoutPromise(timeout, taskName)
+        return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer))
       }
 
-      debug(`${currentQueue()} Running | ${taskName}`);
-
-      const retryRules = this.retries.slice().reverse();
+      const retryRules = this.retries.slice().reverse()
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
-        if (number > 1) log(`${currentQueue()}Retrying... Attempt #${number}`);
-        const [promise, timer] = getTimeoutPromise(timeout, taskName);
-        return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer)).catch((err) => {
-          if (ignoredErrs.includes(err)) return;
-          for (const retryObj of retryRules) {
-            if (!retryObj.when) return retry(err);
-            if (retryObj.when && retryObj.when(err)) return retry(err);
-          }
-          throw err;
-        });
-      });
-    });
+        if (number > 1) log(`${currentQueue()}Retrying... Attempt #${number}`)
+        const [promise, timer] = getTimeoutPromise(timeout, taskName)
+        return Promise.race([promise, Promise.resolve(res).then(fn)])
+          .finally(() => clearTimeout(timer))
+          .catch(err => {
+            if (ignoredErrs.includes(err)) return
+            for (const retryObj of retryRules) {
+              if (!retryObj.when) return retry(err)
+              if (retryObj.when && retryObj.when(err)) return retry(err)
+            }
+            throw err
+          })
+      })
+    }))
   },
 
   /**
@@ -215,15 +223,15 @@ module.exports = {
    * @inner
    */
   retry(opts) {
-    if (!promise) return;
+    if (!promise) return
 
     if (opts === null) {
-      opts = {};
+      opts = {}
     }
     if (Number.isInteger(opts)) {
-      opts = { retries: opts };
+      opts = { retries: opts }
     }
-    return this.add(() => this.retries.push(opts));
+    return this.add(() => this.retries.push(opts))
   },
 
   /**
@@ -232,20 +240,25 @@ module.exports = {
    * @inner
    */
   catch(customErrFn) {
-    const fnDescription = customErrFn?.toString()?.replace(/\s{2,}/g, ' ').replace(/\n/g, ' ')?.slice(0, 50);
-    debug(chalk.gray(`${currentQueue()} Queued | catch with error handler ${fnDescription || ''}`));
-    return promise = promise.catch((err) => {
-      log(`${currentQueue()}Error | ${err} ${fnDescription}...`);
-      if (!(err instanceof Error)) { // strange things may happen
-        err = new Error(`[Wrapped Error] ${printObjectProperties(err)}`); // we should be prepared for them
+    const fnDescription = customErrFn
+      ?.toString()
+      ?.replace(/\s{2,}/g, ' ')
+      .replace(/\n/g, ' ')
+      ?.slice(0, 50)
+    debug(chalk.gray(`${currentQueue()} Queued | catch with error handler ${fnDescription || ''}`))
+    return (promise = promise.catch(err => {
+      log(`${currentQueue()}Error | ${err} ${fnDescription}...`)
+      if (!(err instanceof Error)) {
+        // strange things may happen
+        err = new Error(`[Wrapped Error] ${printObjectProperties(err)}`) // we should be prepared for them
       }
       if (customErrFn) {
-        customErrFn(err);
+        customErrFn(err)
       } else if (errFn) {
-        errFn(err);
+        errFn(err)
       }
-      this.stop();
-    });
+      this.stop()
+    }))
   },
 
   /**
@@ -254,17 +267,22 @@ module.exports = {
    * @inner
    */
   catchWithoutStop(customErrFn) {
-    const fnDescription = customErrFn?.toString()?.replace(/\s{2,}/g, ' ').replace(/\n/g, ' ')?.slice(0, 50);
-    return promise = promise.catch((err) => {
-      if (ignoredErrs.includes(err)) return; // already caught
-      log(`${currentQueue()} Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`);
-      if (!(err instanceof Error)) { // strange things may happen
-        err = new Error(`[Wrapped Error] ${JSON.stringify(err)}`); // we should be prepared for them
+    const fnDescription = customErrFn
+      ?.toString()
+      ?.replace(/\s{2,}/g, ' ')
+      .replace(/\n/g, ' ')
+      ?.slice(0, 50)
+    return (promise = promise.catch(err => {
+      if (ignoredErrs.includes(err)) return // already caught
+      log(`${currentQueue()} Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`)
+      if (!(err instanceof Error)) {
+        // strange things may happen
+        err = new Error(`[Wrapped Error] ${JSON.stringify(err)}`) // we should be prepared for them
       }
       if (customErrFn) {
-        return customErrFn(err);
+        return customErrFn(err)
       }
-    });
+    }))
   },
 
   /**
@@ -276,15 +294,15 @@ module.exports = {
    */
 
   throw(err) {
-    if (ignoredErrs.includes(err)) return promise; // already caught
+    if (ignoredErrs.includes(err)) return promise // already caught
     return this.add(`throw error: ${err.message}`, () => {
-      if (ignoredErrs.includes(err)) return; // already caught
-      throw err;
-    });
+      if (ignoredErrs.includes(err)) return // already caught
+      throw err
+    })
   },
 
   ignoreErr(err) {
-    ignoredErrs.push(err);
+    ignoredErrs.push(err)
   },
 
   /**
@@ -293,7 +311,7 @@ module.exports = {
    */
   saveFirstAsyncError(err) {
     if (asyncErr === null) {
-      asyncErr = err;
+      asyncErr = err
     }
   },
 
@@ -302,7 +320,7 @@ module.exports = {
    * @inner
    */
   getAsyncErr() {
-    return asyncErr;
+    return asyncErr
   },
 
   /**
@@ -310,7 +328,7 @@ module.exports = {
    * @inner
    */
   cleanAsyncErr() {
-    asyncErr = null;
+    asyncErr = null
   },
 
   /**
@@ -319,9 +337,9 @@ module.exports = {
    * @inner
    */
   stop() {
-    debug(this.toString());
-    log(`${currentQueue()} Stopping recording promises`);
-    running = false;
+    debug(this.toString())
+    log(`${currentQueue()} Stopping recording promises`)
+    running = false
   },
 
   /**
@@ -332,7 +350,7 @@ module.exports = {
    * @inner
    */
   promise() {
-    return promise;
+    return promise
   },
 
   /**
@@ -341,7 +359,7 @@ module.exports = {
    * @inner
    */
   scheduled() {
-    return tasks.slice(-MAX_TASKS).join('\n');
+    return tasks.slice(-MAX_TASKS).join('\n')
   },
 
   /**
@@ -350,7 +368,7 @@ module.exports = {
    * @inner
    */
   getQueueId() {
-    return queueId;
+    return queueId
   },
 
   /**
@@ -359,21 +377,34 @@ module.exports = {
    * @inner
    */
   toString() {
-    return `Queue: ${currentQueue()}\n\nTasks: ${this.scheduled()}`;
+    return `Queue: ${currentQueue()}\n\nTasks: ${this.scheduled()}`
   },
 
-};
+  /**
+   * Get current session ID
+   * @return {string|null}
+   * @inner
+   */
+  getCurrentSessionId() {
+    return sessionId
+  },
+}
 
 function getTimeoutPromise(timeoutMs, taskName) {
-  let timer;
-  if (timeoutMs) debug(`Timing out in ${timeoutMs}ms`);
-  return [new Promise((done, reject) => {
-    timer = setTimeout(() => { reject(new Error(`Action ${taskName} was interrupted on step timeout ${timeoutMs}ms`)); }, timeoutMs || 2e9);
-  }), timer];
+  let timer
+  if (timeoutMs) debug(`Timing out in ${timeoutMs}ms`)
+  return [
+    new Promise((done, reject) => {
+      timer = setTimeout(() => {
+        reject(new TimeoutError(`Action ${taskName} was interrupted on timeout ${timeoutMs}ms`))
+      }, timeoutMs || 2e9)
+    }),
+    timer,
+  ]
 }
 
 function currentQueue() {
-  let session = '';
-  if (sessionId) session = `<${sessionId}> `;
-  return `[${queueId}] ${session}`;
+  let session = ''
+  if (sessionId) session = `<${sessionId}> `
+  return `[${queueId}] ${session}`
 }

package/lib/rerun.js

@@ -1,81 +1,82 @@
-const fsPath = require('path');
-const container = require('./container');
-const event = require('./event');
-const BaseCodecept = require('./codecept');
-const output = require('./output');
+const fsPath = require('path')
+const container = require('./container')
+const event = require('./event')
+const BaseCodecept = require('./codecept')
+const output = require('./output')
 
 class CodeceptRerunner extends BaseCodecept {
   runOnce(test) {
     return new Promise((resolve, reject) => {
       // @ts-ignore
-      container.createMocha();
-      const mocha = container.mocha();
-      this.testFiles.forEach((file) => {
-        delete require.cache[file];
-      });
-      mocha.files = this.testFiles;
+      container.createMocha()
+      const mocha = container.mocha()
+      this.testFiles.forEach(file => {
+        delete require.cache[file]
+      })
+      mocha.files = this.testFiles
       if (test) {
         if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test);
+          test = fsPath.join(global.codecept_dir, test)
         }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test);
+        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test)
       }
       try {
-        mocha.run((failures) => {
+        mocha.run(failures => {
           if (failures === 0) {
-            resolve();
+            resolve()
           } else {
-            reject(new Error(`${failures} tests fail`));
+            reject(new Error(`${failures} tests fail`))
           }
-        });
+        })
       } catch (e) {
-        reject(e);
+        reject(e)
       }
-    });
+    })
   }
 
   async runTests(test) {
-    const configRerun = this.config.rerun || {};
-    const minSuccess = configRerun.minSuccess || 1;
-    const maxReruns = configRerun.maxReruns || 1;
+    const configRerun = this.config.rerun || {}
+    const minSuccess = configRerun.minSuccess || 1
+    const maxReruns = configRerun.maxReruns || 1
     if (minSuccess > maxReruns) {
-      process.exitCode = 1;
-      throw new Error(`run-rerun Configuration Error: minSuccess must be less than maxReruns. Current values: minSuccess=${minSuccess} maxReruns=${maxReruns}`);
+      process.exitCode = 1
+      throw new Error(`run-rerun Configuration Error: minSuccess must be less than maxReruns. Current values: minSuccess=${minSuccess} maxReruns=${maxReruns}`)
     }
     if (maxReruns === 1) {
-      await this.runOnce(test);
-      return;
+      await this.runOnce(test)
+      return
     }
-    let successCounter = 0;
-    let rerunsCounter = 0;
+    let successCounter = 0
+    let rerunsCounter = 0
     while (rerunsCounter < maxReruns && successCounter < minSuccess) {
-      rerunsCounter++;
+      container.result().reset() // reset result
+      rerunsCounter++
       try {
-        await this.runOnce(test);
-        successCounter++;
-        output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`);
+        await this.runOnce(test)
+        successCounter++
+        output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`)
       } catch (e) {
-        output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`);
-        console.error(e);
+        output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`)
+        console.error(e)
       }
     }
     if (successCounter < minSuccess) {
-      throw new Error(`Flaky tests detected! ${successCounter} success runs achieved instead of ${minSuccess} success runs expected`);
+      throw new Error(`Flaky tests detected! ${successCounter} success runs achieved instead of ${minSuccess} success runs expected`)
     }
   }
 
   async run(test) {
-    event.emit(event.all.before, this);
+    event.emit(event.all.before, this)
     try {
-      await this.runTests(test);
+      await this.runTests(test)
     } catch (e) {
-      output.error(e.stack);
-      throw e;
+      output.error(e.stack)
+      throw e
     } finally {
-      event.emit(event.all.result, this);
-      event.emit(event.all.after, this);
+      event.emit(event.all.result, this)
+      event.emit(event.all.after, this)
     }
   }
 }
 
-module.exports = CodeceptRerunner;
+module.exports = CodeceptRerunner