codeceptjs 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/session.js

@@ -1,19 +1,13 @@
-import recorder from './recorder.js';
-import container from './container.js';
-import * as event from './event.js';
-import * as output from './output.js';
-import { store } from './store.js';
-import { isAsyncFunction } from './utils.js';
-
-const sessionColors = [
-  'cyan',
-  'blue',
-  'red',
-  'magenta',
-  'yellow',
-];
-
-const savedSessions = {};
+import recorder from './recorder.js'
+import container from './container.js'
+import event from './event.js'
+import output from './output.js'
+import store from './store.js'
+import { isAsyncFunction } from './utils.js'
+
+const sessionColors = ['cyan', 'blue', 'red', 'magenta', 'yellow']
+
+const savedSessions = {}
 
 /**
  * @param {CodeceptJS.LocatorOrString}  sessionName
@@ -24,109 +18,121 @@ const savedSessions = {};
 function session(sessionName, config, fn) {
   if (typeof config === 'function') {
     if (typeof fn === 'function') {
-      config = config();
+      config = config()
     } else {
       // no config but with function
-      fn = config;
-      config = {};
+      fn = config
+      config = {}
     }
   }
   // session helpers won't use beforeSuite and afterSuite hooks...
   // restart: false options are not allowed as well
   // but those helpers should be already started so inside listener/helpers.js the `_init` method should already be called
 
-  const helpers = container.helpers();
+  const helpers = container.helpers()
 
   if (!savedSessions[sessionName]) {
     for (const helper in helpers) {
-      if (!helpers[helper]._session) continue;
+      if (!helpers[helper]._session) continue
       savedSessions[sessionName] = {
         start: () => null,
         stop: () => null,
         loadVars: () => null,
         restoreVars: () => null,
         ...(store.dryRun ? {} : helpers[helper]._session()),
-      };
-      break;
+      }
+      break
     }
 
     const closeBrowsers = () => {
-      const session = savedSessions[sessionName];
-      if (!session) return;
-      session.stop(session.vars);
-      delete savedSessions[sessionName];
-    };
+      const session = savedSessions[sessionName]
+      if (!session) return
+      session.stop(session.vars)
+      delete savedSessions[sessionName]
+    }
 
     event.dispatcher.once(event.test.after, () => {
-      recorder.add('close session browsers', closeBrowsers);
-    });
+      recorder.add('close session browsers', closeBrowsers)
+    })
 
     if (!savedSessions[sessionName]) {
-      throw new Error('Configured helpers do not support starting sessions. Please use a helper with session support.');
+      throw new Error('Configured helpers do not support starting sessions. Please use a helper with session support.')
     }
 
     recorder.add('save vars', async () => {
-      savedSessions[sessionName].vars = await savedSessions[sessionName].start(sessionName, config);
-    });
+      savedSessions[sessionName].vars = await savedSessions[sessionName].start(sessionName, config)
+    })
   }
 
   // pick random color
-  const color = sessionColors[Object.keys(savedSessions).indexOf(sessionName) % sessionColors.length];
-
-  const addContextToStep = (step) => {
-    step.actor = `${output.colors[color](sessionName)}: I`;
-  };
-
-  if (!fn) return; // no current session steps
-
-  return recorder.add('register session wrapper', async () => {
-    const session = savedSessions[sessionName];
-    recorder.session.start(`session:${sessionName}`);
-    event.dispatcher.on(event.step.after, addContextToStep);
-    recorder.add('switch to browser', () => {
-      const session = savedSessions[sessionName];
-      return session.loadVars(session.vars);
-    });
-
-    const finalize = () => {
-      recorder.add('Finalize session', async () => {
-        output.output.stepShift = 0;
-        event.dispatcher.removeListener(event.step.after, addContextToStep);
-        await session.restoreVars();
-        recorder.session.restore(`session:${sessionName}`);
-      });
-    };
-
-    // Indicate when executing this function that we are in a session
-    if (isAsyncFunction(fn)) {
-      return fn.apply(null).then((res) => {
-        finalize();
-        return recorder.promise().then(() => res);
-      }).catch((e) => {
-        output.output.stepShift = 0;
-        session.restoreVars(sessionName);
-        event.dispatcher.removeListener(event.step.after, addContextToStep);
-        recorder.throw(e);
-        return recorder.promise();
-      });
-    }
+  const color = sessionColors[Object.keys(savedSessions).indexOf(sessionName) % sessionColors.length]
 
-    let res;
-    try {
-      res = fn.apply(null);
-    } catch (err) {
-      recorder.throw(err);
-    } finally {
-      recorder.catch((e) => {
-        session.restoreVars(sessionName);
-        output.output.stepShift = 0;
-        event.dispatcher.removeListener(event.step.after, addContextToStep);
-        throw e;
-      });
-    }
-    finalize();
-    return recorder.promise().then(() => res);
-  }, false, false);
+  const addContextToStep = step => {
+    step.actor = `${output.colors[color](sessionName)}: I`
+  }
+
+  if (!fn) return // no current session steps
+
+  return recorder.add(
+    'register session wrapper',
+    async () => {
+      const session = savedSessions[sessionName]
+      if (!session) {
+        throw new Error(`Session "${sessionName}" not found. It may have been closed already.`)
+      }
+      recorder.session.start(`session:${sessionName}`)
+      event.dispatcher.on(event.step.after, addContextToStep)
+      recorder.add('switch to browser', () => {
+        const session = savedSessions[sessionName]
+        return session.loadVars(session.vars)
+      })
+
+      const finalize = () => {
+        recorder.add('Finalize session', async () => {
+          output.stepShift = 0
+          event.dispatcher.removeListener(event.step.after, addContextToStep)
+          await session.restoreVars()
+          recorder.session.restore(`session:${sessionName}`)
+        })
+      }
+
+      // Indicate when executing this function that we are in a session
+      if (isAsyncFunction(fn)) {
+        return fn
+          .apply(null)
+          .then(async res => {
+            finalize()
+            await recorder.promise()
+            return res
+          })
+          .catch(e => {
+            output.stepShift = 0
+            session.restoreVars(sessionName)
+            event.dispatcher.removeListener(event.step.after, addContextToStep)
+            recorder.throw(e)
+            return recorder.promise()
+          })
+      }
+
+      let res
+      try {
+        res = fn.apply(null)
+      } catch (err) {
+        recorder.throw(err)
+      } finally {
+        recorder.catch(e => {
+          session.restoreVars(sessionName)
+          output.stepShift = 0
+          event.dispatcher.removeListener(event.step.after, addContextToStep)
+          throw e
+        })
+      }
+      finalize()
+      return recorder.promise().then(() => res)
+    },
+    false,
+    false,
+  )
 }
 
-export default session;
+export default session

package/lib/step/base.js

@@ -0,0 +1,239 @@
+import color from 'chalk'
+import Secret from '../secret.js'
+import { getCurrentTimeout } from '../timeout.js'
+import { ucfirst, humanizeString, serializeError } from '../utils.js'
+import recordStep from './record.js'
+
+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|But)/)) {
+        hasBDD = true
+        break
+      } else {
+        processingStep = processingStep.metaStep
+      }
+    }
+    return hasBDD
+  }
+}
+
+export default Step

package/lib/step/comment.js

@@ -0,0 +1,10 @@
+import FuncStep from './func.js'
+
+class CommentStep extends FuncStep {
+  constructor(name, comment) {
+    super(name)
+    this.fn = () => {}
+  }
+}
+
+export default 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
+  }
+}
+
+export default StepConfig

package/lib/step/func.js

@@ -0,0 +1,46 @@
+import BaseStep from './base.js'
+import store from '../store.js'
+
+/**
+ * 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
+  }
+}
+
+export default FuncStep

package/lib/step/helper.js

@@ -0,0 +1,50 @@
+import Step from './base.js'
+import store from '../store.js'
+
+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
+  }
+}
+
+export default HelperStep
+
+function dryRunResolver() {
+  return {
+    get(target, prop) {
+      if (prop === 'toString') return () => '<VALUE>'
+      return new Proxy({}, dryRunResolver())
+    },
+  }
+}