codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/container.js

@@ -1,23 +1,26 @@
-const glob = require('glob');
-const path = require('path');
-const { MetaStep } = require('./step');
-const { fileExists, isFunction, isAsyncFunction } = require('./utils');
-const Translation = require('./translation');
-const MochaFactory = require('./mochaFactory');
-const recorder = require('./recorder');
-const event = require('./event');
-const WorkerStorage = require('./workerStorage');
-const store = require('./store');
-const ai = require('./ai');
+import glob from 'glob';
+import path, { dirname } from 'path';
+import importSync from 'import-sync';
+import { fileURLToPath } from 'url';
+import { MetaStep } from './step.js';
+import {
+  fileExists, isFunction, isAsyncFunction, deepMerge,
+} from './utils.js';
+import Translation from './translation.js';
+import { MochaFactory } from './mochaFactory.js';
+// eslint-disable-next-line import/no-named-as-default
+import recorder from './recorder.js';
+import * as event from './event.js';
+import * as WorkerStorage from './workerStorage.js';
+import { store } from './store.js';
+import { actor } from './actor.js';
+
+import ai from './ai.js';
 
 let container = {
   helpers: {},
   support: {},
   plugins: {},
-  /**
-   * @type {Mocha | {}}
-   * @ignore
-   */
   mocha: {},
   translation: {},
 };
