codeceptjs 4.0.0-beta.3 → 4.0.0-beta.5

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/secret.js

@@ -1,4 +1,3 @@
-/* eslint-disable max-classes-per-file */
 const { deepClone } = require('./utils');
 
 const maskedString = '*****';
@@ -38,7 +37,7 @@ function secretObject(obj, fieldsToHide = []) {
       if (prop === 'toString') {
         return function () {
           const maskedObject = deepClone(obj);
-          fieldsToHide.forEach(f => maskedObject[f] = maskedString);
+          fieldsToHide.forEach(f => (maskedObject[f] = maskedString));
           return JSON.stringify(maskedObject);
         };
       }

package/lib/step/base.js

@@ -0,0 +1,239 @@
+const color = require('chalk')
+const Secret = require('../secret')
+const { getCurrentTimeout } = require('../timeout')
+const { ucfirst, humanizeString, serializeError } = require('../utils')
+const recordStep = require('./record')
+
+const STACK_LINE = 5
+
+/**
+ * Each command in test executed through `I.` object is wrapped in Step.
+ * Step allows logging executed commands and triggers hook before and after step execution.
+ * @param {string} name
+ */
+class Step {
+  constructor(name) {
+    /** @member {string} */
+    this.name = name
+    /** @member {Map<number, number>} */
+    this.timeouts = new Map()
+
+    /** @member {Array<*>} */
+    this.args = []
+
+    /** @member {Record<string,any>} */
+    this.opts = {}
+    /** @member {string} */
+    this.actor = 'I' // I = actor
+
+    /** @member {string} */
+    this.status = 'pending'
+    /** @member {string} */
+    this.prefix = this.suffix = ''
+    /** @member {string} */
+    this.comment = ''
+    /** @member {any} */
+    this.metaStep = undefined
+    /** @member {string} */
+    this.stack = ''
+
+    // These are part of HelperStep class
+    // but left here for types compatibility
+    /** @member {any} */
+    this.helper = null
+    /** @member {string} */
+    this.helperMethod = name
+
+    this.startTime = 0
+    this.endTime = 0
+
+    this.setTrace()
+  }
+
+  setMetaStep(metaStep) {
+    this.metaStep = metaStep
+  }
+
+  run() {
+    throw new Error('Not implemented')
+  }
+
+  addToRecorder(args) {
+    return recordStep(this, args)
+  }
+
+  /**
+   * @returns {number|undefined}
+   */
+  get timeout() {
+    return getCurrentTimeout(this.timeouts)
+  }
+
+  /**
+   * @param {number} timeout - timeout in milliseconds or 0 if no timeout
+   * @param {number} order - order defines the priority of timeout, timeouts set with lower order override those set with higher order.
+   *                         When order below 0 value of timeout only override if new value is lower
+   */
+  setTimeout(timeout, order) {
+    this.timeouts.set(order, timeout)
+  }
+
+  /** @function */
+  setTrace() {
+    Error.captureStackTrace(this)
+  }
+
+  /** @param {Array<*>} args */
+  setArguments(args) {
+    this.args = args
+  }
+
+  setActor(actor) {
+    this.actor = actor || ''
+  }
+
+  /** @param {string} status */
+  setStatus(status) {
+    this.status = status
+    if (this.metaStep) {
+      this.metaStep.setStatus(status)
+    }
+  }
+
+  /** @return {string} */
+  humanize() {
+    return humanizeString(this.name)
+  }
+
+  /** @return {string} */
+  humanizeArgs() {
+    return this.args
+      .map(arg => {
+        if (!arg) {
+          return ''
+        }
+        if (typeof arg === 'string') {
+          return `"${arg}"`
+        }
+        if (Array.isArray(arg)) {
+          try {
+            const res = JSON.stringify(arg)
+            return res
+          } catch (err) {
+            return `[${arg.toString()}]`
+          }
+        } else if (typeof arg === 'function') {
+          return arg.toString()
+        } else if (typeof arg === 'undefined') {
+          return `${arg}`
+        } else if (arg instanceof Secret) {
+          return arg.getMasked()
+        } else if (arg.toString && arg.toString() !== '[object Object]') {
+          return arg.toString()
+        } else if (typeof arg === 'object') {
+          const returnedArg = {}
+          for (const [key, value] of Object.entries(arg)) {
+            returnedArg[key] = value
+            if (value instanceof Secret) returnedArg[key] = value.getMasked()
+          }
+          return JSON.stringify(returnedArg)
+        }
+        return arg
+      })
+      .join(', ')
+  }
+
+  /** @return {string} */
+  line() {
+    const lines = this.stack.split('\n')
+    if (lines[STACK_LINE]) {
+      return lines[STACK_LINE].trim()
+        .replace(global.codecept_dir || '', '.')
+        .trim()
+    }
+    return ''
+  }
+
+  /** @return {string} */
+  toString() {
+    return ucfirst(`${this.prefix}${this.actor} ${this.humanize()} ${this.humanizeArgs()}${this.suffix}`).trim()
+  }
+
+  /** @return {string} */
+  toCliStyled() {
+    return `${this.prefix}${this.actor} ${color.italic(this.humanize())} ${color.yellow(this.humanizeArgs())}${this.suffix}`
+  }
+
+  /** @return {string} */
+  toCode() {
+    return `${this.prefix}${this.actor}.${this.name}(${this.humanizeArgs()})${this.suffix}`
+  }
+
+  isMetaStep() {
+    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 if (arg) {
+          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
+    let processingStep
+    processingStep = this
+
+    while (processingStep.metaStep) {
+      if (processingStep.metaStep.actor?.match(/^(Given|When|Then|And)/)) {
+        hasBDD = true
+        break
+      } else {
+        processingStep = processingStep.metaStep
+      }
+    }
+    return hasBDD
+  }
+}
+
+module.exports = Step

package/lib/step/comment.js

@@ -0,0 +1,10 @@
+const FuncStep = require('./func')
+
+class CommentStep extends FuncStep {
+  constructor(name, comment) {
+    super(name)
+    this.fn = () => {}
+  }
+}
+
+module.exports = CommentStep

package/lib/step/config.js

@@ -0,0 +1,50 @@
+/**
+ * StepConfig is a configuration object for a step.
+ * It is used to create a new step that is a combination of other steps.
+ */
+class StepConfig {
+  constructor(opts = {}) {
+    /** @member {{ opts: Record<string, any>, timeout: number|undefined, retry: number|undefined }} */
+    this.config = {
+      opts,
+      timeout: undefined,
+      retry: undefined,
+    }
+  }
+
+  /**
+   * Set the options for the step.
+   * @param {object} opts - The options for the step.
+   * @returns {StepConfig} - The step configuration object.
+   */
+  opts(opts) {
+    this.config.opts = opts
+    return this
+  }
+
+  /**
+   * Set the timeout for the step.
+   * @param {number} timeout - The timeout for the step.
+   * @returns {StepConfig} - The step configuration object.
+   */
+  timeout(timeout) {
+    this.config.timeout = timeout
+    return this
+  }
+
+  /**
+   * Set the retry for the step.
+   * @param {number} retry - The retry for the step.
+   * @returns {StepConfig} - The step configuration object.
+   */
+  retry(retry) {
+    this.config.retry = retry
+    return this
+  }
+
+  getConfig() {
+    return this.config
+  }
+}
+
+module.exports = StepConfig

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

@@ -0,0 +1,50 @@
+const Step = require('./base')
+const store = require('../store')
+
+class HelperStep extends Step {
+  constructor(helper, name) {
+    super(name)
+    /** @member {CodeceptJS.Helper} helper corresponding helper */
+    this.helper = helper
+    /** @member {string} helperMethod name of method to be executed */
+    this.helperMethod = name
+  }
+
+  /**
+   * @param {...any} args
+   * @return {*}
+   */
+  run() {
+    this.args = Array.prototype.slice.call(arguments)
+    this.startTime = +Date.now()
+
+    if (store.dryRun) {
+      this.setStatus('success')
+      return Promise.resolve(new Proxy({}, dryRunResolver()))
+    }
+    let result
+    try {
+      if (this.helperMethod !== 'say') {
+        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
+    }
+    return result
+  }
+}
+
+module.exports = HelperStep
+
+function dryRunResolver() {
+  return {
+    get(target, prop) {
+      if (prop === 'toString') return () => '<VALUE>'
+      return new Proxy({}, dryRunResolver())
+    },
+  }
+}

package/lib/step/meta.js

@@ -0,0 +1,99 @@
+const Step = require('./base')
+const event = require('../event')
+const { humanizeString } = require('../utils')
+
+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
+  }
+
+  /** @return {boolean} */
+  isBDD() {
+    if (this.actor && this.actor.match && this.actor.match(/^(Given|When|Then|And)/)) {
+      return true
+    }
+    return false
+  }
+
+  toCliStyled() {
+    return this.toString()
+  }
+
+  toString() {
+    const actorText = this.actor
+
+    if (this.isBDD()) {
+      return `${this.prefix}${actorText} ${this.name} "${this.humanizeArgs()}${this.suffix}"`
+    }
+
+    if (actorText === 'I') {
+      return `${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() {
+    return humanizeString(this.name)
+  }
+
+  setTrace() {}
+
+  setContext(context) {
+    this.context = context
+  }
+
+  /** @return {*} */
+  run(fn) {
+    this.status = 'queued'
+    this.setArguments(Array.from(arguments).slice(1))
+    let result
+
+    const registerStep = step => {
+      this.setMetaStep(null)
+      step.setMetaStep(this)
+    }
+    event.dispatcher.prependListener(event.step.before, registerStep)
+    // Handle async and sync methods.
+    if (fn.constructor.name === 'AsyncFunction') {
+      result = fn
+        .apply(this.context, this.args)
+        .then(result => {
+          return result
+        })
+        .catch(error => {
+          this.setStatus('failed')
+          throw error
+        })
+        .finally(() => {
+          this.endTime = Date.now()
+          event.dispatcher.removeListener(event.step.before, registerStep)
+        })
+    } else {
+      try {
+        this.startTime = Date.now()
+        result = fn.apply(this.context, this.args)
+      } catch (error) {
+        this.setStatus('failed')
+        throw error
+      } finally {
+        this.endTime = Date.now()
+        event.dispatcher.removeListener(event.step.before, registerStep)
+      }
+    }
+
+    return result
+  }
+}
+
+module.exports = MetaStep