codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

package/lib/result.js

@@ -0,0 +1,161 @@
+import fs from 'fs'
+import path from 'path'
+import { serializeTest } from './mocha/test.js'
+
+/**
+ * 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
+  }
+}
+
+export default Result

package/lib/secret.js

@@ -1,20 +1,20 @@
-const { deepClone } = require('./utils');
+import { deepClone } from './utils.js'
 
-const maskedString = '*****';
+const maskedString = '*****'
 
 /** @param {string} secret */
 class Secret {
   constructor(secret) {
-    this._secret = secret;
+    this._secret = secret
   }
 
   /** @returns {string} */
   toString() {
-    return this._secret;
+    return this._secret
   }
 
   getMasked() {
-    return maskedString;
+    return maskedString
   }
 
   /**
@@ -23,11 +23,11 @@ class Secret {
    */
   static secret(secret) {
     if (typeof secret === 'object') {
-      const fields = Array.from(arguments);
-      fields.shift();
-      return secretObject(secret, fields);
+      const fields = Array.from(arguments)
+      fields.shift()
+      return secretObject(secret, fields)
     }
-    return new Secret(secret);
+    return new Secret(secret)
   }
 }
 
@@ -36,16 +36,17 @@ function secretObject(obj, fieldsToHide = []) {
     get(obj, prop) {
       if (prop === 'toString') {
         return function () {
-          const maskedObject = deepClone(obj);
-          fieldsToHide.forEach(f => maskedObject[f] = maskedString);
-          return JSON.stringify(maskedObject);
-        };
+          const maskedObject = deepClone(obj)
+          fieldsToHide.forEach(f => (maskedObject[f] = maskedString))
+          return JSON.stringify(maskedObject)
+        }
       }
-      return fieldsToHide.includes(prop) ? new Secret(obj[prop]) : obj[prop];
+      return fieldsToHide.includes(prop) ? new Secret(obj[prop]) : obj[prop]
     },
-  };
+  }
 
-  return new Proxy(obj, handler);
+  return new Proxy(obj, handler)
 }
 
-module.exports = Secret;
+export default Secret
+export const secret = Secret.secret

package/lib/session.js

@@ -1,19 +1,13 @@
-const recorder = require('./recorder');
-const container = require('./container');
-const event = require('./event');
-const output = require('./output');
-const store = require('./store');
-const { isAsyncFunction } = require('./utils');
-
-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.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.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.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,
+  )
 }
 
-module.exports = 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)/)) {
+        hasBDD = true
+        break
+      } else {
+        processingStep = processingStep.metaStep
+      }
+    }
+    return hasBDD
+  }
+}
+
+export default 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