codeceptjs 3.6.10 → 3.7.0-beta.1

package/lib/step.js

@@ -1,10 +1,12 @@
 // TODO: place MetaStep in other file, disable rule
 
-const store = require('./store');
-const Secret = require('./secret');
-const event = require('./event');
+const color = require('chalk')
+const store = require('./store')
+const Secret = require('./secret')
+const event = require('./event')
+const { ucfirst } = require('./utils')
 
-const STACK_LINE = 4;
+const STACK_LINE = 4
 
 /**
  * Each command in test executed through `I.` object is wrapped in Step.
@@ -31,59 +33,58 @@ class Step {
        * 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
+    this.actor = 'I' // I = actor
     /** @member {CodeceptJS.Helper} */
-    this.helper = helper; // corresponding helper
+    this.helper = helper // corresponding helper
     /** @member {string} */
-    this.name = name; // name of a step console
+    this.name = name // name of a step console
     /** @member {string} */
-    this.helperMethod = name; // helper method
+    this.helperMethod = name // helper method
     /** @member {string} */
-    this.status = 'pending';
+    this.status = 'pending'
     /**
      * @member {string} suffix
      * @memberof CodeceptJS.Step#
      */
     /** @member {string} */
-    this.prefix = this.suffix = '';
+    this.prefix = this.suffix = ''
     /** @member {string} */
-    this.comment = '';
+    this.comment = ''
     /** @member {Array<*>} */
-    this.args = [];
+    this.args = []
     /** @member {MetaStep} */
-    this.metaStep = undefined;
+    this.metaStep = undefined
     /** @member {string} */
-    this.stack = '';
+    this.stack = ''
 
