codeceptjs 3.7.0-beta.1 → 3.7.0-beta.10

package/lib/step/retry.js

@@ -0,0 +1,11 @@
+const recorder = require('../recorder')
+const event = require('../event')
+
+function retryStep(opts) {
+  if (opts === undefined) opts = 1
+  recorder.retry(opts)
+  // remove retry once the step passed
+  recorder.add(() => event.dispatcher.once(event.step.finished, () => recorder.retries.pop()))
+}
+
+module.exports = retryStep

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

@@ -1,353 +1,26 @@
-// TODO: place MetaStep in other file, disable rule
-
-const color = require('chalk')
-const store = require('./store')
-const Secret = require('./secret')
-const event = require('./event')
-const { ucfirst } = require('./utils')
-
-const STACK_LINE = 4
-
+// refactored step class, moved to helper
 /**
- * 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 {CodeceptJS.Helper} helper
- * @param {string} name
+ * Step is wrapper around a helper method.
+ * It is used to create a new step that is a combination of other steps.
  */
-class Step {
-  static get TIMEOUT_ORDER() {
-    return {
-      /**
-       * timeouts set with order below zero only override timeouts of higher order if their value is smaller
-       */
-      testOrSuite: -5,
-      /**
-       * 0-9 - designated for override of timeouts set from code, 5 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=true
-       */
-      stepTimeoutHard: 5,
-      /**
-       * 10-19 - designated for timeouts set from code, 15 is order of I.setTimeout(t) operation
-       */
-      codeLimitTime: 15,
-      /**
-       * 20-29 - designated for timeout settings which could be overriden in tests code, 25 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=false
-       */
-      stepTimeoutSoft: 25,
-    }
-  }
-
-  constructor(helper, name) {
-    /** @member {string} */
-    this.actor = 'I' // I = actor
-    /** @member {CodeceptJS.Helper} */
-    this.helper = helper // corresponding helper
-    /** @member {string} */
-    this.name = name // name of a step console
-    /** @member {string} */
-    this.helperMethod = name // helper method
-    /** @member {string} */
-    this.status = 'pending'
-    /**
-     * @member {string} suffix
-     * @memberof CodeceptJS.Step#
-     */
-    /** @member {string} */
-    this.prefix = this.suffix = ''
-    /** @member {string} */
-    this.comment = ''
-    /** @member {Array<*>} */
-    this.args = []
-    /** @member {MetaStep} */
-    this.metaStep = undefined
-    /** @member {string} */
-    this.stack = ''
-
-    const timeouts = new Map()
-    /**
-     * @method
-     * @returns {number|undefined}
-     */
-    this.getTimeout = function () {
-      let totalTimeout
-      // iterate over all timeouts starting from highest values of order
-      new Map([...timeouts.entries()].sort().reverse()).forEach((timeout, order) => {
-        if (
-          timeout !== undefined &&
-          // when orders >= 0 - timeout value overrides those set with higher order elements
-          (order >= 0 ||
-            // when `order < 0 && totalTimeout === undefined` - timeout is used when nothing is set by elements with higher order
-            totalTimeout === undefined ||
-            // when `order < 0` - timeout overrides higher values of timeout or 'no timeout' (totalTimeout === 0) set by elements with higher order
-            (timeout > 0 && (timeout < totalTimeout || totalTimeout === 0)))
-        ) {
-          totalTimeout = timeout
-        }
-      })
-      return totalTimeout
-    }
-    /**
-     * @method
-     * @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
-     */
-    this.setTimeout = function (timeout, order) {
-      timeouts.set(order, timeout)
-    }
-
-    this.setTrace()
-  }
-
-  /** @function */
-  setTrace() {
-    Error.captureStackTrace(this)
-  }
-
-  /** @param {Array<*>} args */
-  setArguments(args) {
-    this.args = args
-  }
-
-  /**
-   * @param {...any} args
-   * @return {*}
-   */
-  run() {
-    this.args = Array.prototype.slice.call(arguments)
-    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')
-    } catch (err) {
-      this.setStatus('failed')
-      throw err
-    }
-    return result
-  }
-
-  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'
-  }
-
-  /** @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
-  }
-}
-
-/** @extends Step */
-class MetaStep extends Step {
-  constructor(obj, method) {
-    if (!method) method = ''
-    super(null, method)
-    this.actor = obj
-  }
+const BaseStep = require('./step/base')
+const StepConfig = require('./step/config')
+const Step = require('./step/helper')
 
-  /** @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}`
-    }
-
-    return `On ${this.prefix}${actorText}: ${this.humanize()} ${this.humanizeArgs()}${this.suffix}`
-  }
-
-  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.metaStep = null
-      step.metaStep = 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
-  }
-}
-
-Step.TIMEOUTS = {}
+/**
+ * MetaStep is a step that is used to wrap other steps.
+ * It is used to create a new step that is a combination of other steps.
+ * It is used to create a new step that is a combination of other steps.
+ */
+const MetaStep = require('./step/meta')
 
-/** @type {Class<MetaStep>} */
-Step.MetaStep = MetaStep
+/**
+ * Step used to execute a single function
+ */
+const FuncStep = require('./step/func')
 
 module.exports = Step
-
-function dryRunResolver() {
-  return {
-    get(target, prop) {
-      if (prop === 'toString') return () => '<VALUE>'
-      return new Proxy({}, dryRunResolver())
-    },
-  }
-}
-
-function humanizeString(string) {
-  // split strings by words, then make them all lowercase
-  const _result = string
-    .replace(/([a-z](?=[A-Z]))/g, '$1 ')
-    .split(' ')
-    .map(word => word.toLowerCase())
-
-  _result[0] = _result[0] === 'i' ? capitalizeFLetter(_result[0]) : _result[0]
-  return _result.join(' ').trim()
-}
-
-function capitalizeFLetter(string) {
-  return string[0].toUpperCase() + string.slice(1)
-}
+module.exports.MetaStep = MetaStep
+module.exports.BaseStep = BaseStep
+module.exports.StepConfig = StepConfig
+module.exports.FuncStep = FuncStep

package/lib/steps.js

@@ -0,0 +1,50 @@
+const StepConfig = require('./step/config')
+const Section = require('./step/section')
+function stepOpts(opts = {}) {
+  return new StepConfig(opts)
+}
+
+function stepTimeout(timeout) {
+  return new StepConfig().timeout(timeout)
+}
+
+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

@@ -13,6 +13,10 @@ const store = {
   onPause: false,
   /** @type {CodeceptJS.Test | null} */
   currentTest: null,
+  /** @type {any} */
+  currentStep: null,
+  /** @type {CodeceptJS.Suite | null} */
+  currentSuite: null,
 }
 
 module.exports = store

package/lib/timeout.js

@@ -0,0 +1,66 @@
+const TIMEOUT_ORDER = {
+  /**
+   * timeouts set with order below zero only override timeouts of higher order if their value is smaller
+   */
+  testOrSuite: -5,
+  /**
+   * 0-9 - designated for override of timeouts set from code, 5 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=true
+   */
+  stepTimeoutHard: 5,
+  /**
+   * 10-19 - designated for timeouts set from code, 15 is order of I.setTimeout(t) operation
+   */
+  codeLimitTime: 15,
+  /**
+   * 20-29 - designated for timeout settings which could be overriden in tests code, 25 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=false
+   */
+  stepTimeoutSoft: 25,
+}
+
+function getCurrentTimeout(timeouts) {
+  let totalTimeout
+  // iterate over all timeouts starting from highest values of order
+  new Map([...timeouts.entries()].sort().reverse()).forEach((timeout, order) => {
+    if (
+      timeout !== undefined &&
+      // when orders >= 0 - timeout value overrides those set with higher order elements
+      (order >= 0 ||
+        // when `order < 0 && totalTimeout === undefined` - timeout is used when nothing is set by elements with higher order
+        totalTimeout === undefined ||
+        // when `order < 0` - timeout overrides higher values of timeout or 'no timeout' (totalTimeout === 0) set by elements with higher order
+        (timeout > 0 && (timeout < totalTimeout || totalTimeout === 0)))
+    ) {
+      totalTimeout = timeout
+    }
+  })
+  return totalTimeout
+}
+
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'TimeoutError'
+  }
+}
+
+class TestTimeoutError extends TimeoutError {
+  constructor(timeout) {
+    super(`Timeout ${timeout}s exceeded (with Before hook)`)
+    this.name = 'TestTimeoutError'
+  }
+}
+
+class StepTimeoutError extends TimeoutError {
+  constructor(timeout, step) {
+    super(`Step ${step.toCode().trim()} timed out after ${timeout}s`)
+    this.name = 'StepTimeoutError'
+  }
+}
+
+module.exports = {
+  TIMEOUT_ORDER,
+  getCurrentTimeout,
+  TimeoutError,
+  TestTimeoutError,
+  StepTimeoutError,
+}

