codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/plugin/wdio.js

@@ -1,17 +1,19 @@
-const debug = require('debug')('codeceptjs:plugin:wdio')
+import debug from 'debug';
 
-const container = require('../container')
-const mainConfig = require('../config')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
+import container from '../container.js';
+import mainConfig from '../config.js';
+import recorder from '../recorder.js';
+import * as event from '../event.js';
+import * as output from '../output.js';
+
+debug('codeceptjs:plugin:wdio');
 
 const defaultConfig = {
   services: [],
   capabilities: {},
-}
+};
 
-let restartsSession
+let restartsSession;
 
 /**
  * Webdriverio services runner.
@@ -81,169 +83,164 @@ let restartsSession
  * * ... - additional configuration passed into services.
  *
  */
-module.exports = (config) => {
+export default (config) => {
   // Keep initial configs to pass as options to wdio services
-  const wdioOptions = { ...config }
-  const webDriver = container.helpers('WebDriver')
+  const wdioOptions = { ...config };
+  const webDriver = container.helpers('WebDriver');
   if (webDriver) {
-    config = Object.assign(webDriver.options, config)
-    restartsSession = !!config.restart
+    config = Object.assign(webDriver.options, config);
+    restartsSession = !!config.restart;
   }
-  config = Object.assign(defaultConfig, config)
-  const seleniumInstallArgs = { ...config.seleniumInstallArgs }
-  const seleniumArgs = { ...config.seleniumArgs }
+  config = Object.assign(defaultConfig, config);
+  const seleniumInstallArgs = { ...config.seleniumInstallArgs };
+  const seleniumArgs = { ...config.seleniumArgs };
 
-  const services = []
-  const launchers = []
+  const services = [];
+  const launchers = [];
 
   for (const name of config.services) {
-    const Service = safeRequire(`@wdio/${name.toLowerCase()}-service`)
+    const Service = safeRequire(`@wdio/${name.toLowerCase()}-service`);
     if (Service) {
       if (Service.launcher && typeof Service.launcher === 'function') {
-        const Launcher = Service.launcher
+        const Launcher = Service.launcher;
 
         const options = {
-          logPath: global.output_dir,
-          installArgs: seleniumInstallArgs,
-          args: seleniumArgs,
-          ...wdioOptions,
-        }
-        launchers.push(new Launcher(options, [config.capabilities], config))
+          logPath: global.output_dir, installArgs: seleniumInstallArgs, args: seleniumArgs, ...wdioOptions,
+        };
+        launchers.push(new Launcher(options, [config.capabilities], config));
       }
       if (typeof Service === 'function') {
-        services.push(new Service(config, config.capabilities))
+        services.push(new Service(config, config.capabilities));
       }
-      continue
+      continue;
     }
 
-    throw new Error(
-      `Couldn't initialize service ${name} from wdio plugin config.\nIt should be available either in '@wdio/${name.toLowerCase()}-service' package`,
-    )
+    throw new Error(`Couldn't initialize service ${name} from wdio plugin config.\nIt should be available either in '@wdio/${name.toLowerCase()}-service' package`);
   }
 
-  debug(`services ${services}, launchers ${launchers}`)
+  debug(`services ${services}, launchers ${launchers}`);
 
-  recorder.startUnlessRunning()
+  recorder.startUnlessRunning();
 
   for (const launcher of launchers) {
-    registerLauncher(launcher)
+    registerLauncher(launcher);
   }
 
   for (const service of services) {
-    registerService(service)
+    registerService(service);
   }
 
   function registerService(service) {
-    const name = service.constructor.name
+    const name = service.constructor.name;
     if (service.beforeSession) {
       event.dispatcher.on(event.all.before, () => {
         recorder.add(`service ${name} all.before`, async () => {
-          await service.beforeSession(config, config.capabilities)
-        })
-      })
+          await service.beforeSession(config, config.capabilities);
+        });
+      });
     }
 
     if (service.afterSession) {
       event.dispatcher.on(event.all.result, (result) => {
         recorder.add(`service ${name} all.after`, async () => {
-          await service.afterSession(result)
-        })
-      })
+          await service.afterSession(result);
+        });
+      });
     }
 
     if (service.beforeSuite) {
       event.dispatcher.on(event.suite.before, (suite) => {
-        debug(`suite started: ${suite.title}`)
-        recorder.add(`service ${name} suite.before`, () => service.beforeSuite(suite))
-      })
+        debug(`suite started: ${suite.title}`);
+        recorder.add(`service ${name} suite.before`, () => service.beforeSuite(suite));
+      });
     }
 
     if (service.afterSuite) {
       event.dispatcher.on(event.suite.after, (suite) => {
-        debug(`suite finished: ${suite.title}`)
-        recorder.add(`service ${name} suite.after`, () => service.afterSuite(suite))
-      })
+        debug(`suite finished: ${suite.title}`);
+        recorder.add(`service ${name} suite.after`, () => service.afterSuite(suite));
+      });
     }
 
     if (service.beforeTest) {
       event.dispatcher.on(event.test.started, async (test) => {
         if (test.parent) {
-          test.parent.toString = () => test.parent.title
+          test.parent.toString = () => test.parent.title;
         }
         // test.parent = test.parent ? test.parent.title : null;
-        debug(`test started: ${test.title}`)
+        debug(`test started: ${test.title}`);
         if (webDriver) {
-          global.browser = webDriver.browser
-          global.browser.config = Object.assign(mainConfig.get('test', 1), global.browser.config)
+          global.browser = webDriver.browser;
+          global.browser.config = Object.assign(mainConfig.get('test', 1), global.browser.config);
         }
-        await service.beforeTest(test)
-      })
+        await service.beforeTest(test);
+      });
     }
 
     if (service.afterTest) {
       event.dispatcher.on(event.test.finished, async (test) => {
-        debug(`test finished: ${test.title}`)
-        await service.afterTest(test)
-      })
+        debug(`test finished: ${test.title}`);
+        await service.afterTest(test);
+      });
     }
 
     if (restartsSession && service.before) {
-      event.dispatcher.on(event.test.started, () => service.before())
+      event.dispatcher.on(event.test.started, () => service.before());
     }
 
     if (restartsSession && service.after) {
-      event.dispatcher.on(event.test.finished, () => service.after())
+      event.dispatcher.on(event.test.finished, () => service.after());
     }
 
     if (!restartsSession && service.before) {
-      let initializedBrowser = false
+      let initializedBrowser = false;
       event.dispatcher.on(event.test.started, async () => {
         if (!initializedBrowser) {
-          await service.before()
-          initializedBrowser = true
+          await service.before();
+          initializedBrowser = true;
         }
-      })
+      });
     }
 
     if (!restartsSession && service.after) {
-      event.dispatcher.on(event.all.result, (result) => service.after(result))
+      event.dispatcher.on(event.all.result, result => service.after(result));
     }
   }
 
   function registerLauncher(launcher) {
-    const name = launcher.constructor.name
+    const name = launcher.constructor.name;
     if (launcher.onPrepare) {
       event.dispatcher.on(event.all.before, () => {
         recorder.add(`launcher ${name} start`, async () => {
           // browserstack-service expects capabilities as array
           if (launcher.constructor.name === 'BrowserstackLauncherService') {
-            await launcher.onPrepare(config, [config.capabilities])
+            await launcher.onPrepare(config, [config.capabilities]);
           } else {
-            await launcher.onPrepare(config, config.capabilities)
+            await launcher.onPrepare(config, config.capabilities);
           }
-          output.debug(`Started ${name}`)
-        })
-      })
+          output.debug(`Started ${name}`);
+        });
+      });
     }
 
     if (launcher.onComplete) {
       event.dispatcher.on(event.all.after, () => {
         recorder.add(`launcher ${name} start`, async () => {
-          await launcher.onComplete(process.exitCode, config, config.capabilities)
-          output.debug(`Stopped ${name}`)
-        })
-      })
+          await launcher.onComplete(process.exitCode, config, config.capabilities);
+          output.debug(`Stopped ${name}`);
+        });
+      });
     }
   }
