event.js

import debugModule from 'debug'
const debug = debugModule('codeceptjs:event')
import events from 'events'
import output from './output.js'
import { realmSingleton } from './realm.js'

const MAX_LISTENERS = 200

// Shared across realms so listeners registered from a test (CJS realm, via
// `import { event } from "codeceptjs"`) and events emitted by the runner (ESM realm)
// reach the same EventEmitter. Without this the test subscribes to a dead dispatcher.
const dispatcher = realmSingleton('__codeceptjs_dispatcher', () => {
  const d = new events.EventEmitter()
  d.setMaxListeners(MAX_LISTENERS)
  return d
})

// Increase process max listeners to prevent warnings for beforeExit and other events
if (typeof process.setMaxListeners === 'function') {
  process.setMaxListeners(MAX_LISTENERS)
}

/**
 * @namespace
 * @alias event
 */

export default {
  /**
   * @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
   * @property {'hook.failed'} failed
   * @property {'hook.finished'} finished
   */
  hook: {
    started: 'hook.start',
    passed: 'hook.passed',
    failed: 'hook.failed',
    finished: 'hook.finished',
  },

  /**
   * @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',
  },

  /**
   * @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) {
      output.error(`Error processing ${event} event:`)
      output.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.suite[event])
    }
    for (event in this.step) {
      this.dispatcher.removeAllListeners(this.step[event])
    }
    for (event in this.all) {
      this.dispatcher.removeAllListeners(this.all[event])
    }
  },
}