package/lib/utils.js

@@ -1,9 +1,11 @@
 const fs = require('fs')
 const os = require('os')
 const path = require('path')
+const chalk = require('chalk')
 const getFunctionArguments = require('fn-args')
 const deepClone = require('lodash.clonedeep')
 const { convertColorToRGBA, isColorProperty } = require('./colorUtils')
+const Fuse = require('fuse.js')
 
 function deepMerge(target, source) {
   const merge = require('lodash.merge')
@@ -484,3 +486,94 @@ module.exports.humanizeFunction = function (fn) {
 
   return simplified
 }
+
+/**
+ * Searches through a given data source using the Fuse.js library for fuzzy searching.
+ *
+ * @function searchWithFusejs
+ * @param {Array|Object} source - The data source to search through. This can be an array of objects or strings.
+ * @param {string} searchString - The search query string to match against the source.
+ * @param {Object} [opts] - Optional configuration object for Fuse.js.
+ * @param {boolean} [opts.includeScore=true] - Whether to include the score of the match in the results.
+ * @param {number} [opts.threshold=0.6] - Determines the match threshold; lower values mean stricter matching.
+ * @param {boolean} [opts.caseSensitive=false] - Whether the search should be case-sensitive.
+ * @param {number} [opts.distance=100] - Determines how far apart the search term is allowed to be from the target.
+ * @param {number} [opts.maxPatternLength=32] - The maximum length of the search pattern. Patterns longer than this are ignored.
+ * @param {boolean} [opts.ignoreLocation=false] - Whether the location of the match is ignored when scoring.
+ * @param {boolean} [opts.ignoreFieldNorm=false] - When true, the field's length is not considered when scoring.
+ * @param {Array<string>} [opts.keys=[]] - List of keys to search in the objects of the source array.
+ * @param {boolean} [opts.shouldSort=true] - Whether the results should be sorted by score.
+ * @param {string} [opts.sortFn] - A custom sorting function for sorting results.
+ * @param {number} [opts.minMatchCharLength=1] - The minimum number of characters that must match.
+ * @param {boolean} [opts.useExtendedSearch=false] - Enables extended search capabilities.
+ *
+ * @returns {Array<Object>} - An array of search results. Each result contains an item and, if `includeScore` is true, a score.
+ *
+ * @example
+ * const data = [
+ *   { title: "Old Man's War", author: "John Scalzi" },
+ *   { title: "The Lock Artist", author: "Steve Hamilton" },
+ * ];
+ *
+ * const options = {
+ *   keys: ['title', 'author'],
+ *   includeScore: true,
+ *   threshold: 0.4,
+ *   caseSensitive: false,
+ *   distance: 50,
+ *   ignoreLocation: true,
+ * };
+ *
+ * const results = searchWithFusejs(data, 'lock', options);
+ * console.log(results);
+ */
+module.exports.searchWithFusejs = function (source, searchString, opts) {
+  const fuse = new Fuse(source, opts)
+
+  return fuse.search(searchString)
+}
+
+module.exports.humanizeString = function (string) {
+  // split strings by words, then make them all lowercase
+  const _result = string
+    .replace(/([a-z](?=[A-Z]))/g, '$1 ')
+    .split(' ')
+    .map(word => word.toLowerCase())
+
+  _result[0] = _result[0] === 'i' ? this.ucfirst(_result[0]) : _result[0]
+  return _result.join(' ').trim()
+}
+
+module.exports.serializeError = function (error) {
+  if (error) {
+    const { stack, uncaught, message, actual, expected } = error
+    return { stack, uncaught, message, actual, expected }
+  }
+  return null
+}
+
+module.exports.base64EncodeFile = function (filePath) {
+  return Buffer.from(fs.readFileSync(filePath)).toString('base64')
+}
+
+module.exports.markdownToAnsi = function (markdown) {
+  return (
+    markdown
+      // Headers (# Text) - make blue and bold
+      .replace(/^(#{1,6})\s+(.+)$/gm, (_, hashes, text) => {
+        return chalk.bold.blue(`${hashes} ${text}`)
+      })
+      // Bullet points - replace with yellow bullet character
+      .replace(/^[-*]\s+(.+)$/gm, (_, text) => {
+        return `${chalk.yellow('•')} ${text}`
+      })
+      // Bold (**text**) - make bold
+      .replace(/\*\*(.+?)\*\*/g, (_, text) => {
+        return chalk.bold(text)
+      })
+      // Italic (*text*) - make italic (dim in terminals)
+      .replace(/\*(.+?)\*/g, (_, text) => {
+        return chalk.italic(text)
+      })
+  )
+}

package/lib/within.js

@@ -3,7 +3,7 @@ const store = require('./store')
 const recorder = require('./recorder')
 const container = require('./container')
 const event = require('./event')
-const Step = require('./step')
+const MetaStep = require('./step/meta')
 const { isAsyncFunction } = require('./utils')
 
 /**
@@ -76,7 +76,7 @@ function within(context, fn) {
 
 module.exports = within
 
-class WithinStep extends Step.MetaStep {
+class WithinStep extends MetaStep {
   constructor(locator, fn) {
     super('Within')
     this.args = [locator]