codeceptjs 4.0.0-beta.1 → 4.0.0-beta.10.esm-aria

package/lib/els.js

@@ -0,0 +1,160 @@
+import output from './output.js'
+import store from './store.js'
+import container from './container.js'
+import StepConfig from './step/config.js'
+import recordStep from './step/record.js'
+import FuncStep from './step/func.js'
+import { truth } from './assert/truth.js'
+import { isAsyncFunction, humanizeFunction } from './utils.js'
+
+function element(purpose, locator, fn) {
+  let stepConfig
+  if (arguments[arguments.length - 1] instanceof StepConfig) {
+    stepConfig = arguments[arguments.length - 1]
+  }
+
+  if (!fn || fn === stepConfig) {
+    fn = locator
+    locator = purpose
+    purpose = 'first element'
+  }
+
+  const step = prepareStep(purpose, locator, fn)
+  if (!step) return
+
+  return executeStep(
+    step,
+    async () => {
+      const els = await step.helper._locate(locator)
+      output.debug(`Found ${els.length} elements, using first element`)
+
+      return fn(els[0])
+    },
+    stepConfig,
+  )
+}
+
+function eachElement(purpose, locator, fn) {
+  if (!fn) {
+    fn = locator
+    locator = purpose
+    purpose = 'for each element'
+  }
+
+  const step = prepareStep(purpose, locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements for each elements to iterate`)
+
+    const errs = []
+    let i = 0
+    for (const el of els) {
+      try {
+        await fn(el, i)
+      } catch (err) {
+        output.error(`eachElement: failed operation on element #${i} ${el}`)
+        errs.push(err)
+      }
+      i++
+    }
+
+    if (errs.length) {
+      throw errs[0]
+    }
+  })
+}
+
+function expectElement(locator, fn) {
+  const step = prepareStep('expect element to be', locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, first will be used for assertion`)
+
+    const result = await fn(els[0])
+    const assertion = truth(`element (${locator})`, fn.toString())
+    assertion.assert(result)
+  })
+}
+
+function expectAnyElement(locator, fn) {
+  const step = prepareStep('expect any element to be', locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, at least one should pass the assertion`)
+
+    const assertion = truth(`any element of (${locator})`, fn.toString())
+
+    let found = false
+    for (const el of els) {
+      const result = await fn(el)
+      if (result) {
+        found = true
+        break
+      }
+    }
+    if (!found) throw assertion.getException()
+  })
+}
+
+function expectAllElements(locator, fn) {
+  const step = prepareStep('expect all elements', locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, all should pass the assertion`)
+
+    let i = 1
+    for (const el of els) {
+      output.debug(`checking element #${i}: ${el}`)
+      const result = await fn(el)
+      const assertion = truth(`element #${i} of (${locator})`, humanizeFunction(fn))
+      assertion.assert(result)
+      i++
+    }
+  })
+}
+
+export { element, eachElement, expectElement, expectAnyElement, expectAllElements }
+
+export default {
+  element,
+  eachElement,
+  expectElement,
+  expectAnyElement,
+  expectAllElements,
+}
+
+function prepareStep(purpose, locator, fn) {
+  if (store.dryRun) return
+  const helpers = Object.values(container.helpers())
+
+  const helper = helpers.filter(h => !!h._locate)[0]
+
+  if (!helper) {
+    throw new Error('No helper enabled with _locate method with returns a list of elements.')
+  }
+
+  if (!isAsyncFunction(fn)) {
+    throw new Error('Async function should be passed into each element')
+  }
+
+  const isAssertion = purpose.startsWith('expect')
+
+  const step = new FuncStep(`${purpose} within "${locator}" ${isAssertion ? 'to be' : 'to'}`)
+  step.setHelper(helper)
+  step.setArguments([humanizeFunction(fn)]) // user defined function is a passed argument
+
+  return step
+}
+
+async function executeStep(step, action, stepConfig = {}) {
+  step.setCallable(action)
+  return recordStep(step, [stepConfig])
+}

package/lib/event.js

@@ -1,176 +1,186 @@
-import debug from 'debug';
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:event')
+import events from 'events'
+import output from './output.js'
 
-import events from 'events';
-import * as output from './output.js';
+const MAX_LISTENERS = 200
 
-debug('codeceptjs:event');
+const dispatcher = new events.EventEmitter()
 
-const dispatcher = new events.EventEmitter();
+dispatcher.setMaxListeners(MAX_LISTENERS)
 
-dispatcher.setMaxListeners(50);
+// Increase process max listeners to prevent warnings for beforeExit and other events
+if (typeof process.setMaxListeners === 'function') {
+  process.setMaxListeners(MAX_LISTENERS)
+}
 
 /**
- * @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
+ * @namespace
+ * @alias event
  */