@@ -25,7 +28,7 @@ let container = {
 /**
  * Dependency Injection Container
  */
-class Container {
+export default class Container {
   /**
    * Create container with all required helpers and support objects
    *
@@ -59,10 +62,7 @@ class Container {
    * @returns { * }
    */
   static plugins(name) {
-    if (!name) {
-      return container.plugins;
-    }
-    return container.plugins[name];
+    return name ? container.plugins[name] : container.plugins;
   }
 
   /**
@@ -119,7 +119,6 @@ class Container {
    * @param {Object<string, *>} newContainer
    */
   static append(newContainer) {
-    const deepMerge = require('./utils').deepMerge;
     container = deepMerge(container, newContainer);
   }
 
@@ -151,8 +150,6 @@ class Container {
   }
 }
 
-module.exports = Container;
-
 function createHelpers(config) {
   const helpers = {};
   let moduleName;
@@ -160,29 +157,31 @@ function createHelpers(config) {
     try {
       if (config[helperName].require) {
         if (config[helperName].require.startsWith('.')) {
+          // @ts-ignore
           moduleName = path.resolve(global.codecept_dir, config[helperName].require); // custom helper
         } else {
           moduleName = config[helperName].require; // plugin helper
         }
       } else {
-        moduleName = `./helper/${helperName}`; // built-in helper
+        moduleName = `./helper/${helperName}.js`; // built-in helper
       }
 
       // @ts-ignore
       let HelperClass;
       // check if the helper is the built-in, use the require() syntax.
       if (moduleName.startsWith('./helper/')) {
-        HelperClass = require(moduleName);
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        HelperClass = importSync(path.resolve(__dirname, moduleName)).default;
       } else {
         // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
-        HelperClass = require(moduleName).default || require(moduleName);
+        HelperClass = importSync(path.resolve(moduleName)).default;
       }
 
-      if (HelperClass._checkRequirements) {
+      if (HelperClass && HelperClass._checkRequirements) {
         const requirements = HelperClass._checkRequirements();
         if (requirements) {
           let install;
-          if (require('./utils').installedLocally()) {
+          if (importSync('./utils.js').installedLocally()) {
             install = `npm install --save-dev ${requirements.join(' ')}`;
           } else {
             console.log('WARNING: CodeceptJS is not installed locally. It is recommended to switch to local installation');
@@ -203,7 +202,7 @@ function createHelpers(config) {
   return helpers;
 }
 
-function createSupportObjects(config) {
+export function createSupportObjects(config) {
   const objects = {};
 
   for (const name in config) {
@@ -211,7 +210,7 @@ function createSupportObjects(config) {
   }
 
   if (!config.I) {
-    objects.I = require('./actor')();
+    objects.I = actor();
 
     if (container.translation.I !== 'I') {
       objects[container.translation.I] = objects.I;
@@ -295,12 +294,13 @@ function createPlugins(config, options = {}) {
       if (config[pluginName].require) {
         module = config[pluginName].require;
         if (module.startsWith('.')) { // local
+          // @ts-ignore
           module = path.resolve(global.codecept_dir, module); // custom plugin
         }
       } else {
-        module = `./plugin/${pluginName}`;
+        module = `./plugin/${pluginName}.js`;
       }
-      plugins[pluginName] = require(module)(config[pluginName]);
+      plugins[pluginName] = importSync(module).default(config[pluginName]);
     } catch (err) {
       throw new Error(`Could not load plugin ${pluginName} from module '${module}':\n${err.message}\n${err.stack}`);
     }
@@ -316,8 +316,10 @@ function getSupportObject(config, name) {
   return module;
 }
 
-function loadGherkinSteps(paths) {
+export function loadGherkinSteps(paths) {
+  // @ts-ignore
   global.Before = fn => event.dispatcher.on(event.test.started, fn);
+  // @ts-ignore
   global.After = fn => event.dispatcher.on(event.test.finished, fn);
   global.Fail = fn => event.dispatcher.on(event.test.failed, fn);
 
@@ -329,6 +331,7 @@ function loadGherkinSteps(paths) {
       loadSupportObject(path, `Step Definition from ${path}`);
     }
   } else {
+    // @ts-ignore
     const folderPath = paths.startsWith('.') ? path.join(global.codecept_dir, paths) : '';
     if (folderPath !== '') {
       glob.sync(folderPath).forEach((file) => {
@@ -337,17 +340,20 @@ function loadGherkinSteps(paths) {
     }
   }
 
+  // @ts-ignore
   delete global.Before;
+  // @ts-ignore
   delete global.After;
   delete global.Fail;
 }
 
 function loadSupportObject(modulePath, supportObjectName) {
   if (modulePath.charAt(0) === '.') {
+    // @ts-ignore
     modulePath = path.join(global.codecept_dir, modulePath);
   }
   try {
-    const obj = require(modulePath);
+    const obj = importSync(modulePath).default || importSync(modulePath);
 
     if (typeof obj === 'function') {
       const fobj = obj();
@@ -405,7 +411,7 @@ function getObjectMethods(obj) {
   const methodsSet = new Set();
   let protoObj = Reflect.getPrototypeOf(obj);
   do {
-    if (protoObj.constructor.prototype !== Object.prototype) {
+    if (protoObj?.constructor.prototype !== Object.prototype) {
       const keys = Reflect.ownKeys(protoObj);
       keys.forEach(k => methodsSet.add(k));
     }
@@ -424,16 +430,18 @@ function loadTranslation(locale, vocabularies) {
   }
 
   let translation;
+  locale = locale.replace('-', '_');
 
   // check if it is a known translation
   if (Translation.langs[locale]) {
     translation = new Translation(Translation.langs[locale]);
-  } else if (fileExists(path.join(global.codecept_dir, locale))) {
-    // get from a provided file instead
-    translation = Translation.createDefault();
-    translation.loadVocabulary(locale);
-  } else {
+  } else { // @ts-ignore
     translation = Translation.createDefault();
+    // @ts-ignore
+    if (fileExists(path.join(global.codecept_dir, locale))) {
+      // get from a provided file instead
+      translation.loadVocabulary(locale);
+    }
   }
 
   vocabularies.forEach(v => translation.loadVocabulary(v));

package/lib/data/context.js

@@ -1,129 +1,128 @@
-const { isGenerator } = require('../utils')
-const DataTable = require('./table')
-const DataScenarioConfig = require('./dataScenarioConfig')
-const Secret = require('../secret')
+import { isGenerator } from '../utils.js';
+import DataTable from './table.js';
+import DataScenarioConfig from './dataScenarioConfig.js';
 
-module.exports = function (context) {
+export default function (context) {
   context.Data = function (dataTable) {
-    const data = detectDataType(dataTable)
+    const data = detectDataType(dataTable);
     return {
       Scenario(title, opts, fn) {
-        const scenarios = []
+        const scenarios = [];
         if (typeof opts === 'function' && !fn) {
-          fn = opts
-          opts = {}
+          fn = opts;
+          opts = {};
         }
-        opts.data = data.map((dataRow) => dataRow.data)
+        opts.data = data.map(dataRow => dataRow.data);
         data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow)
+          const dataTitle = replaceTitle(title, dataRow);
           if (dataRow.skip) {
-            context.xScenario(dataTitle)
+            context.xScenario(dataTitle);
           } else {
-            scenarios.push(context.Scenario(dataTitle, opts, fn).inject({ current: dataRow.data }))
+            scenarios.push(context.Scenario(dataTitle, opts, fn)
+              .inject({ current: dataRow.data }));
           }
-        })
-        maskSecretInTitle(scenarios)
-        return new DataScenarioConfig(scenarios)
+        });
+        maskSecretInTitle(scenarios);
+        return new DataScenarioConfig(scenarios);
       },
       only: {
         Scenario(title, opts, fn) {
-          const scenarios = []
+          const scenarios = [];
           if (typeof opts === 'function' && !fn) {
-            fn = opts
-            opts = {}
+            fn = opts;
+            opts = {};
           }
-          opts.data = data.map((dataRow) => dataRow.data)
+          opts.data = data.map(dataRow => dataRow.data);
           data.forEach((dataRow) => {
-            const dataTitle = replaceTitle(title, dataRow)
+            const dataTitle = replaceTitle(title, dataRow);
             if (dataRow.skip) {
-              context.xScenario(dataTitle)
+              context.xScenario(dataTitle);
             } else {
-              scenarios.push(context.Scenario.only(dataTitle, opts, fn).inject({ current: dataRow.data }))
+              scenarios.push(context.Scenario.only(dataTitle, opts, fn)
+                .inject({ current: dataRow.data }));
             }
-          })
-          maskSecretInTitle(scenarios)
-          return new DataScenarioConfig(scenarios)
+          });
+          maskSecretInTitle(scenarios);
+          return new DataScenarioConfig(scenarios);
         },
       },
-    }
-  }
+    };
+  };
 
   context.xData = function (dataTable) {
-    const data = detectDataType(dataTable)
+    const data = detectDataType(dataTable);
     return {
       Scenario: (title) => {
         data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow)
-          context.xScenario(dataTitle)
-        })
-        return new DataScenarioConfig([])
+          const dataTitle = replaceTitle(title, dataRow);
+          context.xScenario(dataTitle);
+        });
+        return new DataScenarioConfig([]);
       },
-    }
-  }
+    };
+  };
 }
 
 function replaceTitle(title, dataRow) {
   if (typeof dataRow.data !== 'object') {
-    return `${title} | {${JSON.stringify(dataRow.data)}}`
+    return `${title} | {${JSON.stringify(dataRow.data)}}`;
   }
 
   // if `dataRow` is object and has own `toString()` method,
   // it should be printed
-  if (
-    Object.prototype.toString.call(dataRow.data) === Object().toString() &&
-    dataRow.data.toString() !== Object().toString()
-  ) {
-    return `${title} | ${dataRow.data}`
+  if (Object.prototype.toString.call(dataRow.data) === (Object()).toString()
+    && dataRow.data.toString() !== (Object()).toString()) {
+    return `${title} | ${dataRow.data}`;
   }
 
-  return `${title} | ${JSON.stringify(dataRow.data)}`
+  return `${title} | ${JSON.stringify(dataRow.data)}`;
 }
 
 function isTableDataRow(row) {
-  const has = Object.prototype.hasOwnProperty
-  return has.call(row, 'data') && has.call(row, 'skip')
+  const has = Object.prototype.hasOwnProperty;
+  return has.call(row, 'data') && has.call(row, 'skip');
 }
 
 function detectDataType(dataTable) {
   if (dataTable instanceof DataTable) {
-    return dataTable.rows
+    return dataTable.rows;
   }
 
   if (isGenerator(dataTable)) {
-    const data = []
+    const data = [];
     for (const dataRow of dataTable()) {
       data.push({
         data: dataRow,
-      })
+      });
     }
-    return data
+    return data;
   }
   if (typeof dataTable === 'function') {
-    return dataTable()
+    return dataTable();
   }
   if (Array.isArray(dataTable)) {
     return dataTable.map((item) => {
       if (isTableDataRow(item)) {
-        return item
+        return item;
       }
       return {
         data: item,
         skip: false,
-      }
-    })
+      };
+    });
   }
 
-  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function')
+  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function');
 }
 
 function maskSecretInTitle(scenarios) {
-  scenarios.forEach((scenario) => {
-    const res = []
+  scenarios.forEach(scenario => {
+    const res = [];
 
-    scenario.test.title.split(',').forEach((item) => {
-      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'))
-    })
+    scenario.test.title.split(',').forEach(item => {
+      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'));
+    });
 
-    scenario.test.title = res.join(',')
-  })
+    scenario.test.title = res.join(',');
+  });
 }

package/lib/data/dataScenarioConfig.js

@@ -1,84 +1,84 @@
 class DataScenarioConfig {
   constructor(scenarios) {
-    this.scenarios = scenarios
+    this.scenarios = scenarios;
   }
 
   /**
-   * Declares that test throws error.
-   * Can pass an Error object or regex matching expected message.
-   *
-   * @param {*} err
-   */
+     * Declares that test throws error.
+     * Can pass an Error object or regex matching expected message.
+     *
+     * @param {*} err
+     */
   throws(err) {
-    this.scenarios.forEach((scenario) => scenario.throws(err))
-    return this
+    this.scenarios.forEach(scenario => scenario.throws(err));
+    return this;
   }
 
   /**
-   * Declares that test should fail.
-   * If test passes - throws an error.
-   * Can pass an Error object or regex matching expected message.
-   *
-   */
+     * Declares that test should fail.
+     * If test passes - throws an error.
+     * Can pass an Error object or regex matching expected message.
+     *
+     */
   fails() {
-    this.scenarios.forEach((scenario) => scenario.fails())
-    return this
+    this.scenarios.forEach(scenario => scenario.fails());
+    return this;
   }
 
   /**
-   * Retry this test for x times
-   *
-   * @param {*} retries
-   */
+     * Retry this test for x times
+     *
+     * @param {*} retries
+     */
   retry(retries) {
-    this.scenarios.forEach((scenario) => scenario.retry(retries))
-    return this
+    this.scenarios.forEach(scenario => scenario.retry(retries));
+    return this;
   }
 
   /**
-   * Set timeout for this test
-   * @param {*} timeout
-   */
+     * Set timeout for this test
+     * @param {*} timeout
+     */
   timeout(timeout) {
-    this.scenarios.forEach((scenario) => scenario.timeout(timeout))
-    return this
+    this.scenarios.forEach(scenario => scenario.timeout(timeout));
+    return this;
   }
 
   /**
-   * Configures a helper.
-   * Helper name can be omitted and values will be applied to first helper.
-   */
+     * Configures a helper.
+     * Helper name can be omitted and values will be applied to first helper.
+     */
   config(helper, obj) {
-    this.scenarios.forEach((scenario) => scenario.config(helper, obj))
-    return this
+    this.scenarios.forEach(scenario => scenario.config(helper, obj));
+    return this;
   }
 
   /**
-   * Append a tag name to scenario title
-   * @param {*} tagName
-   */
+     * Append a tag name to scenario title
+     * @param {*} tagName
+     */
   tag(tagName) {
-    this.scenarios.forEach((scenario) => scenario.tag(tagName))
-    return this
+    this.scenarios.forEach(scenario => scenario.tag(tagName));
+    return this;
   }
 
   /**
-   * Pass in additional objects to inject into test
-   * @param {*} obj
-   */
+     * Pass in additional objects to inject into test
+     * @param {*} obj
+     */
   inject(obj) {
-    this.scenarios.forEach((scenario) => scenario.inject(obj))
-    return this
+    this.scenarios.forEach(scenario => scenario.inject(obj));
+    return this;
   }
 
   /**
-   * Dynamically injects dependencies, see https://codecept.io/pageobjects/#dynamic-injection
-   * @param {*} dependencies
-   */
+     * Dynamically injects dependencies, see https://codecept.io/pageobjects/#dynamic-injection
+     * @param {*} dependencies
+     */
   injectDependencies(dependencies) {
-    this.scenarios.forEach((scenario) => scenario.injectDependencies(dependencies))
-    return this
+    this.scenarios.forEach(scenario => scenario.injectDependencies(dependencies));
+    return this;
   }
 }
 
-module.exports = DataScenarioConfig
+export default DataScenarioConfig;

package/lib/data/dataTableArgument.js

@@ -7,60 +7,60 @@ class DataTableArgument {
   constructor(gherkinDataTable) {
     this.rawData = gherkinDataTable.rows.map((row) => {
       return row.cells.map((cell) => {
-        return cell.value
-      })
-    })
+        return cell.value;
+      });
+    });
   }
 
   /** Returns the table as a 2-D array
-   * @returns {string[][]}
-   */
+  * @returns {string[][]}
+  */
   raw() {
-    return this.rawData.slice(0)
+    return this.rawData.slice(0);
   }
 
   /** Returns the table as a 2-D array, without the first row
-   * @returns {string[][]}
-   */
+  * @returns {string[][]}
+  */
   rows() {
-    const copy = this.raw()
-    copy.shift()
-    return copy
+    const copy = this.raw();
+    copy.shift();
+    return copy;
   }
 
   /** Returns an array of objects where each row is converted to an object (column header is the key)
-   * @returns {any[]}
-   */
+  * @returns {any[]}
+  */
   hashes() {
-    const copy = this.raw()
-    const header = copy.shift()
+    const copy = this.raw();
+    const header = copy.shift();
     return copy.map((row) => {
-      const r = {}
-      row.forEach((cell, index) => (r[header[index]] = cell))
-      return r
-    })
+      const r = {};
+      row.forEach((cell, index) => r[header[index]] = cell);
+      return r;
+    });
   }
 
   /** Returns an object where each row corresponds to an entry
    * (first column is the key, second column is the value)
-   * @returns {Record<string, string>}
-   */
+  * @returns {Record<string, string>}
+  */
   rowsHash() {
-    const rows = this.raw()
-    const everyRowHasTwoColumns = rows.every((row) => row.length === 2)
+    const rows = this.raw();
+    const everyRowHasTwoColumns = rows.every((row) => row.length === 2);
     if (!everyRowHasTwoColumns) {
-      throw new Error('rowsHash can only be called on a data table where all rows have exactly two columns')
+      throw new Error('rowsHash can only be called on a data table where all rows have exactly two columns');
     }
     /** @type {Record<string, string>} */
-    const result = {}
-    rows.forEach((x) => (result[x[0]] = x[1]))
-    return result
+    const result = {};
+    rows.forEach((x) => (result[x[0]] = x[1]));
+    return result;
   }
 
   /** Transposed the data */
   transpose() {
-    this.rawData = this.rawData[0].map((x, i) => this.rawData.map((y) => y[i]))
+    this.rawData = this.rawData[0].map((x, i) => this.rawData.map((y) => y[i]));
   }
 }
 
-module.exports = DataTableArgument
+export default DataTableArgument;