-    const timeouts = new Map();
+    const timeouts = new Map()
     /**
      * @method
      * @returns {number|undefined}
      */
     this.getTimeout = function () {
-      let totalTimeout;
+      let totalTimeout
       // iterate over all timeouts starting from highest values of order
       new Map([...timeouts.entries()].sort().reverse()).forEach((timeout, order) => {
-        if (timeout !== undefined && (
+        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;
+          (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;
-    };
+      })
+      return totalTimeout
+    }
     /**
      * @method
      * @param {number} timeout - timeout in milliseconds or 0 if no timeout
@@ -91,20 +92,20 @@ class Step {
      *                         When order below 0 value of timeout only override if new value is lower
      */
     this.setTimeout = function (timeout, order) {
-      timeouts.set(order, timeout);
-    };
+      timeouts.set(order, timeout)
+    }
 
-    this.setTrace();
+    this.setTrace()
   }
 
   /** @function */
   setTrace() {
-    Error.captureStackTrace(this);
+    Error.captureStackTrace(this)
   }
 
   /** @param {Array<*>} args */
   setArguments(args) {
-    this.args = args;
+    this.args = args
   }
 
   /**
@@ -112,226 +113,241 @@ class Step {
    * @return {*}
    */
   run() {
-    this.args = Array.prototype.slice.call(arguments);
+    this.args = Array.prototype.slice.call(arguments)
     if (store.dryRun) {
-      this.setStatus('success');
-      return Promise.resolve(new Proxy({}, dryRunResolver()));
+      this.setStatus('success')
+      return Promise.resolve(new Proxy({}, dryRunResolver()))
     }
-    let result;
+    let result
     try {
       if (this.helperMethod !== 'say') {
-        result = this.helper[this.helperMethod].apply(this.helper, this.args);
+        result = this.helper[this.helperMethod].apply(this.helper, this.args)
       }
-      this.setStatus('success');
+      this.setStatus('success')
     } catch (err) {
-      this.setStatus('failed');
-      throw err;
+      this.setStatus('failed')
+      throw err
     }
-    return result;
+    return result
+  }
+
+  setActor(actor) {
+    this.actor = actor || ''
   }
 
   /** @param {string} status */
   setStatus(status) {
-    this.status = status;
+    this.status = status
     if (this.metaStep) {
-      this.metaStep.setStatus(status);
+      this.metaStep.setStatus(status)
     }
   }
 
   /** @return {string} */
   humanize() {
-    return humanizeString(this.name);
+    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()}]`;
+    return this.args
+      .map(arg => {
+        if (!arg) {
+          return ''
         }
-      } 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();
+        if (typeof arg === 'string') {
+          return `"${arg}"`
         }
-        return JSON.stringify(returnedArg);
-      }
-      return arg;
-    }).join(', ');
+        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');
+    const lines = this.stack.split('\n')
     if (lines[STACK_LINE]) {
-      return lines[STACK_LINE].trim().replace(global.codecept_dir || '', '.').trim();
+      return lines[STACK_LINE].trim()
+        .replace(global.codecept_dir || '', '.')
+        .trim()
     }
-    return '';
+    return ''
   }
 
   /** @return {string} */
   toString() {
-    return `${this.prefix}${this.actor} ${this.humanize()} ${this.humanizeArgs()}${this.suffix}`;
+    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}`;
+    return `${this.prefix}${this.actor}.${this.name}(${this.humanizeArgs()})${this.suffix}`
   }
 
   isMetaStep() {
-    return this.constructor.name === 'MetaStep';
+    return this.constructor.name === 'MetaStep'
   }
 
   /** @return {boolean} */
   hasBDDAncestor() {
-    let hasBDD = false;
-    let processingStep;
-    processingStep = this;
+    let hasBDD = false
+    let processingStep
+    processingStep = this
 
     while (processingStep.metaStep) {
       if (processingStep.metaStep.actor.match(/^(Given|When|Then|And)/)) {
-        hasBDD = true;
-        break;
+        hasBDD = true
+        break
       } else {
-        processingStep = processingStep.metaStep;
+        processingStep = processingStep.metaStep
       }
     }
-    return hasBDD;
+    return hasBDD
   }
 }
 
 /** @extends Step */
 class MetaStep extends Step {
   constructor(obj, method) {
-    super(null, method);
-    this.actor = obj;
+    if (!method) method = ''
+    super(null, method)
+    this.actor = obj
   }
 
   /** @return {boolean} */
   isBDD() {
     if (this.actor && this.actor.match && this.actor.match(/^(Given|When|Then|And)/)) {
-      return true;
+      return true
     }
-    return false;
+    return false
   }
 
-  isWithin() {
-    if (this.actor && this.actor.match && this.actor.match(/^(Within)/)) {
-      return true;
-    }
-    return false;
+  toCliStyled() {
+    return this.toString()
   }
 
   toString() {
-    const actorText = this.actor;
+    const actorText = this.actor
 
-    if (this.isBDD() || this.isWithin()) {
-      return `${this.prefix}${actorText} ${this.name} "${this.humanizeArgs()}${this.suffix}"`;
+    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 `${this.prefix}${actorText} ${this.humanize()} ${this.humanizeArgs()}${this.suffix}`
     }
 
-    return `On ${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);
+    return humanizeString(this.name)
   }
 
-  setTrace() {
-  }
+  setTrace() {}
 
   setContext(context) {
-    this.context = 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);
+    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);
-      });
+      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);
+        this.startTime = Date.now()
+        result = fn.apply(this.context, this.args)
       } catch (error) {
-        this.setStatus('failed');
-        throw error;
+        this.setStatus('failed')
+        throw error
       } finally {
-        this.endTime = Date.now();
-        event.dispatcher.removeListener(event.step.before, registerStep);
+        this.endTime = Date.now()
+        event.dispatcher.removeListener(event.step.before, registerStep)
       }
     }
 
-    return result;
+    return result
   }
 }
 
-Step.TIMEOUTS = {};
+Step.TIMEOUTS = {}
 
 /** @type {Class<MetaStep>} */
-Step.MetaStep = MetaStep;
+Step.MetaStep = MetaStep
 
-module.exports = Step;
+module.exports = Step
 
 function dryRunResolver() {
   return {
     get(target, prop) {
-      if (prop === 'toString') return () => '<VALUE>';
-      return new Proxy({}, dryRunResolver());
+      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 ')
+  const _result = string
+    .replace(/([a-z](?=[A-Z]))/g, '$1 ')
     .split(' ')
-    .map(word => word.toLowerCase());
+    .map(word => word.toLowerCase())
 
-  _result[0] = _result[0] === 'i' ? capitalizeFLetter(_result[0]) : _result[0];
-  return _result.join(' ').trim();
+  _result[0] = _result[0] === 'i' ? capitalizeFLetter(_result[0]) : _result[0]
+  return _result.join(' ').trim()
 }
 
 function capitalizeFLetter(string) {
-  return (string[0].toUpperCase() + string.slice(1));
+  return string[0].toUpperCase() + string.slice(1)
 }

package/lib/store.js

@@ -9,6 +9,10 @@ const store = {
   timeouts: true,
   /** @type {boolean} */
   dryRun: false,
-};
+  /** @type {boolean} */
+  onPause: false,
+  /** @type {CodeceptJS.Test | null} */
+  currentTest: null,
+}
 
-module.exports = store;
+module.exports = store

package/lib/template/heal.js

@@ -6,17 +6,8 @@ heal.addRecipe('ai', {
     html: ({ I }) => I.grabHTMLFrom('body'),
   },
   suggest: true,
-  steps: [
-    'click',
-    'fillField',
-    'appendField',
-    'selectOption',
-    'attachFile',
-    'checkOption',
-    'uncheckOption',
-    'doubleClick',
-  ],
-  fn: async (args) => {
+  steps: ['click', 'fillField', 'appendField', 'selectOption', 'attachFile', 'checkOption', 'uncheckOption', 'doubleClick'],
+  fn: async args => {
     return ai.healFailedStep(args)
   },
 })