codeceptjs 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/data/table.js

@@ -4,40 +4,46 @@
 class DataTable {
   /** @param {Array<*>} array */
   constructor(array) {
-    this.array = array;
-    this.rows = new Array(0);
+    this.array = array
+    this.rows = new Array(0)
   }
 
   /** @param {Array<*>} array */
   add(array) {
-    if (array.length !== this.array.length) throw new Error(`There is too many elements in given data array. Please provide data in this format: ${this.array}`);
-    const tempObj = {};
-    let arrayCounter = 0;
+    if (array.length !== this.array.length)
+      throw new Error(
+        `There is too many elements in given data array. Please provide data in this format: ${this.array}`,
+      )
+    const tempObj = {}
+    let arrayCounter = 0
     this.array.forEach((elem) => {
-      tempObj[elem] = array[arrayCounter];
-      tempObj.toString = () => JSON.stringify(tempObj);
-      arrayCounter++;
-    });
-    this.rows.push({ skip: false, data: tempObj });
+      tempObj[elem] = array[arrayCounter]
+      tempObj.toString = () => JSON.stringify(tempObj)
+      arrayCounter++
+    })
+    this.rows.push({ skip: false, data: tempObj })
   }
 
   /** @param {Array<*>} array */
   xadd(array) {
-    if (array.length !== this.array.length) throw new Error(`There is too many elements in given data array. Please provide data in this format: ${this.array}`);
-    const tempObj = {};
-    let arrayCounter = 0;
+    if (array.length !== this.array.length)
+      throw new Error(
+        `There is too many elements in given data array. Please provide data in this format: ${this.array}`,
+      )
+    const tempObj = {}
+    let arrayCounter = 0
     this.array.forEach((elem) => {
-      tempObj[elem] = array[arrayCounter];
-      tempObj.toString = () => JSON.stringify(tempObj);
-      arrayCounter++;
-    });
-    this.rows.push({ skip: true, data: tempObj });
+      tempObj[elem] = array[arrayCounter]
+      tempObj.toString = () => JSON.stringify(tempObj)
+      arrayCounter++
+    })
+    this.rows.push({ skip: true, data: tempObj })
   }
 
   /** @param {Function} func */
   filter(func) {
-    return this.rows.filter(row => func(row.data));
+    return this.rows.filter((row) => func(row.data))
   }
 }
 
-export default DataTable;
+module.exports = DataTable

package/lib/event.js

@@ -1,176 +1,172 @@
-import debug from 'debug';
-
-import events from 'events';
-import * as output from './output.js';
-
-debug('codeceptjs:event');
+const debug = require('debug')('codeceptjs:event');
+const events = require('events');
+const { error } = require('./output');
 
 const dispatcher = new events.EventEmitter();
 
 dispatcher.setMaxListeners(50);
