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

package/lib/step.js

@@ -1,337 +1,23 @@
-// TODO: place MetaStep in other file, disable rule
-
-const store = require('./store');
-const Secret = require('./secret');
-const event = require('./event');
-
-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;
-  }
-
-  /** @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 `${this.prefix}${this.actor} ${this.humanize()} ${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) {
-    super(null, method);
-    this.actor = obj;
-  }
+import BaseStep from './step/base.js'
+import StepConfig from './step/config.js'
+import Step from './step/helper.js'
 
-  /** @return {boolean} */
-  isBDD() {
-    if (this.actor && this.actor.match && this.actor.match(/^(Given|When|Then|And)/)) {
-      return true;
-    }
-    return false;
-  }
-
-  isWithin() {
-    if (this.actor && this.actor.match && this.actor.match(/^(Within)/)) {
-      return true;
-    }
-    return false;
-  }
-
-  toString() {
-    const actorText = this.actor;
-
-    if (this.isBDD() || this.isWithin()) {
-      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 = {};
-
-/** @type {Class<MetaStep>} */
-Step.MetaStep = MetaStep;
-
-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());
+/**
+ * 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.
+ */
+import MetaStep from './step/meta.js'
 
-  _result[0] = _result[0] === 'i' ? capitalizeFLetter(_result[0]) : _result[0];
-  return _result.join(' ').trim();
-}
+/**
+ * Step used to execute a single function
+ */
+import FuncStep from './step/func.js'
 
-function capitalizeFLetter(string) {
-  return (string[0].toUpperCase() + string.slice(1));
-}
+export default Step
+export { MetaStep, BaseStep, StepConfig, FuncStep }

package/lib/steps.js

@@ -0,0 +1,54 @@
+import StepConfig from './step/config.js'
+import SectionClass from './step/section.js'
+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 SectionClass(name).start()
+}
+
+function endSection() {
+  return SectionClass.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'),
+}
+
+export default step
+
+// Named exports for ESM compatibility
+export const Section = step.Section
+export const EndSection = step.EndSection

package/lib/store.js

@@ -3,12 +3,44 @@
  * @namespace
  */
 const store = {
-  /** @type {boolean} */
+  /**
+   * If we are in --debug mode
+   * @type {boolean}
+   */
   debugMode: false,
-  /** @type {boolean} */
+
+  /**
+   * Is timeouts enabled
+   * @type {boolean}
+   */
   timeouts: true,
-  /** @type {boolean} */
+
+  /**
+   * If auto-retries are enabled by retryFailedStep plugin
+   * tryTo effect disables them
+   * @type {boolean}
+   */
+  autoRetries: false,
+
+  /**
+   * Tests are executed via dry-run
+   * @type {boolean}
+   */
   dryRun: false,
-};
+  /**
+   * If we are in pause mode
+   * @type {boolean}
+   */
+  onPause: false,
+
+  // current object states
+
+  /** @type {CodeceptJS.Test | null} */
+  currentTest: null,
+  /** @type {CodeceptJS.Step | null} */
+  currentStep: null,
+  /** @type {CodeceptJS.Suite | null} */
+  currentSuite: null,
+}
 
-module.exports = store;
+export default 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)
   },
 })

package/lib/timeout.js

@@ -0,0 +1,60 @@
+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'
+  }
+}
+
+export { TIMEOUT_ORDER, getCurrentTimeout, TimeoutError, TestTimeoutError, StepTimeoutError }

package/lib/transform.js

@@ -1,26 +1,26 @@
 const transformers = {
   'gherkin.examples': [],
-};
+}
 
 function transform(target, value) {
   if (target in transformers) {
     for (const transform of transformers[target]) {
-      value = transform(value);
+      value = transform(value)
     }
   }
-  return value;
+  return value
 }
 
 transform.addTransformer = function (target, transformer) {
   if (target in transformers) {
-    transformers[target].push(transformer);
+    transformers[target].push(transformer)
   }
-};
+}
 
 transform.addTransformerBeforeAll = function (target, transformer) {
   if (target in transformers) {
-    transformers[target].unshift(transformer);
+    transformers[target].unshift(transformer)
   }
-};
+}
 
-module.exports = transform;
+export default transform

package/lib/translation.js

@@ -1,55 +1,69 @@
-const merge = require('lodash.merge');
-const path = require('path');
+import merge from 'lodash.merge'
+import path from 'path'
+import { createRequire } from 'module'
 
 const defaultVocabulary = {
   I: 'I',
   actions: {},
-};
+}
 
 class Translation {
   constructor(vocabulary, loaded) {
-    this.vocabulary = vocabulary;
-    this.loaded = loaded !== false;
+    this.vocabulary = vocabulary
+    this.loaded = loaded !== false
   }
 
   loadVocabulary(vocabularyFile) {
-    if (!vocabularyFile) return;
-    const filePath = path.join(global.codecept_dir, vocabularyFile);
+    if (!vocabularyFile) return
+    const filePath = path.join(global.codecept_dir, vocabularyFile)
 
     try {
-      const vocabulary = require(filePath);
-      this.vocabulary = merge(this.vocabulary, vocabulary);
+      const require = createRequire(import.meta.url)
+      const vocabulary = require(filePath)
+      this.vocabulary = merge(this.vocabulary, vocabulary)
     } catch (err) {
-      throw new Error(`Can't load vocabulary from ${filePath}; ${err}`);
+      throw new Error(`Can't load vocabulary from ${filePath}; ${err}`)
     }
   }
 
   value(val) {
-    return this.vocabulary[val];
+    return this.vocabulary[val]
   }
 
   actionAliasFor(actualActionName) {
     if (this.vocabulary.actions && this.vocabulary.actions[actualActionName]) {
-      return this.vocabulary.actions[actualActionName];
+      return this.vocabulary.actions[actualActionName]
     }
-    return actualActionName;
+    return actualActionName
   }
 
   get I() {
-    return this.vocabulary.I;
+    return this.vocabulary.I
+  }
+
+  static async getLangs() {
+    const translations = await import('../translations/index.js')
+    return translations.default
   }
 
   static get langs() {
-    return require('../translations');
+    // Synchronous fallback - may be empty initially
+    if (!this._cachedLangs) {
+      this.getLangs().then(langs => {
+        this._cachedLangs = langs
+      })
+      return {}
+    }
+    return this._cachedLangs
   }
 
   static createDefault() {
-    return new Translation(defaultVocabulary, true);
+    return new Translation(defaultVocabulary, true)
   }
 
   static createEmpty() {
-    return new Translation(defaultVocabulary, false);
+    return new Translation(defaultVocabulary, false)
   }
 }
 
-module.exports = Translation;
+export default Translation