-}
+};
 
 function safeRequire(name) {
   try {
-    return require(name)
+    return require(name);
   } catch (e) {
     if (!e.message.match(`Cannot find module '${name}'`)) {
-      throw new Error(`Couldn't initialise "${name}".\n${e.stack}`)
+      throw new Error(`Couldn't initialise "${name}".\n${e.stack}`);
     }
-    return null
+    return null;
   }
 }

package/lib/recorder.js

@@ -1,9 +1,10 @@
-const debug = require('debug')('codeceptjs:recorder');
-const promiseRetry = require('promise-retry');
-const chalk = require('chalk');
-const { printObjectProperties } = require('./utils');
-const { log } = require('./output');
+import debug from 'debug';
+import promiseRetry from 'promise-retry';
+import chalk from 'chalk';
+import { printObjectProperties } from './utils.js';
+import * as output from './output.js';
 
+debug('codeceptjs:recorder');
 const MAX_TASKS = 100;
 
 let promise;
@@ -28,7 +29,7 @@ const defaultRetryOptions = {
  * @alias recorder
  * @interface
  */
-module.exports = {
+export default {
 
   /**
    * @type {Array<Object<string, *>>}
@@ -47,6 +48,7 @@ module.exports = {
     running = true;
     asyncErr = null;
     errFn = null;
+    // @ts-ignore
     this.reset();
   },
 
@@ -91,7 +93,7 @@ module.exports = {
     queueId++;
     sessionId = null;
     asyncErr = null;
-    log(`${currentQueue()} Starting recording promises`);
+    output.output.log(`${currentQueue()} Starting recording promises`);
     promise = Promise.resolve();
     oldPromises = [];
     tasks = [];
@@ -163,10 +165,10 @@ module.exports = {
    * @param {boolean} [force=false]
    * @param {boolean} [retry]
    *     undefined: `add(fn)` -> `false` and `add('step',fn)` -> `true`
-   *     true: it will retries if `retryOpts` set.
+   *     true: it will retry if `retryOpts` set.
    *     false: ignore `retryOpts` and won't retry.
    * @param {number} [timeout]
-   * @return {Promise<*>}
+   * @return {Promise<*>|undefined}
    * @inner
    */
   add(taskName, fn = undefined, force = false, retry = undefined, timeout = undefined) {
@@ -195,7 +197,7 @@ module.exports = {
 
       const retryRules = this.retries.slice().reverse();
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
-        if (number > 1) log(`${currentQueue()}Retrying... Attempt #${number}`);
+        if (number > 1) output.output.log(`${currentQueue()}Retrying... Attempt #${number}`);
         const [promise, timer] = getTimeoutPromise(timeout, taskName);
         return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer)).catch((err) => {
           if (ignoredErrs.includes(err)) return;
@@ -235,7 +237,7 @@ module.exports = {
     const fnDescription = customErrFn?.toString()?.replace(/\s{2,}/g, ' ').replace(/\n/g, ' ')?.slice(0, 50);
     debug(chalk.gray(`${currentQueue()} Queued | catch with error handler ${fnDescription || ''}`));
     return promise = promise.catch((err) => {
-      log(`${currentQueue()}Error | ${err} ${fnDescription}...`);
+      output.output.log(`${currentQueue()}Error | ${err} ${fnDescription}...`);
       if (!(err instanceof Error)) { // strange things may happen
         err = new Error(`[Wrapped Error] ${printObjectProperties(err)}`); // we should be prepared for them
       }
@@ -257,7 +259,7 @@ module.exports = {
     const fnDescription = customErrFn?.toString()?.replace(/\s{2,}/g, ' ').replace(/\n/g, ' ')?.slice(0, 50);
     return promise = promise.catch((err) => {
       if (ignoredErrs.includes(err)) return; // already caught
-      log(`${currentQueue()} Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`);
+      output.output.log(`${currentQueue()}Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`);
       if (!(err instanceof Error)) { // strange things may happen
         err = new Error(`[Wrapped Error] ${JSON.stringify(err)}`); // we should be prepared for them
       }
@@ -319,8 +321,10 @@ module.exports = {
    * @inner
    */
   stop() {
+    if (process.env.DEBUG) debug(this.toString());
+    output.output.log(`${currentQueue()}Stopping recording promises`);
     debug(this.toString());
-    log(`${currentQueue()} Stopping recording promises`);
+
     running = false;
   },
 
@@ -361,7 +365,6 @@ module.exports = {
   toString() {
     return `Queue: ${currentQueue()}\n\nTasks: ${this.scheduled()}`;
   },
-
 };
 
 function getTimeoutPromise(timeoutMs, taskName) {

package/lib/rerun.js

@@ -1,8 +1,8 @@
-const fsPath = require('path');
-const container = require('./container');
-const event = require('./event');
-const BaseCodecept = require('./codecept');
-const output = require('./output');
+import fsPath from 'path';
+import container from './container.js';
+import * as event from './event.js';
+import BaseCodecept from './codecept.js';
+import * as output from './output.js';
 
 class CodeceptRerunner extends BaseCodecept {
   runOnce(test) {
@@ -11,7 +11,7 @@ class CodeceptRerunner extends BaseCodecept {
       container.createMocha();
       const mocha = container.mocha();
       this.testFiles.forEach((file) => {
-        delete require.cache[file];
+        // delete require.cache[file];
       });
       mocha.files = this.testFiles;
       if (test) {
@@ -53,9 +53,9 @@ class CodeceptRerunner extends BaseCodecept {
       try {
         await this.runOnce(test);
         successCounter++;
-        output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`);
+        output.output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`);
       } catch (e) {
-        output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`);
+        output.output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`);
         console.error(e);
       }
     }
@@ -69,8 +69,7 @@ class CodeceptRerunner extends BaseCodecept {
     try {
       await this.runTests(test);
     } catch (e) {
-      output.error(e.stack);
-      throw e;
+      output.output.error(e.stack);
     } finally {
       event.emit(event.all.result, this);
       event.emit(event.all.after, this);
@@ -78,4 +77,4 @@ class CodeceptRerunner extends BaseCodecept {
   }
 }
 
-module.exports = CodeceptRerunner;
+export default CodeceptRerunner;

package/lib/scenario.js

@@ -1,9 +1,10 @@
-const promiseRetry = require('promise-retry');
-const event = require('./event');
-const recorder = require('./recorder');
-const assertThrown = require('./assert/throws');
-const { ucfirst, isAsyncFunction } = require('./utils');
-const parser = require('./parser');
+import promiseRetry from 'promise-retry';
+import * as event from './event.js';
+import recorder from './recorder.js';
+import assertThrown from './assert/throws.js';
+import { ucfirst, isAsyncFunction } from './utils.js';
+import * as parser from './parser.js';
+import Container from './container.js';
 
 const injectHook = function (inject, suite) {
   try {
@@ -33,7 +34,7 @@ function makeDoneCallableOnce(done) {
  * starts promise chain with recorder, performs before/after hooks
  * through event system.
  */
-module.exports.test = (test) => {
+export function test(test) {
   const testFn = test.fn;
   if (!testFn) {
     return test;
@@ -100,12 +101,12 @@ module.exports.test = (test) => {
     }
   };
   return test;
-};
+}
 
 /**
  * Injects arguments to function from controller
  */
-module.exports.injected = function (fn, suite, hookName) {
+export function injected(fn, suite, hookName) {
   return function (done) {
     const doneFn = makeDoneCallableOnce(done);
     const errHandler = (err) => {
@@ -167,44 +168,43 @@ module.exports.injected = function (fn, suite, hookName) {
         recorder.add('fire hook.failed', () => event.emit(event.hook.failed, suite, e));
       });
   };
-};
+}
 
 /**
  * Starts promise chain, so helpers could enqueue their hooks
  */
-module.exports.setup = function (suite) {
+export function setup(suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.test.before, suite && suite.ctx && suite.ctx.currentTest);
   }, suite);
-};
+}
 
-module.exports.teardown = function (suite) {
+export function teardown(suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.test.after, suite && suite.ctx && suite.ctx.currentTest);
   }, suite);
-};
+}
 
-module.exports.suiteSetup = function (suite) {
+export function suiteSetup(suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.suite.before, suite);
   }, suite);
-};
+}
 
-module.exports.suiteTeardown = function (suite) {
+export function suiteTeardown(suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.suite.after, suite);
   }, suite);
-};
+}
 
-const getInjectedArguments = (fn, test) => {
-  const container = require('./container');
+export function getInjectedArguments(fn, test) {
   const testArgs = {};
   const params = parser.getParams(fn) || [];
-  const objects = container.support();
+  const objects = Container.support();
   for (const key of params) {
     testArgs[key] = {};
     if (test && test.inject && test.inject[key]) {
@@ -215,10 +215,8 @@ const getInjectedArguments = (fn, test) => {
     if (!objects[key]) {
       throw new Error(`Object of type ${key} is not defined in container`);
     }
-    testArgs[key] = container.support(key);
+    testArgs[key] = Container.support(key);
   }
 
   return testArgs;
-};
-
-module.exports.getInjectedArguments = getInjectedArguments;
+}

package/lib/secret.js

@@ -1,10 +1,10 @@
 /* eslint-disable max-classes-per-file */
-const { deepClone } = require('./utils');
+import { deepClone } from './utils.js';
 
 const maskedString = '*****';
 
 /** @param {string} secret */
-class Secret {
+export default class Secret {
   constructor(secret) {
     this._secret = secret;
   }
@@ -48,5 +48,3 @@ function secretObject(obj, fieldsToHide = []) {
 
   return new Proxy(obj, handler);
 }
-
-module.exports = Secret;

package/lib/session.js

@@ -1,9 +1,9 @@
-const recorder = require('./recorder');
-const container = require('./container');
-const event = require('./event');
-const output = require('./output');
-const store = require('./store');
-const { isAsyncFunction } = require('./utils');
+import recorder from './recorder.js';
+import container from './container.js';
+import * as event from './event.js';
+import * as output from './output.js';
+import { store } from './store.js';
+import { isAsyncFunction } from './utils.js';
 
 const sessionColors = [
   'cyan',
@@ -90,7 +90,7 @@ function session(sessionName, config, fn) {
 
     const finalize = () => {
       recorder.add('Finalize session', async () => {
-        output.stepShift = 0;
+        output.output.stepShift = 0;
         event.dispatcher.removeListener(event.step.after, addContextToStep);
         await session.restoreVars();
         recorder.session.restore(`session:${sessionName}`);
@@ -103,7 +103,7 @@ function session(sessionName, config, fn) {
         finalize();
         return recorder.promise().then(() => res);
       }).catch((e) => {
-        output.stepShift = 0;
+        output.output.stepShift = 0;
         session.restoreVars(sessionName);
         event.dispatcher.removeListener(event.step.after, addContextToStep);
         recorder.throw(e);
@@ -119,7 +119,7 @@ function session(sessionName, config, fn) {
     } finally {
       recorder.catch((e) => {
         session.restoreVars(sessionName);
-        output.stepShift = 0;
+        output.output.stepShift = 0;
         event.dispatcher.removeListener(event.step.after, addContextToStep);
         throw e;
       });
@@ -129,4 +129,4 @@ function session(sessionName, config, fn) {
   }, false, false);
 }
 
-module.exports = session;
+export default session;

package/lib/step.js

@@ -1,8 +1,9 @@
 // TODO: place MetaStep in other file, disable rule
 /* eslint-disable max-classes-per-file */
-const store = require('./store');
-const Secret = require('./secret');
-const event = require('./event');
+import { store } from './store.js';
+
+import Secret from './secret.js';
+import * as event from './event.js';
 
 const STACK_LINE = 4;
 
@@ -12,7 +13,7 @@ const STACK_LINE = 4;
  * @param {CodeceptJS.Helper} helper
  * @param {string} name
  */
-class Step {
+export class Step {
   static get TIMEOUT_ORDER() {
     return {
       /**
@@ -71,13 +72,11 @@ class Step {
       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` - timeout overrides higher values of timeout or 'no timeout' (totalTimeout === 0) set by elements with higher order
+            (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 === undefined || timeout > 0 && (timeout < totalTimeout || totalTimeout === 0)))
         )) {
           totalTimeout = timeout;
         }
@@ -221,7 +220,7 @@ class Step {
 }
 
 /** @extends Step */
-class MetaStep extends Step {
+export class MetaStep extends Step {
   constructor(obj, method) {
     super(null, method);
     this.actor = obj;
@@ -311,8 +310,6 @@ Step.TIMEOUTS = {};
 /** @type {Class<MetaStep>} */
 Step.MetaStep = MetaStep;
 
-module.exports = Step;
-
 function dryRunResolver() {
   return {
     get(target, prop) {

package/lib/store.js

@@ -2,7 +2,7 @@
  * global values for current session
  * @namespace
  */
-const store = {
+export const store = {
   /** @type {boolean} */
   debugMode: false,
   /** @type {boolean} */
@@ -11,4 +11,5 @@ const store = {
   dryRun: false,
 };
 
-module.exports = store;
+/** @type {boolean} */
+export const timeouts = true;

package/lib/transform.js

@@ -23,4 +23,4 @@ transform.addTransformerBeforeAll = function (target, transformer) {
   }
 };
 
-module.exports = transform;
+export default transform;