-
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'test.start'} started
- * @property {'test.before'} before
- * @property {'test.after'} after
- * @property {'test.passed'} passed
- * @property {'test.failed'} failed
- * @property {'test.finish'} finished
- * @property {'test.skipped'} skipped
- */
-export const test = {
-  started: 'test.start', // sync
-  before: 'test.before', // async
-  after: 'test.after', // async
-  passed: 'test.passed', // sync
-  failed: 'test.failed', // sync
-  finished: 'test.finish', // sync
-  skipped: 'test.skipped', // sync
-};
-
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'suite.before'} before
- * @property {'suite.after'} after
- */
-export const suite = {
-  before: 'suite.before',
-  after: 'suite.after',
-};
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'hook.start'} started
- * @property {'hook.passed'} passed
- */
-export const hook = {
-  started: 'hook.start',
-  passed: 'hook.passed',
-  failed: 'hook.failed',
-};
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'step.start'} started
- * @property {'step.before'} before
- * @property {'step.after'} after
- * @property {'step.passed'} passed
- * @property {'step.failed'} failed
- * @property {'step.finish'} finished
- * @property {'step.comment'} comment
- */
-export const step = {
-  before: 'step.before', // async
-  after: 'step.after', // async
-  started: 'step.start', // sync
-  passed: 'step.passed', // sync
-  failed: 'step.failed', // sync
-  finished: 'step.finish', // sync
-  comment: 'step.comment',
-};
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'suite.before'} before
- * @property {'suite.after'} after
- */
-export const bddStep = {
-  before: 'bddStep.before',
-  after: 'bddStep.after',
-  started: 'bddStep.started',
-  finished: 'bddStep.finished',
-};
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'global.before'} before
- * @property {'global.after'} after
- * @property {'global.result'} result
- * @property {'global.failures'} failures
- */
-export const all = {
-  before: 'global.before',
-  after: 'global.after',
-  result: 'global.result',
-  failures: 'global.failures',
-};
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'multiple.before'} before
- * @property {'multiple.after'} after
- */
-export const multiple = {
-  before: 'multiple.before',
-  after: 'multiple.after',
-};
-
-/**
- * @type {object}
- * @constant
- * @inner
- * @property {'workers.before'} before
- * @property {'workers.after'} after
- * @property {'workers.result'} result
- */
-export const workers = {
-  before: 'workers.before',
-  after: 'workers.after',
-  result: 'workers.result',
-};
-
-/** for testing only! */
-export function cleanDispatcher() {
-  let event;
-  for (event in test) {
-    dispatcher.removeAllListeners(test[event]);
-  }
-  for (event in suite) {
-    dispatcher.removeAllListeners(test[event]);
-  }
-  for (event in step) {
-    dispatcher.removeAllListeners(test[event]);
-  }
-  for (event in all) {
-    dispatcher.removeAllListeners(test[event]);
-  }
-}
-
 /**
  * @namespace
  * @alias event
  */
-/**
- * @type {NodeJS.EventEmitter}
- * @constant
- * @inner
- */
-export { dispatcher };
+module.exports = {
+  /**
+   * @type {NodeJS.EventEmitter}
+   * @constant
+   * @inner
+   */
+  dispatcher,
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'test.start'} started
+   * @property {'test.before'} before
+   * @property {'test.after'} after
+   * @property {'test.passed'} passed
+   * @property {'test.failed'} failed
+   * @property {'test.finish'} finished
+   * @property {'test.skipped'} skipped
+   */
+  test: {
+    started: 'test.start', // sync
+    before: 'test.before', // async
+    after: 'test.after', // async
+    passed: 'test.passed', // sync
+    failed: 'test.failed', // sync
+    finished: 'test.finish', // sync
+    skipped: 'test.skipped', // sync
+  },
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'suite.before'} before
+   * @property {'suite.after'} after
+   */
+  suite: {
+    before: 'suite.before',
+    after: 'suite.after',
+  },
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'hook.start'} started
+   * @property {'hook.passed'} passed
+   */
+  hook: {
+    started: 'hook.start',
+    passed: 'hook.passed',
+    failed: 'hook.failed',
+  },
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'step.start'} started
+   * @property {'step.before'} before
+   * @property {'step.after'} after
+   * @property {'step.passed'} passed
+   * @property {'step.failed'} failed
+   * @property {'step.finish'} finished
+   * @property {'step.comment'} comment
+   */
+  step: {
+    before: 'step.before', // async
+    after: 'step.after', // async
+    started: 'step.start', // sync
+    passed: 'step.passed', // sync
+    failed: 'step.failed', // sync
+    finished: 'step.finish', // sync
+    comment: 'step.comment',
+  },
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'suite.before'} before
+   * @property {'suite.after'} after
+   */
+  bddStep: {
+    before: 'bddStep.before',
+    after: 'bddStep.after',
+    started: 'bddStep.started',
+    finished: 'bddStep.finished',
+  },
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'global.before'} before
+   * @property {'global.after'} after
+   * @property {'global.result'} result
+   * @property {'global.failures'} failures
+   */
+  all: {
+    before: 'global.before',
+    after: 'global.after',
+    result: 'global.result',
+    failures: 'global.failures',
+  },
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'multiple.before'} before
+   * @property {'multiple.after'} after
+   */
+  multiple: {
+    before: 'multiple.before',
+    after: 'multiple.after',
+  },
 
