codeceptjs 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/container.js

@@ -1,26 +1,23 @@
-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';
+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');
 
 let container = {
   helpers: {},
   support: {},
   plugins: {},
+  /**
+   * @type {Mocha | {}}
+   * @ignore
+   */
   mocha: {},
   translation: {},
 };
@@ -28,7 +25,7 @@ let container = {
 /**
  * Dependency Injection Container
  */
-export default class Container {
+class Container {
   /**
    * Create container with all required helpers and support objects
    *
@@ -62,7 +59,10 @@ export default class Container {
    * @returns { * }
    */
   static plugins(name) {
-    return name ? container.plugins[name] : container.plugins;
+    if (!name) {
+      return container.plugins;
+    }
+    return container.plugins[name];
   }
 
   /**
@@ -119,6 +119,7 @@ export default class Container {
    * @param {Object<string, *>} newContainer
    */
   static append(newContainer) {
+    const deepMerge = require('./utils').deepMerge;
     container = deepMerge(container, newContainer);
   }
 
@@ -150,6 +151,8 @@ export default class Container {
   }
 }
 
+module.exports = Container;
+
 function createHelpers(config) {
   const helpers = {};
   let moduleName;
@@ -157,31 +160,29 @@ 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}.js`; // built-in helper
+        moduleName = `./helper/${helperName}`; // built-in helper
       }
 
       // @ts-ignore
       let HelperClass;
       // check if the helper is the built-in, use the require() syntax.
       if (moduleName.startsWith('./helper/')) {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        HelperClass = importSync(path.resolve(__dirname, moduleName)).default;
+        HelperClass = require(moduleName);
       } 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 = importSync(path.resolve(moduleName)).default;
+        HelperClass = require(moduleName).default || require(moduleName);
       }
 
-      if (HelperClass && HelperClass._checkRequirements) {
+      if (HelperClass._checkRequirements) {
         const requirements = HelperClass._checkRequirements();
         if (requirements) {
           let install;
-          if (importSync('./utils.js').installedLocally()) {
+          if (require('./utils').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');
@@ -202,7 +203,7 @@ function createHelpers(config) {
   return helpers;
 }
 
-export function createSupportObjects(config) {
+function createSupportObjects(config) {
   const objects = {};
 
   for (const name in config) {
@@ -210,7 +211,7 @@ export function createSupportObjects(config) {
   }
 
   if (!config.I) {
-    objects.I = actor();
+    objects.I = require('./actor')();
 
     if (container.translation.I !== 'I') {
       objects[container.translation.I] = objects.I;
@@ -294,13 +295,12 @@ 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}.js`;
+        module = `./plugin/${pluginName}`;
       }
-      plugins[pluginName] = importSync(module).default(config[pluginName]);
+      plugins[pluginName] = require(module)(config[pluginName]);
     } catch (err) {
       throw new Error(`Could not load plugin ${pluginName} from module '${module}':\n${err.message}\n${err.stack}`);
     }
@@ -316,10 +316,8 @@ function getSupportObject(config, name) {
   return module;
 }
 
-export function loadGherkinSteps(paths) {
-  // @ts-ignore
+function loadGherkinSteps(paths) {
   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);
 
@@ -331,7 +329,6 @@ export 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) => {
@@ -340,20 +337,17 @@ export 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 = importSync(modulePath).default || importSync(modulePath);
+    const obj = require(modulePath);
 
     if (typeof obj === 'function') {
       const fobj = obj();
@@ -411,7 +405,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));
     }
@@ -430,18 +424,16 @@ 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 { // @ts-ignore
+  } else if (fileExists(path.join(global.codecept_dir, locale))) {
+    // get from a provided file instead
+    translation = Translation.createDefault();
+    translation.loadVocabulary(locale);
+  } else {
     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,128 +1,129 @@
-import { isGenerator } from '../utils.js';
-import DataTable from './table.js';
-import DataScenarioConfig from './dataScenarioConfig.js';
+const { isGenerator } = require('../utils')
+const DataTable = require('./table')
+const DataScenarioConfig = require('./dataScenarioConfig')
+const Secret = require('../secret')
 
-export default function (context) {
+module.exports = 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
   }
 }
 
-export default DataScenarioConfig;
+module.exports = 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]))
   }
 }
 
-export default DataTableArgument;
+module.exports = DataTableArgument