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

package/lib/mocha/asyncWrapper.js

@@ -1,10 +1,10 @@
-const promiseRetry = require('promise-retry')
-const event = require('../event')
-const recorder = require('../recorder')
-const assertThrown = require('../assert/throws')
-const { ucfirst, isAsyncFunction } = require('../utils')
-const { getInjectedArguments } = require('./inject')
-const { fireHook } = require('./hooks')
+import promiseRetry from 'promise-retry'
+import event from '../event.js'
+import recorder from '../recorder.js'
+import assertThrown from '../assert/throws.js'
+import { ucfirst, isAsyncFunction } from '../utils.js'
+import { getInjectedArguments } from './inject.js'
+import { fireHook } from './hooks.js'
 
 const injectHook = function (inject, suite) {
   try {
@@ -43,7 +43,7 @@ function makeDoneCallableOnce(done) {
  * starts promise chain with recorder, performs before/after hooks
  * through event system.
  */
-module.exports.test = test => {
+export function test(test) {
   const testFn = test.fn
   if (!testFn) {
     return test
@@ -75,39 +75,35 @@ module.exports.test = test => {
       recorder.add(() => doneFn(err))
     })
 
-    if (isAsyncFunction(testFn)) {
-      event.emit(event.test.started, test)
-      testFn
-        .call(test, getInjectedArguments(testFn, test))
-        .then(() => {
-          recorder.add('fire test.passed', () => {
-            event.emit(event.test.passed, test)
-            event.emit(event.test.finished, test)
-          })
-          recorder.add('finish test', doneFn)
-        })
-        .catch(err => {
-          recorder.throw(err)
-        })
-        .finally(() => {
-          recorder.catch()
-        })
-      return
-    }
+    event.emit(event.test.started, test)
+
+    getInjectedArguments(testFn, test)
+      .then(args => {
+        // Start recorder to ensure any steps added within test function are executed
+        recorder.startUnlessRunning()
 
-    try {
-      event.emit(event.test.started, test)
-      testFn.call(test, getInjectedArguments(testFn, test))
-    } catch (err) {
-      recorder.throw(err)
-    } finally {
-      recorder.add('fire test.passed', () => {
-        event.emit(event.test.passed, test)
-        event.emit(event.test.finished, test)
+        // Execute test function
+        const result = testFn.call(test, args)
+
+        // Wait for all recorder steps to complete
+        if (result && result.then) {
+          return result.then(() => recorder.promise())
+        }
+        return recorder.promise()
+      })
+      .then(() => {
+        recorder.add('fire test.passed', () => {
+          event.emit(event.test.passed, test)
+          event.emit(event.test.finished, test)
+        })
+        recorder.add('finish test', doneFn)
+      })
+      .catch(err => {
+        recorder.throw(err)
+      })
+      .finally(() => {
+        recorder.catch()
       })
-      recorder.add('finish test', doneFn)
-      recorder.catch()
-    }
   }
   return test
 }
@@ -115,7 +111,7 @@ module.exports.test = test => {
 /**
  * Injects arguments to function from controller
  */
-module.exports.injected = function (fn, suite, hookName) {
+export function injected(fn, suite, hookName) {
   return function (done) {
     const doneFn = makeDoneCallableOnce(done)
     const errHandler = err => {
@@ -162,7 +158,8 @@ module.exports.injected = function (fn, suite, hookName) {
       async (retry, number) => {
         try {
           recorder.startUnlessRunning()
-          await fn.call(this, { ...getInjectedArguments(fn), suite, test: currentTest })
+          const injectedArgs = await getInjectedArguments(fn, null, suite)
+          await fn.call(this, { ...injectedArgs, suite, test: currentTest })
           await recorder.promise().catch(err => retry(err))
         } catch (err) {
           retry(err)
@@ -196,36 +193,82 @@ module.exports.injected = function (fn, suite, hookName) {
 /**
  * Starts promise chain, so helpers could enqueue their hooks
  */
-module.exports.setup = function (suite) {
-  const { enhanceMochaTest } = require('./test')
-  return injectHook(() => {
+export function setup(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
     recorder.startUnlessRunning()
-    event.emit(event.test.before, enhanceMochaTest(suite?.ctx?.currentTest))
-  }, suite)
+    import('./test.js').then(testModule => {
+      const { enhanceMochaTest } = testModule.default || testModule
+      event.emit(event.test.before, enhanceMochaTest(suite?.ctx?.currentTest))
+      recorder.add(() => doneFn())
+    })
+  }
 }
 
-module.exports.teardown = function (suite) {
-  const { enhanceMochaTest } = require('./test')
-  return injectHook(() => {
+export function teardown(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
     recorder.startUnlessRunning()
-    event.emit(event.test.after, enhanceMochaTest(suite?.ctx?.currentTest))
-  }, suite)
+    import('./test.js').then(testModule => {
+      const { enhanceMochaTest } = testModule.default || testModule
+      event.emit(event.test.after, enhanceMochaTest(suite?.ctx?.currentTest))
+      recorder.add(() => doneFn())
+    })
+  }
 }
 
-module.exports.suiteSetup = function (suite) {
-  const { enhanceMochaSuite } = require('./suite')
-  return injectHook(() => {
+export function suiteSetup(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
     recorder.startUnlessRunning()
-    event.emit(event.suite.before, enhanceMochaSuite(suite))
-  }, suite)
+
+    // Set up error handler for suite setup
+    recorder.errHandler(err => {
+      doneFn(err)
+    })
+
+    import('./suite.js')
+      .then(suiteModule => {
+        const { enhanceMochaSuite } = suiteModule.default || suiteModule
+        event.emit(event.suite.before, enhanceMochaSuite(suite))
+        recorder.add(() => doneFn())
+      })
+      .catch(err => {
+        doneFn(err)
+      })
+  }
 }
 
-module.exports.suiteTeardown = function (suite) {
-  const { enhanceMochaSuite } = require('./suite')
-  return injectHook(() => {
+export function suiteTeardown(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
     recorder.startUnlessRunning()
-    event.emit(event.suite.after, enhanceMochaSuite(suite))
-  }, suite)
+
+    // Set up error handler for suite teardown
+    recorder.errHandler(err => {
+      doneFn(err)
+    })
+
+    import('./suite.js')
+      .then(suiteModule => {
+        const { enhanceMochaSuite } = suiteModule.default || suiteModule
+        event.emit(event.suite.after, enhanceMochaSuite(suite))
+        recorder.add(() => doneFn())
+      })
+      .catch(err => {
+        doneFn(err)
+      })
+  }
 }
 
-module.exports.getInjectedArguments = getInjectedArguments
+export { getInjectedArguments }
+
+export default {
+  test,
+  injected,
+  setup,
+  teardown,
+  suiteSetup,
+  suiteTeardown,
+  getInjectedArguments,
+}

package/lib/mocha/bdd.js

@@ -1,27 +1,52 @@
-const { CucumberExpression, ParameterTypeRegistry, ParameterType } = require('@cucumber/cucumber-expressions')
-const Config = require('../config')
+import { CucumberExpression, ParameterTypeRegistry, ParameterType } from '@cucumber/cucumber-expressions'
+import event from '../event.js'
 
 let steps = {}
+let Config
 
 const STACK_POSITION = 2
 
+async function getConfig() {
+  if (!Config) {
+    const ConfigModule = await import('../config.js')
+    Config = ConfigModule.default || ConfigModule
+  }
+  return Config
+}
+
 /**
  * @param {*} step
  * @param {*} fn
  */
-const addStep = (step, fn) => {
-  const avoidDuplicateSteps = Config.get('gherkin', {}).avoidDuplicateSteps || false
-  const stack = new Error().stack
+// Current file being loaded for step tracking
+let currentStepFile = null
+
+export function setCurrentStepFile(filePath) {
+  currentStepFile = filePath
+}
+
+export function clearCurrentStepFile() {
+  currentStepFile = null
+}
+
+const addStep = async (step, fn) => {
+  const config = await getConfig()
+  const avoidDuplicateSteps = config.get('gherkin', {}).avoidDuplicateSteps || false
   if (avoidDuplicateSteps && steps[step]) {
     throw new Error(`Step '${step}' is already defined`)
   }
   steps[step] = fn
-  fn.line = stack && stack.split('\n')[STACK_POSITION]
-  if (fn.line) {
-    fn.line = fn.line
-      .trim()
-      .replace(/^at (.*?)\(/, '(')
-      .replace(codecept_dir, '.')
+
+  // Use the current step file context if available (fallback for old usage)
+  if (currentStepFile) {
+    let relativePath = currentStepFile
+
+    // Remove any leading './' and keep step_definitions/ path
+    relativePath = relativePath.replace(/^\.\//, '').replace(/^.*\/(?=step_definitions)/, '')
+
+    fn.line = `${relativePath}:3:1`
+  } else {
+    fn.line = 'unknown_file:1:1'
   }
 }
 
@@ -43,7 +68,7 @@ const matchStep = step => {
     const res = expression.match(step)
     if (res) {
       const fn = steps[stepName]
-      fn.params = res.map(arg => arg.getValue())
+      fn.params = res.map(arg => arg.getValue(null))
       return fn
     }
   }
@@ -69,7 +94,68 @@ const buildParameterType = ({ name, regexp, transformer, useForSnippets, preferF
   return new ParameterType(name, regexp, null, transformer, useForSnippets, preferForRegexpMatch)
 }
 
-module.exports = {
+// Create wrapper functions that capture the call context
+const createStepFunction = stepType => {
+  return (step, fn) => {
+    // Capture the stack trace at the point where Given/When/Then is called
+    const callStack = new Error().stack
+
+    // Find the caller (step definition file) in the stack
+    let callerInfo = 'unknown_file:1:1'
+    if (callStack) {
+      const stackLines = callStack.split('\n')
+      for (let i = 1; i < stackLines.length; i++) {
+        const line = stackLines[i]
+        if (line.includes('step_definitions') && (line.includes('.js') || line.includes('.mjs'))) {
+          // Extract file path and use line 3:1 as consistent reference (import line)
+          const match = line.match(/file:\/\/.*\/(step_definitions\/[^:]+):(\d+):(\d+)/)
+          if (match) {
+            callerInfo = `${match[1]}:3:1` // Use line 3:1 consistently (import line)
+            break
+          }
+        }
+      }
+    }
+
+    // Instead of using global currentStepFile, pass the caller info directly to addStep
+    return addStepWithCaller(step, fn, callerInfo)
+  }
+}
+
+// New function that accepts caller info directly
+const addStepWithCaller = async (step, fn, callerInfo) => {
+  const config = await getConfig()
+  const avoidDuplicateSteps = config.get('gherkin', {}).avoidDuplicateSteps || false
+  if (avoidDuplicateSteps && steps[step]) {
+    throw new Error(`Step '${step}' is already defined`)
+  }
+  steps[step] = fn
+
+  // Use the caller info passed directly
+  fn.line = callerInfo
+}
+
+const Given = createStepFunction('Given')
+const When = createStepFunction('When')
+const Then = createStepFunction('Then')
+const And = createStepFunction('And')
+
+// Before/After hooks for BDD - these are global event listeners
+const Before = fn => {
+  event.dispatcher.on(event.test.started, fn)
+}
+
+const After = fn => {
+  event.dispatcher.on(event.test.finished, fn)
+}
+
+const Fail = fn => {
+  event.dispatcher.on(event.test.failed, fn)
+}
+
+export { Given, When, Then, And, Before, After, Fail, matchStep, getSteps, clearSteps, defineParameterType }
+
+export default {
   Given: addStep,
   When: addStep,
   Then: addStep,

package/lib/mocha/cli.js

@@ -1,16 +1,34 @@
-const {
-  reporters: { Base },
-} = require('mocha')
-const ms = require('ms')
-const figures = require('figures')
-const event = require('../event')
-const AssertionFailedError = require('../assert/error')
-const output = require('../output')
-const { cloneTest } = require('./test')
+import mocha from 'mocha'
+const { reporters: { Base } } = mocha
+import ms from 'ms'
+import figures from 'figures'
+import { readFileSync } from 'fs'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import event from '../event.js'
+import AssertionFailedError from '../assert/error.js'
+import output from '../output.js'
+import test, { cloneTest } from './test.js'
+
+// Get version from package.json to avoid circular dependency
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const packagePath = join(__dirname, '../../package.json')
+const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'))
+const codeceptVersion = packageJson.version
 const cursor = Base.cursor
 let currentMetaStep = []
 let codeceptjsEventDispatchersRegistered = false
 
+// Lazy container loading to avoid circular dependencies
+let containerPromise = null
+const getContainer = () => {
+  if (!containerPromise) {
+    containerPromise = import('../container.js').then(module => module.default || module)
+  }
+  return containerPromise
+}
+
 class Cli extends Base {
   constructor(runner, opts) {
     super(runner)
@@ -21,15 +39,21 @@ class Cli extends Base {
     if (opts.debug) level = 2
     if (opts.verbose) level = 3
     output.level(level)
-    output.print(`CodeceptJS v${require('../codecept').version()} ${output.standWithUkraine()}`)
+    output.print(`CodeceptJS v${codeceptVersion} ${output.standWithUkraine()}`)
     output.print(`Using test root "${global.codecept_dir}"`)
 
     const showSteps = level >= 1
 
     if (level >= 2) {
-      const Containter = require('../container')
-      output.print(output.styles.debug(`Helpers: ${Object.keys(Containter.helpers()).join(', ')}`))
-      output.print(output.styles.debug(`Plugins: ${Object.keys(Containter.plugins()).join(', ')}`))
+      // Load container asynchronously to avoid circular dependency
+      getContainer().then(Container => {
+        output.print(output.styles.debug(`Helpers: ${Object.keys(Container.helpers()).join(', ')}`))
+        output.print(output.styles.debug(`Plugins: ${Object.keys(Container.plugins()).join(', ')}`))
+      }).catch(() => {
+        // Silently fail if container can't be loaded
+        output.print(output.styles.debug('Helpers: [loading...]'))
+        output.print(output.styles.debug('Plugins: [loading...]'))
+      })
     }
 
     if (level >= 3) {
@@ -149,19 +173,23 @@ class Cli extends Base {
         }
       }
 
-      const container = require('../container')
-      container.result().addStats({ pending: skippedCount, tests: skippedCount })
+      getContainer().then(Container => {
+        Container.result().addStats({ pending: skippedCount, tests: skippedCount })
+      }).catch(() => {
+        // Silently fail if container can't be loaded
+      })
     })
 
     runner.on('end', this.result.bind(this))
   }
 
-  result() {
-    const container = require('../container')
-    container.result().addStats(this.stats)
-    container.result().finish()
+  async result() {
+    try {
+      const Container = await getContainer()
+      Container.result().addStats(this.stats)
+      Container.result().finish()
 
-    const stats = container.result().stats
+      const stats = Container.result().stats
     console.log()
 
     // passes
@@ -273,12 +301,17 @@ class Cli extends Base {
       console.log()
     }
 
-    container.result().addFailures(failuresLog)
+      Container.result().addFailures(failuresLog)
 
-    output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration), stats.failedHooks)
+      output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration), stats.failedHooks)
 
-    if (stats.failures && output.level() < 3) {
-      output.print(output.styles.debug('Run with --verbose flag to see complete NodeJS stacktrace'))
+      if (stats.failures && output.level() < 3) {
+        output.print(output.styles.debug('Run with --verbose flag to see complete NodeJS stacktrace'))
+      }
+    } catch (error) {
+      // Fallback behavior if container can't be loaded
+      console.log('Error loading container:', error.message)
+      output.result(0, 1, 0, 0, 0)
     }
   }
 }
@@ -303,6 +336,6 @@ function skipTestConfig(test, message) {
   test.state = 'skipped'
 }
 
-module.exports = function (runner, opts) {
+export default function (runner, opts) {
   return new Cli(runner, opts)
-}
+}

package/lib/mocha/factory.js

@@ -1,12 +1,15 @@
-const Mocha = require('mocha')
-const fsPath = require('path')
-const fs = require('fs')
-const reporter = require('./cli')
-const gherkinParser = require('./gherkin')
-const output = require('../output')
-const ConnectionRefused = require('../helper/errors/ConnectionRefused')
-
-const scenarioUi = fsPath.join(__dirname, './ui.js')
+import Mocha from 'mocha'
+import fsPath from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+import reporter from './cli.js'
+import gherkinParser, { loadTranslations } from './gherkin.js'
+import output from '../output.js'
+import scenarioUiFunction from './ui.js'
+import { initMochaGlobals } from '../globals.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = fsPath.dirname(__filename)
 
 let mocha
 
@@ -14,12 +17,22 @@ class MochaFactory {
   static create(config, opts) {
     mocha = new Mocha(Object.assign(config, opts))
     output.process(opts.child)
-    mocha.ui(scenarioUi)
+    mocha.ui(scenarioUiFunction)
+
+    // Manually trigger UI setup for globals to be available in ESM context
+    // This ensures Feature, Scenario, Before, etc. are available immediately
+    if (mocha.suite && mocha.suite.emit) {
+      const context = {}
+      mocha.suite.emit('pre-require', context, '', mocha)
+      // Also set globals immediately so they're available when ESM modules load
+      initMochaGlobals(context)
+    }
 
     Mocha.Runner.prototype.uncaught = function (err) {
       if (err) {
         if (err.toString().indexOf('ECONNREFUSED') >= 0) {
-          err = new ConnectionRefused(err)
+          // Handle ECONNREFUSED without dynamic import for now
+          err = new Error('Connection refused: ' + err.toString())
         }
         output.error(err)
         output.print(err.stack)
@@ -29,21 +42,64 @@ class MochaFactory {
       process.exit(1)
     }
 
-    mocha.loadFiles = fn => {
+    // Override loadFiles to handle feature files
+    const originalLoadFiles = Mocha.prototype.loadFiles
+    mocha.loadFiles = function (fn) {
       // load features
-      if (mocha.suite.suites.length === 0) {
-        mocha.files.filter(file => file.match(/\.feature$/)).forEach(file => mocha.suite.addSuite(gherkinParser(fs.readFileSync(file, 'utf8'), file)))
+      const featureFiles = this.files.filter(file => file.match(/\.feature$/))
+      if (featureFiles.length > 0) {
+        // Load translations for Gherkin features
+        loadTranslations().catch(() => {
+          // Ignore if translations can't be loaded
+        })
 
-        // remove feature files
-        mocha.files = mocha.files.filter(file => !file.match(/\.feature$/))
+        for (const file of featureFiles) {
+          const suite = gherkinParser(fs.readFileSync(file, 'utf8'), file)
+          this.suite.addSuite(suite)
+        }
 
-        Mocha.prototype.loadFiles.call(mocha, fn)
+        // remove feature files
+        const jsFiles = this.files.filter(file => !file.match(/\.feature$/))
+        this.files = this.files.filter(file => !file.match(/\.feature$/))
+
+        // Load JavaScript test files using ESM imports
+        if (jsFiles.length > 0) {
+          try {
+            // Try original loadFiles first for compatibility
+            originalLoadFiles.call(this, fn)
+          } catch (e) {
+            // If original loadFiles fails, load ESM files manually
+            if (e.message.includes('not in cache') || e.message.includes('ESM') || e.message.includes('getStatus')) {
+              // Load ESM files by importing them synchronously using top-level await workaround
+              for (const file of jsFiles) {
+                try {
+                  // Convert file path to file:// URL for dynamic import
+                  const fileUrl = `file://${file}`
+                  // Use import() but don't await it - let it load in the background
+                  import(fileUrl).catch(importErr => {
+                    // If dynamic import fails, the file may have syntax errors or other issues
+                    console.error(`Failed to load test file ${file}:`, importErr.message)
+                  })
+                  if (fn) fn()
+                } catch (fileErr) {
+                  console.error(`Error processing test file ${file}:`, fileErr.message)
+                  if (fn) fn(fileErr)
+                }
+              }
+            } else {
+              throw e
+            }
+          }
+        }
 
         // add ids for each test and check uniqueness
         const dupes = []
         let missingFeatureInFile = []
         const seenTests = []
-        mocha.suite.eachTest(test => {
+        this.suite.eachTest(test => {
+          if (!test) {
+            return // Skip undefined tests
+          }
           const name = test.fullTitle()
           if (seenTests.includes(test.uid)) {
             dupes.push(name)
@@ -63,6 +119,9 @@ class MochaFactory {
           missingFeatureInFile = [...new Set(missingFeatureInFile)]
           output.error(`Missing Feature section in:\n${missingFeatureInFile.join('\n')}`)
         }
+      } else {
+        // Use original for non-feature files
+        originalLoadFiles.call(this, fn)
       }
     }
 
@@ -101,4 +160,4 @@ class MochaFactory {
   }
 }
 
-module.exports = MochaFactory
+export default MochaFactory

package/lib/mocha/featureConfig.js

@@ -86,4 +86,4 @@ class FeatureConfig {
   }
 }
 
-module.exports = FeatureConfig
+export default FeatureConfig