-/**
- * @param {string} event
- * @param {*} [param]
- */
-export function emit(event, param) {
-  let msg = `Emitted | ${event}`;
-  if (param && param.toString()) {
-    msg += ` (${param.toString()})`;
-  }
-  output.output.debug(msg);
-  try {
-    dispatcher.emit.apply(dispatcher, arguments);
-  } catch (err) {
-    output.output.error(`Error processing ${event} event:`);
-    output.output.error(err.stack);
-  }
-}
+  /**
+   * @type {object}
+   * @constant
+   * @inner
+   * @property {'workers.before'} before
+   * @property {'workers.after'} after
+   * @property {'workers.result'} result
+   */
+  workers: {
+    before: 'workers.before',
+    after: 'workers.after',
+    result: 'workers.result',
+  },
+
+  /**
+   * @param {string} event
+   * @param {*} [param]
+   */
+  emit(event, param) {
+    let msg = `Emitted | ${event}`;
+    if (param && param.toString()) {
+      msg += ` (${param.toString()})`;
+    }
+    debug(msg);
+    try {
+      this.dispatcher.emit.apply(this.dispatcher, arguments);
+    } catch (err) {
+      error(`Error processing ${event} event:`);
+      error(err.stack);
+    }
+  },
+
+  /** for testing only! */
+  cleanDispatcher: () => {
+    let event;
+    for (event in this.test) {
+      this.dispatcher.removeAllListeners(this.test[event]);
+    }
+    for (event in this.suite) {
+      this.dispatcher.removeAllListeners(this.test[event]);
+    }
+    for (event in this.step) {
+      this.dispatcher.removeAllListeners(this.test[event]);
+    }
+    for (event in this.all) {
+      this.dispatcher.removeAllListeners(this.test[event]);
+    }
+  },
+};

package/lib/heal.js

@@ -1,13 +1,9 @@
-import debug from 'debug';
-import colors from 'chalk';
-import Container from './container.js';
-import recorder from './recorder.js';
-import * as event from './event.js';
-import { output } from './output.js';
-
-const logger = debug('myapp:server');
-
-logger('codeceptjs:heal');
+const debug = require('debug')('codeceptjs:heal');
+const colors = require('chalk');
+const Container = require('./container');
+const recorder = require('./recorder');
+const output = require('./output');
+const event = require('./event');
 
 /**
  * @class
@@ -61,7 +57,7 @@ class Heal {
     const suggestions = [];
     const recipes = matchRecipes(this.recipes, this.contextName);
 
-    logger('Recipes', recipes);
+    debug('Recipes', recipes);
 
     const currentOutputLevel = output.level();
     output.level(0);
@@ -100,24 +96,24 @@ class Heal {
     const suggestions = await this.getCodeSuggestions(failureContext);
 
     if (suggestions.length === 0) {
-      logger('No healing suggestions found');
+      debug('No healing suggestions found');
       throw error;
     }
 
     output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`);
 
-    logger(suggestions);
+    debug(suggestions);
 
     for (const suggestion of suggestions) {
       for (const codeSnippet of suggestion.snippets) {
         try {
-          logger('Executing', codeSnippet);
+          debug('Executing', codeSnippet);
           recorder.catch((e) => {
-            logger(e);
+            debug(e);
           });
 
           if (typeof codeSnippet === 'string') {
-            const I = Container.support('I'); // eslint-disable-line
+            const I = Container.support('I');
             await eval(codeSnippet); // eslint-disable-line
           } else if (typeof codeSnippet === 'function') {
             await codeSnippet(Container.support());
@@ -135,7 +131,7 @@ class Heal {
           // recorder.session.restore();
           return;
         } catch (err) {
-          logger('Failed to execute code', err);
+          debug('Failed to execute code', err);
           recorder.ignoreErr(err); // healing did not help
           recorder.catchWithoutStop(err);
           await recorder.promise(); // wait for all promises to resolve
@@ -153,7 +149,7 @@ class Heal {
 
 const heal = new Heal();
 
-export { heal };
+module.exports = heal;
 
 function matchRecipes(recipes, contextName) {
   return Object.entries(recipes)