codeceptjs 3.7.6-beta.4 → 4.0.0-beta.10.esm-aria

package/lib/assert/equal.js

@@ -1,7 +1,7 @@
-const Assertion = require('../assert')
-const AssertionFailedError = require('./error')
-const { template } = require('../utils')
-const output = require('../output')
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
 class EqualityAssertion extends Assertion {
   constructor(params) {
@@ -37,18 +37,16 @@ class EqualityAssertion extends Assertion {
   }
 }
 
-module.exports = {
-  Assertion: EqualityAssertion,
-  equals: jar => new EqualityAssertion({ jar }),
-  urlEquals: baseUrl => {
-    const assert = new EqualityAssertion({ jar: 'url of current page' })
-    assert.comparator = function (expected, actual) {
-      if (expected.indexOf('http') !== 0) {
-        actual = actual.slice(actual.indexOf(baseUrl) + baseUrl.length)
-      }
-      return actual === expected
+export { EqualityAssertion as Assertion }
+export const equals = jar => new EqualityAssertion({ jar })
+export const urlEquals = baseUrl => {
+  const assert = new EqualityAssertion({ jar: 'url of current page' })
+  assert.comparator = function (expected, actual) {
+    if (expected.indexOf('http') !== 0) {
+      actual = actual.slice(actual.indexOf(baseUrl) + baseUrl.length)
     }
-    return assert
-  },
-  fileEquals: file => new EqualityAssertion({ file, jar: 'contents of {{file}}' }),
+    return actual === expected
+  }
+  return assert
 }
+export const fileEquals = file => new EqualityAssertion({ file, jar: 'contents of {{file}}' })

package/lib/assert/error.js

@@ -1,4 +1,4 @@
-const subs = require('../utils').template
+import { template as subs } from '../utils.js'
 
 /**
  * Assertion errors, can provide a detailed error messages.
@@ -29,4 +29,4 @@ function AssertionFailedError(params, template) {
 AssertionFailedError.prototype = Object.create(Error.prototype)
 AssertionFailedError.constructor = AssertionFailedError
 
-module.exports = AssertionFailedError
+export default AssertionFailedError

package/lib/assert/include.js

@@ -1,7 +1,7 @@
-const Assertion = require('../assert')
-const AssertionFailedError = require('./error')
-const { template } = require('../utils')
-const output = require('../output')
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
 const MAX_LINES = 10
 
@@ -62,14 +62,12 @@ class InclusionAssertion extends Assertion {
   }
 }
 
-module.exports = {
-  Assertion: InclusionAssertion,
-  includes: needleType => {
-    needleType = needleType || 'string'
-    return new InclusionAssertion({ jar: needleType })
-  },
-  fileIncludes: file => new InclusionAssertion({ file, jar: 'file {{file}}' }),
+export { InclusionAssertion as Assertion }
+export const includes = needleType => {
+  needleType = needleType || 'string'
+  return new InclusionAssertion({ jar: needleType })
 }
+export const fileIncludes = file => new InclusionAssertion({ file, jar: 'file {{file}}' })
 
 function escapeRegExp(str) {
   return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&')

package/lib/assert/throws.js

@@ -17,4 +17,4 @@ function errorThrown(actual, expected) {
   return null
 }
 
-module.exports = errorThrown
+export default errorThrown

package/lib/assert/truth.js

@@ -1,7 +1,7 @@
-const Assertion = require('../assert')
-const AssertionFailedError = require('./error')
-const { template } = require('../utils')
-const output = require('../output')
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
 class TruthAssertion extends Assertion {
   constructor(params) {
@@ -30,7 +30,10 @@ class TruthAssertion extends Assertion {
   }
 }
 
-module.exports = {
+export { TruthAssertion as Assertion }
+export const truth = (subject, type) => new TruthAssertion({ subject, type })
+
+export default {
   Assertion: TruthAssertion,
   truth: (subject, type) => new TruthAssertion({ subject, type }),
 }

package/lib/assert.js

@@ -1,4 +1,4 @@
-const AssertionFailedError = require('./assert/error');
+import AssertionFailedError from './assert/error.js'
 
 /**
  * Abstract assertion class introduced for more verbose and customizable messages.
@@ -22,9 +22,9 @@ const AssertionFailedError = require('./assert/error');
  */
 class Assertion {
   constructor(comparator, params) {
-    this.comparator = comparator;
-    this.params = params || {};
-    this.params.customMessage = '';
+    this.comparator = comparator
+    this.params = params || {}
+    this.params.customMessage = ''
   }
 
   /**
@@ -32,10 +32,10 @@ class Assertion {
    * Fails if comparator function with provided arguments returns false
    */
   assert() {
-    this.addAssertParams.apply(this, arguments);
-    const result = this.comparator.apply(this.params, arguments);
-    if (result) return; // should increase global assertion counter
-    throw this.getFailedAssertion();
+    this.addAssertParams.apply(this, arguments)
+    const result = this.comparator.apply(this.params, arguments)
+    if (result) return // should increase global assertion counter
+    throw this.getFailedAssertion()
   }
 
   /**
@@ -43,10 +43,10 @@ class Assertion {
    * Fails if comparator function with provided arguments returns true
    */
   negate() {
-    this.addAssertParams.apply(this, arguments);
-    const result = this.comparator.apply(this.params, arguments);
-    if (!result) return; // should increase global assertion counter
-    throw this.getFailedNegation();
+    this.addAssertParams.apply(this, arguments)
+    const result = this.comparator.apply(this.params, arguments)
+    if (!result) return // should increase global assertion counter
+    throw this.getFailedNegation()
   }
 
   /**
@@ -55,18 +55,18 @@ class Assertion {
   addAssertParams() {}
 
   getException() {
-    return new AssertionFailedError(this.params, '');
+    return new AssertionFailedError(this.params, '')
   }
 
   getFailedNegation() {
-    const err = this.getException();
-    err.params.type = `not ${err.params.type}`;
-    return err;
+    const err = this.getException()
+    err.params.type = `not ${err.params.type}`
+    return err
   }
 
   getFailedAssertion() {
-    return this.getException();
+    return this.getException()
   }
 }
 
-module.exports = Assertion;
+export default Assertion

package/lib/codecept.js

@@ -1,15 +1,34 @@
-const { existsSync, readFileSync } = require('fs')
-const { globSync } = require('glob')
-const shuffle = require('lodash.shuffle')
-const fsPath = require('path')
-const { resolve } = require('path')
-
-const container = require('./container')
-const Config = require('./config')
-const event = require('./event')
-const runHook = require('./hooks')
-const output = require('./output')
-const { emptyFolder } = require('./utils')
+import { existsSync, readFileSync } from 'fs'
+import { globSync } from 'glob'
+import shuffle from 'lodash.shuffle'
+import fsPath from 'path'
+import { resolve } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+import Helper from '@codeceptjs/helper'
+import container from './container.js'
+import Config from './config.js'
+import event from './event.js'
+import runHook from './hooks.js'
+import ActorFactory from './actor.js'
+import output from './output.js'
+import { emptyFolder } from './utils.js'
+import { initCodeceptGlobals } from './globals.js'
+import recorder from './recorder.js'
+
+import storeListener from './listener/store.js'
+import stepsListener from './listener/steps.js'
+import configListener from './listener/config.js'
+import resultListener from './listener/result.js'
+import helpersListener from './listener/helpers.js'
+import globalTimeoutListener from './listener/globalTimeout.js'
+import globalRetryListener from './listener/globalRetry.js'
+import exitListener from './listener/exit.js'
+import emptyRunListener from './listener/emptyRun.js'
 
 /**
  * CodeceptJS runner
@@ -26,7 +45,7 @@ class Codecept {
     this.config = Config.create(config)
     this.opts = opts
     this.testFiles = new Array(0)
-    this.requireModules(config.require)
+    this.requiringModules = config.require
   }
 
   /**
@@ -34,29 +53,41 @@ class Codecept {
    *
    * @param {string[]} requiringModules
    */
-  requireModules(requiringModules) {
+  async requireModules(requiringModules) {
     if (requiringModules) {
-      requiringModules.forEach(requiredModule => {
-        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`)
+      for (const requiredModule of requiringModules) {
+        let modulePath = requiredModule
+        const isLocalFile = existsSync(modulePath) || existsSync(`${modulePath}.js`)
         if (isLocalFile) {
-          requiredModule = resolve(requiredModule)
+          modulePath = resolve(modulePath)
+          // For ESM, ensure .js extension for local files
+          if (!modulePath.endsWith('.js') && !modulePath.endsWith('.mjs') && !modulePath.endsWith('.cjs')) {
+            if (existsSync(`${modulePath}.js`)) {
+              modulePath = `${modulePath}.js`
+            }
+          }
         }
-        require(requiredModule)
-      })
+        // Use dynamic import for ESM
+        await import(modulePath)
+      }
     }
   }
 
   /**
-   * Initialize CodeceptJS at specific directory.
-   * If async initialization is required, pass callback as second parameter.
+   * Initialize CodeceptJS at specific dir.
+   * Loads config, requires factory methods
    *
    * @param {string} dir
    */
-  init(dir) {
-    this.initGlobals(dir)
+  async init(dir) {
+    await this.initGlobals(dir)
+    // Require modules before initializing
+    await this.requireModules(this.requiringModules)
     // initializing listeners
-    container.create(this.config, this.opts)
-    this.runHooks()
+    await container.create(this.config, this.opts)
+    // Store container globally for easy access
+    global.container = container
+    await this.runHooks()
   }
 
   /**
@@ -64,56 +95,32 @@ class Codecept {
    *
    * @param {string} dir
    */
-  initGlobals(dir) {
-    global.codecept_dir = dir
-    global.output_dir = fsPath.resolve(dir, this.config.output)
-
-    if (this.config.emptyOutputFolder) emptyFolder(global.output_dir)
-
-    if (!this.config.noGlobals) {
-      global.Helper = global.codecept_helper = require('@codeceptjs/helper')
-      global.actor = global.codecept_actor = require('./actor')
-      global.pause = require('./pause')
-      global.within = require('./within')
-      global.session = require('./session')
-      global.DataTable = require('./data/table')
-      global.locate = locator => require('./locator').build(locator)
-      global.inject = container.support
-      global.share = container.share
-      global.secret = require('./secret').secret
-      global.codecept_debug = output.debug
-      global.codeceptjs = require('./index') // load all objects
-
-      // BDD
-      const stepDefinitions = require('./mocha/bdd')
-      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 = this.config.maskSensitiveData || false
-    }
+  async initGlobals(dir) {
+    await initCodeceptGlobals(dir, this.config, container)
   }
 
   /**
    * Executes hooks.
    */
-  runHooks() {
-    // default hooks
-    runHook(require('./listener/store'))
-    runHook(require('./listener/steps'))
-    runHook(require('./listener/config'))
-    runHook(require('./listener/result'))
-    runHook(require('./listener/helpers'))
-    runHook(require('./listener/globalTimeout'))
-    runHook(require('./listener/globalRetry'))
-    runHook(require('./listener/retryEnhancer'))
-    runHook(require('./listener/exit'))
-    runHook(require('./listener/emptyRun'))
+  async runHooks() {
+    // default hooks - dynamic imports for ESM
+    const listenerModules = [
+      './listener/store.js',
+      './listener/steps.js',
+      './listener/config.js',
+      './listener/result.js',
+      './listener/helpers.js',
+      './listener/globalTimeout.js',
+      './listener/globalRetry.js',
+      './listener/retryEnhancer.js',
+      './listener/exit.js',
+      './listener/emptyRun.js',
+    ]
+
+    for (const modulePath of listenerModules) {
+      const module = await import(modulePath)
+      runHook(module.default || module)
+    }
 
     // custom hooks (previous iteration of plugins)
     this.config.hooks.forEach(hook => runHook(hook))
@@ -160,7 +167,7 @@ class Codecept {
         }
       }
 
-      if (this.config.gherkin.features && !this.opts.tests) {
+      if (this.config.gherkin && this.config.gherkin.features && !this.opts.tests) {
         if (Array.isArray(this.config.gherkin.features)) {
           this.config.gherkin.features.forEach(feature => {
             patterns.push(feature)
@@ -239,24 +246,44 @@ class Codecept {
   async run(test) {
     await container.started()
 
+    // Ensure translations are loaded for Gherkin features
+    try {
+      const { loadTranslations } = await import('./mocha/gherkin.js')
+      await loadTranslations()
+    } catch (e) {
+      // Ignore if gherkin module not available
+    }
+
     return new Promise((resolve, reject) => {
       const mocha = container.mocha()
       mocha.files = this.testFiles
+
       if (test) {
         if (!fsPath.isAbsolute(test)) {
           test = fsPath.join(global.codecept_dir, test)
         }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test)
+        const testBasename = fsPath.basename(test, '.js')
+        const testFeatureBasename = fsPath.basename(test, '.feature')
+        mocha.files = mocha.files.filter(t => {
+          return fsPath.basename(t, '.js') === testBasename || fsPath.basename(t, '.feature') === testFeatureBasename || t === test
+        })
       }
-      const done = () => {
+
+      const done = async (failures) => {
         event.emit(event.all.result, container.result())
         event.emit(event.all.after, this)
+        // Wait for any recorder tasks added by event.all.after handlers
+        await recorder.promise()
+        // Set exit code based on test failures
+        if (failures) {
+          process.exitCode = 1
+        }
         resolve()
       }
 
       try {
         event.emit(event.all.before, this)
-        mocha.run(() => done())
+        mocha.run(async (failures) => await done(failures))
       } catch (e) {
         output.error(e.stack)
         reject(e)
@@ -274,4 +301,4 @@ class Codecept {
   }
 }
 
-module.exports = Codecept
+export default Codecept

package/lib/colorUtils.js

@@ -144,14 +144,14 @@ function convertColorNameToHex(color) {
     whitesmoke: '#f5f5f5',
     yellow: '#ffff00',
     yellowgreen: '#9acd32',
-  };
+  }
 
-  const cColor = `${color}`.toLowerCase();
+  const cColor = `${color}`.toLowerCase()
   if (typeof colors[cColor] !== 'undefined') {
-    return colors[cColor];
+    return colors[cColor]
   }
 
-  return color;
+  return color
 }
 
 /**
@@ -160,23 +160,23 @@ function convertColorNameToHex(color) {
  */
 function convertHexColorToRgba(hex) {
   // Expand shorthand form (e.g. "#03F") to full form (e.g. "#0033FF")
-  const shorthandRegex = /^#([a-f\d])([a-f\d])([a-f\d])$/i;
+  const shorthandRegex = /^#([a-f\d])([a-f\d])([a-f\d])$/i
   const hexFull = `${hex}`.replace(shorthandRegex, (m, r, g, b) => {
-    return r + r + g + g + b + b;
-  });
+    return r + r + g + g + b + b
+  })
 
-  const result = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexFull);
+  const result = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexFull)
   if (!result) {
     // Return untouched if not a hex code
-    return hex;
+    return hex
   }
 
-  const r = parseInt(result[1], 16);
-  const g = parseInt(result[2], 16);
-  const b = parseInt(result[3], 16);
-  const a = 1;
+  const r = parseInt(result[1], 16)
+  const g = parseInt(result[2], 16)
+  const b = parseInt(result[3], 16)
+  const a = 1
 
-  return `rgba(${r}, ${g}, ${b}, ${a})`;
+  return `rgba(${r}, ${g}, ${b}, ${a})`
 }
 
 /**
@@ -190,29 +190,29 @@ function convertHexColorToRgba(hex) {
  * @param {string} color Color as a string, i.e. rgb(85,0,0)
  */
 function convertColorToRGBA(color) {
-  const cstr = `${color}`.toLowerCase().trim() || '';
+  const cstr = `${color}`.toLowerCase().trim() || ''
 
   if (!/^rgba?\(.+?\)$/.test(cstr)) {
     // Convert both color names and hex colors to rgba
-    const hexColor = convertColorNameToHex(color);
-    return convertHexColorToRgba(hexColor);
+    const hexColor = convertColorNameToHex(color)
+    return convertHexColorToRgba(hexColor)
   }
 
   // Convert rgb to rgba
-  const channels = cstr.match(/([\-0-9.]+)/g) || [];
+  const channels = cstr.match(/([\-0-9.]+)/g) || []
 
   switch (channels.length) {
     case 3:
       // Convert rgb to rgba
-      return `rgba(${channels.join(', ')}, 1)`;
+      return `rgba(${channels.join(', ')}, 1)`
 
     case 4:
       // Format rgba
-      return `rgba(${channels.join(', ')})`;
+      return `rgba(${channels.join(', ')})`
 
     default:
       // Unexpected color format. Leave it untouched (let the user handle it)
-      return color;
+      return color
   }
 }
 
@@ -222,34 +222,32 @@ function convertColorToRGBA(color) {
  * @param {string} prop CSS Property name
  */
 function isColorProperty(prop) {
-  return [
-    'color',
-    'background',
-    'backgroundColor',
-    'background-color',
-    'borderColor',
-    'border-color',
-    'borderBottomColor',
-    'border-bottom-color',
-    'borderLeftColor',
-    'border-left-color',
-    'borderRightColor',
-    'borderTopColor',
-    'caretColor',
-    'columnRuleColor',
-    'outlineColor',
-    'textDecorationColor',
-    'border-right-color',
-    'border-top-color',
-    'caret-color',
-    'column-rule-color',
-    'outline-color',
-    'text-decoration-color',
-  ].indexOf(prop) > -1;
+  return (
+    [
+      'color',
+      'background',
+      'backgroundColor',
+      'background-color',
+      'borderColor',
+      'border-color',
+      'borderBottomColor',
+      'border-bottom-color',
+      'borderLeftColor',
+      'border-left-color',
+      'borderRightColor',
+      'borderTopColor',
+      'caretColor',
+      'columnRuleColor',
+      'outlineColor',
+      'textDecorationColor',
+      'border-right-color',
+      'border-top-color',
+      'caret-color',
+      'column-rule-color',
+      'outline-color',
+      'text-decoration-color',
+    ].indexOf(prop) > -1
+  )
 }
 
-module.exports = {
-  isColorProperty,
-  convertColorToRGBA,
-  convertColorNameToHex,
-};
+export { isColorProperty, convertColorToRGBA, convertColorNameToHex }