codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/data/table.js

@@ -4,46 +4,40 @@
 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));
   }
 }
 
-module.exports = DataTable
+export default DataTable;

package/lib/dirname.js

@@ -0,0 +1,5 @@
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+export const __dirname = dirname(__filename);

package/lib/event.js

@@ -1,172 +1,176 @@
-const debug = require('debug')('codeceptjs:event');
-const events = require('events');
-const { error } = require('./output');
+import debug from 'debug';
+
+import events from 'events';
+import * as output from './output.js';
+
+debug('codeceptjs:event');
 
 const dispatcher = new events.EventEmitter();
 
 dispatcher.setMaxListeners(50);
+
 /**
- * @namespace
- * @alias event
+ * @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
  */
-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',
-  },
-
-  /**
-   * @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',
-  },
+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
+};
 
-  /**
-   * @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);
-    }
-  },
+/**
+ * @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',
+};
 
-  /** 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]);
-    }
-  },
+/**
+ * @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 };
+
+/**
+ * @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);
+  }
+}

package/lib/heal.js

@@ -1,9 +1,13 @@
-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');
+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');
 
 /**
  * @class
@@ -57,7 +61,7 @@ class Heal {
     const suggestions = [];
     const recipes = matchRecipes(this.recipes, this.contextName);
 
-    debug('Recipes', recipes);
+    logger('Recipes', recipes);
 
     const currentOutputLevel = output.level();
     output.level(0);
@@ -96,20 +100,20 @@ class Heal {
     const suggestions = await this.getCodeSuggestions(failureContext);
 
     if (suggestions.length === 0) {
-      debug('No healing suggestions found');
+      logger('No healing suggestions found');
       throw error;
     }
 
     output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`);
 
-    debug(suggestions);
+    logger(suggestions);
 
     for (const suggestion of suggestions) {
       for (const codeSnippet of suggestion.snippets) {
         try {
-          debug('Executing', codeSnippet);
+          logger('Executing', codeSnippet);
           recorder.catch((e) => {
-            debug(e);
+            logger(e);
           });
 
           if (typeof codeSnippet === 'string') {
@@ -131,7 +135,7 @@ class Heal {
           // recorder.session.restore();
           return;
         } catch (err) {
-          debug('Failed to execute code', err);
+          logger('Failed to execute code', err);
           recorder.ignoreErr(err); // healing did not help
           recorder.catchWithoutStop(err);
           await recorder.promise(); // wait for all promises to resolve
@@ -149,7 +153,7 @@ class Heal {
 
 const heal = new Heal();
 
-module.exports = heal;
+export { heal };
 
 function matchRecipes(recipes, contextName) {
   return Object.entries(recipes)