-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',
-};
+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 {'workers.before'} before
- * @property {'workers.after'} after
- * @property {'workers.result'} result
- */
-export const workers = {
-  before: 'workers.before',
-  after: 'workers.after',
-  result: 'workers.result',
-};
+  /**
+   * @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',
+  },
 
-/** 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]);
-  }
-}
+  /**
+   * @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',
+  },
 
-/**
- * @namespace
- * @alias event
- */
-/**
- * @type {NodeJS.EventEmitter}
- * @constant
- * @inner
- */
-export { dispatcher };
+  /**
+   * @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)
+    }
+  },
 
-/**
- * @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);
-  }
+  /** 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])
+    }
+  },
 }

package/lib/globals.js

@@ -0,0 +1,141 @@
+/**
+ * Global variables initialization module
+ *
+ * Centralizes all global variable setup for CodeceptJS from codecept.js and mocha/ui.js
+ */
+
+import fsPath from 'path'
+import ActorFactory from './actor.js'
+import output from './output.js'
+import locator from './locator.js'
+
+/**
+ * Initialize CodeceptJS core globals
+ * Called from Codecept.initGlobals()
+ */
+export async function initCodeceptGlobals(dir, config, container) {
+  global.codecept_dir = dir
+  global.output_dir = fsPath.resolve(dir, config.output)
+
+  if (config.noGlobals) return;
+    // Set up actor global - will use container when available
+  global.actor = global.codecept_actor = (obj) => {
+    return ActorFactory(obj, global.container || container)
+  }
+  global.Actor = global.actor
+
+  // Use dynamic imports for modules to avoid circular dependencies
+  global.pause = async (...args) => {
+    const pauseModule = await import('./pause.js')
+    return (pauseModule.default || pauseModule)(...args)
+  }
+
+  global.within = async (...args) => {
+    return (await import('./effects.js')).within(...args)
+  }
+
+  global.session = async (...args) => {
+    const sessionModule = await import('./session.js')
+    return (sessionModule.default || sessionModule)(...args)
+  }
+
+  const dataTableModule = await import('./data/table.js')
+  global.DataTable = dataTableModule.default || dataTableModule
+
+  global.locate = locatorQuery => {
+    return locator.build(locatorQuery)
+  }
+
+  global.inject = () => container.support()
+  global.share = container.share
+
+  const secretModule = await import('./secret.js')
+  global.secret = secretModule.secret || (secretModule.default && secretModule.default.secret)
+
+  global.codecept_debug = output.debug
+
+  const codeceptjsModule = await import('./index.js') // load all objects
+  global.codeceptjs = codeceptjsModule.default || codeceptjsModule
+
+  // BDD step definitions
+  const stepDefinitionsModule = await import('./mocha/bdd.js')
+  const stepDefinitions = stepDefinitionsModule.default || stepDefinitionsModule
+  global.Given = stepDefinitions.Given
+  global.When = stepDefinitions.When
+  global.Then = stepDefinitions.Then
+  global.DefineParameterType = stepDefinitions.defineParameterType
+
+  // debug mode
+  global.debugMode = false
+
+  // mask sensitive data
+  global.maskSensitiveData = config.maskSensitiveData || false
+
+}
+
+/**
+ * Initialize Mocha test framework globals (Feature, Scenario, etc.)
+ * Called from mocha/ui.js pre-require event
+ */
+export function initMochaGlobals(context) {
+  // Mocha test framework globals
+  global.BeforeAll = context.BeforeAll
+  global.AfterAll = context.AfterAll
+  global.Feature = context.Feature
+  global.xFeature = context.xFeature
+  global.BeforeSuite = context.BeforeSuite
+  global.AfterSuite = context.AfterSuite
+  global.Background = context.Background
+  global.Before = context.Before
+  global.After = context.After
+  global.Scenario = context.Scenario
+  global.xScenario = context.xScenario
+}
+
+/**
+ * Clear all CodeceptJS globals (useful for testing/cleanup)
+ */
+export function clearGlobals() {
+  getGlobalNames().forEach(name => delete global[name]);
+}
+
+/**
+ * Get list of all CodeceptJS global variable names
+ */
+export function getGlobalNames() {
+  return [
+    'codecept_dir',
+    'output_dir',
+    'actor',
+    'codecept_actor',
+    'Actor',
+    'pause',
+    'within',
+    'session',
+    'DataTable',
+    'locate',
+    'inject',
+    'share',
+    'secret',
+    'codecept_debug',
+    'codeceptjs',
+    'Given',
+    'When',
+    'Then',
+    'DefineParameterType',
+    'debugMode',
+    'maskSensitiveData',
+    'BeforeAll',
+    'AfterAll',
+    'Feature',
+    'xFeature',
+    'BeforeSuite',
+    'AfterSuite',
+    'Background',
+    'Before',
+    'After',
+    'Scenario',
+    'xScenario',
+    'container'
+  ]
+}