codeceptjs 3.7.0-beta.7 → 3.7.0-beta.9

package/lib/plugin/tryTo.js

@@ -1,4 +1,6 @@
-module.exports = function () {
+const { tryTo } = require('../effects')
+
+module.exports = function (config) {
   console.log(`
 Deprecated Warning: 'tryTo' has been moved to the effects module.
 You should update your tests to use it as follows:
@@ -14,4 +16,10 @@ await tryTo(() => {
 
 For more details, refer to the documentation.
   `)
+
+  if (config.registerGlobal) {
+    global.tryTo = tryTo
+  }
+
+  return tryTo
 }

package/lib/recorder.js

@@ -3,7 +3,7 @@ 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
@@ -191,13 +191,13 @@ module.exports = {
         .slice(-1)
         .pop()
       // no retries or unnamed tasks
+      debug(`${currentQueue()} Running | ${taskName} | Timeout: ${timeout || 'None'}`)
+
       if (!retryOpts || !taskName || !retry) {
         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()
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
         if (number > 1) log(`${currentQueue()}Retrying... Attempt #${number}`)
@@ -386,7 +386,7 @@ function getTimeoutPromise(timeoutMs, taskName) {
   return [
     new Promise((done, reject) => {
       timer = setTimeout(() => {
-        reject(new Error(`Action ${taskName} was interrupted on step timeout ${timeoutMs}ms`))
+        reject(new TimeoutError(`Action ${taskName} was interrupted on timeout ${timeoutMs}ms`))
       }, timeoutMs || 2e9)
     }),
     timer,

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

package/lib/result.js

@@ -0,0 +1,161 @@
+const fs = require('fs')
+const path = require('path')
+const { serializeTest } = require('./mocha/test')
+
+/**
+ * Result of the test run
+ *
+ * @typedef {Object} Stats
+ * @property {number} passes
+ * @property {number} failures
+ * @property {number} tests
+ * @property {number} pending
+ * @property {number} failedHooks
+ * @property {Date} start
+ * @property {Date} end
+ * @property {number} duration
+ */
+class Result {
+  /**
+   * Create Result of the test run
+   */
+  constructor() {
+    this._startTime = new Date()
+    this._endTime = null
+
+    this.reset()
+    this.start()
+  }
+
+  reset() {
+    this._stats = {
+      passes: 0,
+      failures: 0,
+      tests: 0,
+      pending: 0,
+      failedHooks: 0,
+      start: null,
+      end: null,
+      duration: 0,
+    }
+
+    /** @type {CodeceptJS.Test[]} */
+    this._tests = []
+
+    /** @type {String[]} */
+    this._failures = []
+  }
+
+  start() {
+    this._startTime = new Date()
+  }
+
+  finish() {
+    this._endTime = new Date()
+  }
+
+  get hasFailed() {
+    return this._stats.failures > 0
+  }
+
+  get tests() {
+    return this._tests
+  }
+
+  get failures() {
+    return this._failures.filter(f => f && (!Array.isArray(f) || f.length > 0))
+  }
+
+  get stats() {
+    return this._stats
+  }
+
+  get startTime() {
+    return this._startTime
+  }
+
+  /**
+   * Add test to result
+   *
+   * @param {CodeceptJS.Test} test
+   */
+  addTest(test) {
+    const existingTestIndex = this._tests.findIndex(t => !!t.uid && t.uid === test.uid)
+    if (existingTestIndex >= 0) {
+      this._tests[existingTestIndex] = test
+      return
+    }
+
+    this._tests.push(test)
+  }
+
+  /**
+   * Add failures to result
+   *
+   * @param {String[]} newFailures
+   */
+  addFailures(newFailures) {
+    this._failures.push(...newFailures)
+  }
+
+  get hasFailures() {
+    return this.stats.failures > 0
+  }
+
+  get duration() {
+    return this._endTime ? +this._endTime - +this._startTime : 0
+  }
+
+  get failedTests() {
+    return this._tests.filter(test => test.state === 'failed')
+  }
+
+  get passedTests() {
+    return this._tests.filter(test => test.state === 'passed')
+  }
+
+  get skippedTests() {
+    return this._tests.filter(test => test.state === 'skipped' || test.state === 'pending')
+  }
+
+  simplify() {
+    return {
+      hasFailed: this.hasFailed,
+      stats: this.stats,
+      duration: this.duration,
+      tests: this._tests.map(test => serializeTest(test)),
+      failures: this._failures,
+    }
+  }
+
+  /**
+   * Save result to json file
+   *
+   * @param {string} fileName
+   */
+  save(fileName) {
+    if (!fileName) fileName = 'result.json'
+    fs.writeFileSync(path.join(global.output_dir, fileName), JSON.stringify(this.simplify(), null, 2))
+  }
+
+  /**
+   * Add stats to result
+   *
+   * @param {object} newStats
+   */
+  addStats(newStats = {}) {
+    this._stats.passes += newStats.passes || 0
+    this._stats.failures += newStats.failures || 0
+    this._stats.tests += newStats.tests || 0
+    this._stats.pending += newStats.pending || 0
+    this._stats.failedHooks += newStats.failedHooks || 0
+
+    // do not override start time
+    this._stats.start = this._stats.start || newStats.start
+
+    this._stats.end = newStats.end || this._stats.end
+    this._stats.duration = newStats.duration
+  }
+}
+
+module.exports = Result

package/lib/step/base.js

@@ -1,9 +1,9 @@
 const color = require('chalk')
 const Secret = require('../secret')
-const { getCurrentTimeout } = require('./timeout')
-const { ucfirst, humanizeString } = require('../utils')
+const { getCurrentTimeout } = require('../timeout')
+const { ucfirst, humanizeString, serializeError } = require('../utils')
 
-const STACK_LINE = 4
+const STACK_LINE = 5
 
 /**
  * Each command in test executed through `I.` object is wrapped in Step.
@@ -37,6 +37,9 @@ class Step {
     /** @member {string} */
     this.stack = ''
 
+    this.startTime = 0
+    this.endTime = 0
+
     this.setTrace()
   }
 
@@ -159,6 +162,51 @@ class Step {
     return this.constructor.name === 'MetaStep'
   }
 
+  get duration() {
+    if (!this.startTime || !this.endTime) return 0
+    return this.endTime - this.startTime
+  }
+
+  simplify() {
+    const step = this
+
+    const parent = {}
+    if (step.metaStep) {
+      parent.title = step.metaStep.actor
+    }
+
+    if (step.opts) {
+      Object.keys(step.opts).forEach(k => {
+        if (typeof step.opts[k] === 'object') delete step.opts[k]
+        if (typeof step.opts[k] === 'function') delete step.opts[k]
+      })
+    }
+
+    const args = []
+    if (step.args) {
+      for (const arg of step.args) {
+        // check if arg is a JOI object
+        if (arg && typeof arg === 'function') {
+          args.push(arg.name)
+        } else if (typeof arg == 'string') {
+          args.push(arg)
+        } else {
+          args.push(JSON.stringify(arg).slice(0, 300))
+        }
+      }
+    }
+
+    return {
+      opts: step.opts || {},
+      title: step.name,
+      args: args,
+      status: step.status,
+      startTime: step.startTime,
+      endTime: step.endTime,
+      parent,
+    }
+  }
+
   /** @return {boolean} */
   hasBDDAncestor() {
     let hasBDD = false
@@ -166,7 +214,7 @@ class Step {
     processingStep = this
 
     while (processingStep.metaStep) {
-      if (processingStep.metaStep.actor.match(/^(Given|When|Then|And)/)) {
+      if (processingStep.metaStep.actor?.match(/^(Given|When|Then|And)/)) {
         hasBDD = true
         break
       } else {

package/lib/step/func.js

@@ -0,0 +1,46 @@
+const BaseStep = require('./base')
+const store = require('../store')
+
+/**
+ * Function executed as a step
+ */
+class FuncStep extends BaseStep {
+  // this is actual function that should be executed within step
+  setCallable(fn) {
+    this.fn = fn
+  }
+
+  // helper is optional, if we need to allow step to access helper methods
+  setHelper(helper) {
+    this.helper = helper
+  }
+
+  run() {
+    if (!this.fn) throw new Error('Function is not set')
+
+    // we wrap that function to track time and status
+    // and disable it in dry run mode
+    this.args = Array.prototype.slice.call(arguments)
+    this.startTime = +Date.now()
+
+    if (store.dryRun) {
+      this.setStatus('success')
+      // should we add Proxy and dry run resolver here?
+      return Promise.resolve(true)
+    }
+
+    let result
+    try {
+      result = this.fn.apply(this.helper, this.args)
+      this.setStatus('success')
+      this.endTime = +Date.now()
+    } catch (err) {
+      this.endTime = +Date.now()
+      this.setStatus('failed')
+      throw err
+    }
+    return result
+  }
+}
+
+module.exports = FuncStep

package/lib/step/helper.js

@@ -16,6 +16,7 @@ class HelperStep extends Step {
    */
   run() {
     this.args = Array.prototype.slice.call(arguments)
+    this.startTime = +Date.now()
 
     if (store.dryRun) {
       this.setStatus('success')
@@ -27,7 +28,9 @@ class HelperStep extends Step {
         result = this.helper[this.helperMethod].apply(this.helper, this.args)
       }
       this.setStatus('success')
+      this.endTime = +Date.now()
     } catch (err) {
+      this.endTime = +Date.now()
       this.setStatus('failed')
       throw err
     }

package/lib/step/meta.js

@@ -6,6 +6,10 @@ class MetaStep extends Step {
   constructor(actor, method) {
     if (!method) method = ''
     super(method)
+
+    /** @member {boolean} collsapsed hide children steps from output */
+    this.collapsed = false
+
     this.actor = actor
   }
 
@@ -32,7 +36,11 @@ class MetaStep extends Step {
       return `${this.prefix}${actorText} ${this.humanize()} ${this.humanizeArgs()}${this.suffix}`
     }
 
-    return `On ${this.prefix}${actorText}: ${this.humanize()} ${this.humanizeArgs()}${this.suffix}`
+    if (!this.actor) {
+      return `${this.name} ${this.humanizeArgs()}${this.suffix}`.trim()
+    }
+
+    return `On ${this.prefix}${actorText}: ${this.humanize()} ${this.humanizeArgs()}${this.suffix}`.trim()
   }
 
   humanize() {

package/lib/step/record.js

@@ -3,7 +3,7 @@ const recorder = require('../recorder')
 const StepConfig = require('./config')
 const { debug } = require('../output')
 const store = require('../store')
-const { TIMEOUT_ORDER } = require('./timeout')
+const { TIMEOUT_ORDER } = require('../timeout')
 const retryStep = require('./retry')
 function recordStep(step, args) {
   step.status = 'queued'
@@ -40,7 +40,7 @@ function recordStep(step, args) {
       if (!step.startTime) {
         // step can be retries
         event.emit(event.step.started, step)
-        step.startTime = Date.now()
+        step.startTime = +Date.now()
       }
       return (val = step.run(...args))
     },
@@ -52,15 +52,15 @@ function recordStep(step, args) {
   event.emit(event.step.after, step)
 
   recorder.add('step passed', () => {
-    step.endTime = Date.now()
+    step.endTime = +Date.now()
     event.emit(event.step.passed, step, val)
     event.emit(event.step.finished, step)
   })
 
   recorder.catchWithoutStop(err => {
     step.status = 'failed'
-    step.endTime = Date.now()
-    event.emit(event.step.failed, step)
+    step.endTime = +Date.now()
+    event.emit(event.step.failed, step, err)
     event.emit(event.step.finished, step)
     throw err
   })

package/lib/step/section.js

@@ -0,0 +1,55 @@
+const MetaStep = require('./meta')
+const event = require('../event')
+
+let currentSection
+
+class Section {
+  constructor(name = '') {
+    this.name = name
+
+    this.metaStep = new MetaStep(null, name)
+
+    this.attachMetaStep = step => {
+      if (currentSection !== this) return
+      if (!step) return
+      const metaStep = getRootMetaStep(step)
+
+      if (metaStep !== this.metaStep) {
+        metaStep.metaStep = this.metaStep
+      }
+    }
+  }
+
+  hidden() {
+    this.metaStep.collapsed = true
+    return this
+  }
+
+  start() {
+    if (currentSection) currentSection.end()
+    currentSection = this
+    event.dispatcher.prependListener(event.step.before, this.attachMetaStep)
+    event.dispatcher.once(event.test.finished, () => this.end())
+    return this
+  }
+
+  end() {
+    currentSection = null
+    event.dispatcher.off(event.step.started, this.attachMetaStep)
+    return this
+  }
+
+  /**
+   * @returns {Section}
+   */
+  static current() {
+    return currentSection
+  }
+}
+
+function getRootMetaStep(step) {
+  if (step.metaStep) return getRootMetaStep(step.metaStep)
+  return step
+}
+
+module.exports = Section

package/lib/step.js

@@ -14,7 +14,13 @@ const Step = require('./step/helper')
  */
 const MetaStep = require('./step/meta')
 
+/**
+ * Step used to execute a single function
+ */
+const FuncStep = require('./step/func')
+
 module.exports = Step
 module.exports.MetaStep = MetaStep
 module.exports.BaseStep = BaseStep
 module.exports.StepConfig = StepConfig
+module.exports.FuncStep = FuncStep

package/lib/steps.js

@@ -1,5 +1,5 @@
 const StepConfig = require('./step/config')
-
+const Section = require('./step/section')
 function stepOpts(opts = {}) {
   return new StepConfig(opts)
 }
@@ -12,12 +12,39 @@ function stepRetry(retry) {
   return new StepConfig().retry(retry)
 }
 
+function section(name) {
+  if (!name) return endSection()
+  return new Section(name).start()
+}
+
+function endSection() {
+  return Section.current().end()
+}
+
 // Section function to be added here
 
 const step = {
+  // steps.opts syntax
   opts: stepOpts,
   timeout: stepTimeout,
   retry: stepRetry,
+
+  // one-function syntax
+  stepTimeout,
+  stepRetry,
+  stepOpts,
+
+  // sections
+  section,
+  endSection,
+
+  Section: section,
+  EndSection: endSection,
+
+  // shortcuts
+  Given: () => section('Given'),
+  When: () => section('When'),
+  Then: () => section('Then'),
 }
 
 module.exports = step

package/lib/store.js

@@ -15,6 +15,8 @@ const store = {
   currentTest: null,
   /** @type {any} */
   currentStep: null,
+  /** @type {CodeceptJS.Suite | null} */
+  currentSuite: null,
 }
 
 module.exports = store