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

package/lib/plugin/wdio.js

@@ -1,19 +1,17 @@
-import debug from 'debug';
+const debug = require('debug')('codeceptjs:plugin:wdio')
 
-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 container = require('../container')
+const mainConfig = require('../config')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
 
 const defaultConfig = {
   services: [],
   capabilities: {},
-};
+}
 
-let restartsSession;
+let restartsSession
 
 /**
  * Webdriverio services runner.
@@ -83,164 +81,169 @@ let restartsSession;
  * * ... - additional configuration passed into services.
  *
  */
-export default (config) => {
+module.exports = (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,10 +1,9 @@
-import debug from 'debug';
-import promiseRetry from 'promise-retry';
-import chalk from 'chalk';
-import { printObjectProperties } from './utils.js';
-import * as output from './output.js';
+const debug = require('debug')('codeceptjs:recorder');
+const promiseRetry = require('promise-retry');
+const chalk = require('chalk');
+const { printObjectProperties } = require('./utils');
+const { log } = require('./output');
 
-debug('codeceptjs:recorder');
 const MAX_TASKS = 100;
 
 let promise;
@@ -29,7 +28,7 @@ const defaultRetryOptions = {
  * @alias recorder
  * @interface
  */
-export default {
+module.exports = {
 
   /**
    * @type {Array<Object<string, *>>}
@@ -48,7 +47,6 @@ export default {
     running = true;
     asyncErr = null;
     errFn = null;
-    // @ts-ignore
     this.reset();
   },
 
@@ -93,7 +91,7 @@ export default {
     queueId++;
     sessionId = null;
     asyncErr = null;
-    output.output.log(`${currentQueue()} Starting recording promises`);
+    log(`${currentQueue()} Starting recording promises`);
     promise = Promise.resolve();
     oldPromises = [];
     tasks = [];
@@ -165,10 +163,10 @@ export default {
    * @param {boolean} [force=false]
    * @param {boolean} [retry]
    *     undefined: `add(fn)` -> `false` and `add('step',fn)` -> `true`
-   *     true: it will retry if `retryOpts` set.
+   *     true: it will retries if `retryOpts` set.
    *     false: ignore `retryOpts` and won't retry.
    * @param {number} [timeout]
-   * @return {Promise<*>|undefined}
+   * @return {Promise<*>}
    * @inner
    */
   add(taskName, fn = undefined, force = false, retry = undefined, timeout = undefined) {
@@ -197,7 +195,7 @@ export default {
 
       const retryRules = this.retries.slice().reverse();
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
-        if (number > 1) output.output.log(`${currentQueue()}Retrying... Attempt #${number}`);
+        if (number > 1) 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;
@@ -237,7 +235,7 @@ export default {
     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) => {
-      output.output.log(`${currentQueue()}Error | ${err} ${fnDescription}...`);
+      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
       }
@@ -259,7 +257,7 @@ export default {
     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
-      output.output.log(`${currentQueue()}Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`);
+      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
       }
@@ -321,10 +319,8 @@ export default {
    * @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;
   },
 
@@ -365,6 +361,7 @@ export default {
   toString() {
     return `Queue: ${currentQueue()}\n\nTasks: ${this.scheduled()}`;
   },
+
 };
 
 function getTimeoutPromise(timeoutMs, taskName) {

package/lib/rerun.js

@@ -1,8 +1,8 @@
-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';
+const fsPath = require('path');
+const container = require('./container');
+const event = require('./event');
+const BaseCodecept = require('./codecept');
+const output = require('./output');
 
 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.output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`);
+        output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`);
       } catch (e) {
-        output.output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`);
+        output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`);
         console.error(e);
       }
     }
@@ -69,7 +69,8 @@ class CodeceptRerunner extends BaseCodecept {
     try {
       await this.runTests(test);
     } catch (e) {
-      output.output.error(e.stack);
+      output.error(e.stack);
+      throw e;
     } finally {
       event.emit(event.all.result, this);
       event.emit(event.all.after, this);
@@ -77,4 +78,4 @@ class CodeceptRerunner extends BaseCodecept {
   }
 }
 
-export default CodeceptRerunner;
+module.exports = CodeceptRerunner;

package/lib/scenario.js

@@ -1,10 +1,9 @@
-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 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');
 
 const injectHook = function (inject, suite) {
   try {
@@ -34,7 +33,7 @@ function makeDoneCallableOnce(done) {
  * starts promise chain with recorder, performs before/after hooks
  * through event system.
  */
-export function test(test) {
+module.exports.test = (test) => {
   const testFn = test.fn;
   if (!testFn) {
     return test;
@@ -101,12 +100,12 @@ export function test(test) {
     }
   };
   return test;
-}
+};
 
 /**
  * Injects arguments to function from controller
  */
-export function injected(fn, suite, hookName) {
+module.exports.injected = function (fn, suite, hookName) {
   return function (done) {
     const doneFn = makeDoneCallableOnce(done);
     const errHandler = (err) => {
@@ -168,43 +167,44 @@ export function injected(fn, suite, hookName) {
         recorder.add('fire hook.failed', () => event.emit(event.hook.failed, suite, e));
       });
   };
-}
+};
 
 /**
  * Starts promise chain, so helpers could enqueue their hooks
  */
-export function setup(suite) {
+module.exports.setup = function (suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.test.before, suite && suite.ctx && suite.ctx.currentTest);
   }, suite);
-}
+};
 
-export function teardown(suite) {
+module.exports.teardown = function (suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.test.after, suite && suite.ctx && suite.ctx.currentTest);
   }, suite);
-}
+};
 
-export function suiteSetup(suite) {
+module.exports.suiteSetup = function (suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.suite.before, suite);
   }, suite);
-}
+};
 
-export function suiteTeardown(suite) {
+module.exports.suiteTeardown = function (suite) {
   return injectHook(() => {
     recorder.startUnlessRunning();
     event.emit(event.suite.after, suite);
   }, suite);
-}
+};
 
-export function getInjectedArguments(fn, test) {
+const getInjectedArguments = (fn, test) => {
+  const container = require('./container');
   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,8 +215,10 @@ export function 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 */
-import { deepClone } from './utils.js';
+const { deepClone } = require('./utils');
 
 const maskedString = '*****';
 
 /** @param {string} secret */
-export default class Secret {
+class Secret {
   constructor(secret) {
     this._secret = secret;
   }
@@ -48,3 +48,5 @@ function secretObject(obj, fieldsToHide = []) {
 
   return new Proxy(obj, handler);
 }
+
+module.exports = Secret;

package/lib/session.js

@@ -1,9 +1,9 @@
-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 recorder = require('./recorder');
+const container = require('./container');
+const event = require('./event');
+const output = require('./output');
+const store = require('./store');
+const { isAsyncFunction } = require('./utils');
 
 const sessionColors = [
   'cyan',
@@ -90,7 +90,7 @@ function session(sessionName, config, fn) {
 
     const finalize = () => {
       recorder.add('Finalize session', async () => {
-        output.output.stepShift = 0;
+        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.output.stepShift = 0;
+        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.output.stepShift = 0;
+        output.stepShift = 0;
         event.dispatcher.removeListener(event.step.after, addContextToStep);
         throw e;
       });
@@ -129,4 +129,4 @@ function session(sessionName, config, fn) {
   }, false, false);
 }
 
-export default session;
+module.exports = session;

package/lib/step.js

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

package/lib/transform.js

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