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

package/lib/data/context.js

@@ -1,9 +1,10 @@
-const { isGenerator } = require('../utils')
-const DataTable = require('./table')
-const DataScenarioConfig = require('./dataScenarioConfig')
-const Secret = require('../secret')
+import { isGenerator } from '../utils.js'
+import DataTable from './table.js'
+import DataScenarioConfig from './dataScenarioConfig.js'
+import secretModule from '../secret.js'
+const Secret = secretModule.default || secretModule
 
-module.exports = function (context) {
+export default function (context) {
   context.Data = function (dataTable) {
     const data = detectDataType(dataTable)
     return {

package/lib/data/dataScenarioConfig.js

@@ -81,4 +81,4 @@ class DataScenarioConfig {
   }
 }
 
-module.exports = DataScenarioConfig
+export default DataScenarioConfig

package/lib/data/dataTableArgument.js

@@ -63,4 +63,4 @@ class DataTableArgument {
   }
 }
 
-module.exports = DataTableArgument
+export default DataTableArgument

package/lib/data/table.js

@@ -40,4 +40,4 @@ class DataTable {
   }
 }
 
-module.exports = DataTable
+export default DataTable

package/lib/effects.js

@@ -1,8 +1,89 @@
-const recorder = require('./recorder')
-const { debug } = require('./output')
-const store = require('./store')
-const event = require('./event')
-const within = require('./within')
+import recorder from './recorder.js'
+import output from './output.js'
+import store from './store.js'
+import event from './event.js'
+import container from './container.js'
+import MetaStep from './step/meta.js'
+import { isAsyncFunction } from './utils.js'
+
+/**
+ * @param {CodeceptJS.LocatorOrString}  context
+ * @param {Function}  fn
+ * @return {Promise<*> | undefined}
+ */
+function within(context, fn) {
+  const helpers = store.dryRun ? {} : container.helpers()
+  const locator = typeof context === 'object' ? JSON.stringify(context) : context
+
+  return recorder.add(
+    'register within wrapper',
+    () => {
+      const metaStep = new WithinStep(locator, fn)
+      const defineMetaStep = step => (step.metaStep = metaStep)
+      recorder.session.start('within')
+
+      event.dispatcher.prependListener(event.step.before, defineMetaStep)
+
+      Object.keys(helpers).forEach(helper => {
+        if (helpers[helper]._withinBegin) recorder.add(`[${helper}] start within`, () => helpers[helper]._withinBegin(context))
+      })
+
+      const finalize = () => {
+        event.dispatcher.removeListener(event.step.before, defineMetaStep)
+        recorder.add('Finalize session within session', () => {
+          output.stepShift = 1
+          recorder.session.restore('within')
+        })
+      }
+      const finishHelpers = () => {
+        Object.keys(helpers).forEach(helper => {
+          if (helpers[helper]._withinEnd) recorder.add(`[${helper}] finish within`, () => helpers[helper]._withinEnd())
+        })
+      }
+
+      if (isAsyncFunction(fn)) {
+        return fn()
+          .then(res => {
+            finishHelpers()
+            finalize()
+            return recorder.promise().then(() => res)
+          })
+          .catch(e => {
+            finalize()
+            recorder.throw(e)
+          })
+      }
+
+      let res
+      try {
+        res = fn()
+      } catch (err) {
+        recorder.throw(err)
+      } finally {
+        finishHelpers()
+        recorder.catch(err => {
+          output.stepShift = 1
+          throw err
+        })
+      }
+      finalize()
+      return recorder.promise().then(() => res)
+    },
+    false,
+    false,
+  )
+}
+
+class WithinStep extends MetaStep {
+  constructor(locator, fn) {
+    super('Within')
+    this.args = [locator]
+  }
+
+  toString() {
+    return `${this.prefix}Within ${this.humanizeArgs()}${this.suffix}`
+  }
+}
 
 /**
  * A utility function for CodeceptJS tests that acts as a soft assertion.
@@ -49,8 +130,9 @@ async function hopeThat(callback) {
       recorder.session.catch(err => {
         result = false
         const msg = err.inspect ? err.inspect() : err.toString()
-        debug(`Unsuccessful assertion > ${msg}`)
+        output.debug(`Unsuccessful assertion > ${msg}`)
         event.dispatcher.once(event.test.finished, test => {
+          if (!test.notes) test.notes = []
           test.notes.push({ type: 'conditionalError', text: msg })
         })
         recorder.session.restore(sessionName)
@@ -130,7 +212,7 @@ async function retryTo(callback, maxTries, pollInterval = 200) {
       recorder.session.catch(err => {
         recorder.session.restore(`${sessionName} ${tries}`)
         if (tries <= maxTries) {
-          debug(`Error ${err}... Retrying`)
+          output.debug(`Error ${err}... Retrying`)
           recorder.add(`${sessionName} ${tries}`, () => setTimeout(tryBlock, pollInterval))
         } else {
           // if maxTries reached
@@ -185,7 +267,7 @@ async function tryTo(callback) {
     () => {
       recorder.session.start(sessionName)
       isAutoRetriesEnabled = store.autoRetries
-      if (isAutoRetriesEnabled) debug('Auto retries disabled inside tryTo effect')
+      if (isAutoRetriesEnabled) output.debug('Auto retries disabled inside tryTo effect')
       store.autoRetries = false
       callback()
       recorder.add(() => {
@@ -196,7 +278,7 @@ async function tryTo(callback) {
       recorder.session.catch(err => {
         result = false
         const msg = err.inspect ? err.inspect() : err.toString()
-        debug(`Unsuccessful try > ${msg}`)
+        output.debug(`Unsuccessful try > ${msg}`)
         recorder.session.restore(sessionName)
         return result
       })
@@ -215,7 +297,9 @@ async function tryTo(callback) {
   )
 }
 
-module.exports = {
+export { hopeThat, retryTo, tryTo, within }
+
+export default {
   hopeThat,
   retryTo,
   tryTo,

package/lib/element/WebElement.js

@@ -1,4 +1,4 @@
-const assert = require('assert')
+import assert from 'assert'
 
 /**
  * Unified WebElement class that wraps native element instances from different helpers
@@ -324,4 +324,4 @@ class WebElement {
   }
 }
 
-module.exports = WebElement
+export default WebElement

package/lib/els.js

@@ -1,11 +1,11 @@
-const output = require('./output')
-const store = require('./store')
-const container = require('./container')
-const StepConfig = require('./step/config')
-const recordStep = require('./step/record')
-const FuncStep = require('./step/func')
-const { truth } = require('./assert/truth')
-const { isAsyncFunction, humanizeFunction } = require('./utils')
+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
@@ -121,7 +121,9 @@ function expectAllElements(locator, fn) {
   })
 }
 
-module.exports = {
+export { element, eachElement, expectElement, expectAnyElement, expectAllElements }
+
+export default {
   element,
   eachElement,
   expectElement,

package/lib/event.js

@@ -1,6 +1,7 @@
-const debug = require('debug')('codeceptjs:event')
-const events = require('events')
-const { error } = require('./output')
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:event')
+import events from 'events'
+import output from './output.js'
 
 const MAX_LISTENERS = 200
 
@@ -18,7 +19,7 @@ if (typeof process.setMaxListeners === 'function') {
  * @alias event
  */
 
-module.exports = {
+export default {
   /**
    * @type {NodeJS.EventEmitter}
    * @constant
@@ -161,25 +162,25 @@ module.exports = {
     try {
       this.dispatcher.emit.apply(this.dispatcher, arguments)
     } catch (err) {
-      error(`Error processing ${event} event:`)
-      error(err.stack)
+      output.error(`Error processing ${event} event:`)
+      output.error(err.stack)
     }
   },
 
   /** for testing only! */
-  cleanDispatcher: () => {
+  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])
+      this.dispatcher.removeAllListeners(this.suite[event])
     }
     for (event in this.step) {
-      this.dispatcher.removeAllListeners(this.test[event])
+      this.dispatcher.removeAllListeners(this.step[event])
     }
     for (event in this.all) {
-      this.dispatcher.removeAllListeners(this.test[event])
+      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'
+  ]
+}

package/lib/heal.js

@@ -1,9 +1,9 @@
-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 debugModule from 'debug'
+const debug = debugModule('codeceptjs:heal')
+import colors from 'chalk'
+import recorder from './recorder.js'
+import output from './output.js'
+import event from './event.js'
 
 /**
  * @class
@@ -69,7 +69,7 @@ class Heal {
       if (!prepareFn) continue
 
       if (context[property]) continue
-      context[property] = await prepareFn(Container.support())
+      context[property] = await prepareFn(global.inject())
     }
 
     output.level(currentOutputLevel)
@@ -116,10 +116,10 @@ class Heal {
           })
 
           if (typeof codeSnippet === 'string') {
-            const I = Container.support('I')
+            const I = global.container.support('I')
             await eval(codeSnippet)
           } else if (typeof codeSnippet === 'function') {
-            await codeSnippet(Container.support())
+            await codeSnippet(global.container.support())
           }
 
           this.fixes.push({
@@ -155,14 +155,14 @@ class Heal {
     recorder.throw(error)
   }
 
-  static setDefaultHealers() {
-    require('./template/heal')
+  static async setDefaultHealers() {
+    await import('./template/heal.js')
   }
 }
 
 const heal = new Heal()
 
-module.exports = heal
+export default heal
 
 function matchRecipes(recipes, contextName) {
   return Object.entries(recipes)

package/lib/helper/AI.js

@@ -1,13 +1,13 @@
-const Helper = require('@codeceptjs/helper')
-const ora = require('ora-classic')
-const fs = require('fs')
-const path = require('path')
-const ai = require('../ai')
-const Container = require('../container')
-const { splitByChunks, minifyHtml } = require('../html')
-const { beautify } = require('../utils')
-const output = require('../output')
-const { registerVariable } = require('../pause')
+import HelperModule from '@codeceptjs/helper'
+import ora from 'ora-classic'
+import fs from 'fs'
+import path from 'path'
+import ai from '../ai.js'
+import Container from '../container.js'
+import { splitByChunks, minifyHtml } from '../html.js'
+import { beautify } from '../utils.js'
+import output from '../output.js'
+import { registerVariable } from '../pause.js'
 
 const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
 
@@ -211,4 +211,4 @@ class AI extends Helper {
   }
 }
 
-module.exports = AI
+export default AI

package/lib/helper/ApiDataFactory.js

@@ -1,7 +1,6 @@
-const path = require('path')
-
-const Helper = require('@codeceptjs/helper')
-const REST = require('./REST')
+import path from 'path'
+import Helper from '@codeceptjs/helper'
+import REST from './REST.js'
 
 /**
  * Helper for managing remote data using REST API.
@@ -222,10 +221,11 @@ class ApiDataFactory extends Helper {
 
   static _checkRequirements() {
     try {
-      require('axios')
-      require('rosie')
+      // In ESM, dependencies are already imported at the top
+      // The import will fail at module load time if dependencies are missing
+      return null
     } catch (e) {
-      return ['axios', 'rosie']
+      return ['axios']
     }
   }
 
@@ -241,10 +241,25 @@ class ApiDataFactory extends Helper {
       if (!createdItems.length) continue
       this.debug(`Deleting ${createdItems.length} ${factoryName}(s)`)
       for (const id in createdItems) {
-        promises.push(this._requestDelete(factoryName, createdItems[id]))
+        const deletePromise = this._requestDelete(factoryName, createdItems[id])
+        if (deletePromise) {
+          promises.push(deletePromise.catch(err => {
+            this.debugSection('Delete Error', `Failed to delete ${factoryName} with id ${createdItems[id]}: ${err.message}`)
+            // Don't reject Promise.all, just log the error
+            return Promise.resolve()
+          }))
+        }
       }
     }
-    return Promise.all(promises)
+    return Promise.all(promises).then(() => {
+      // Clear the created items after successful cleanup
+      for (const factoryName in this.created) {
+        this.created[factoryName] = []
+      }
+      // Add a small delay to ensure file system changes propagate in Docker environments
+      // This helps avoid race conditions where GET requests after DELETE don't see the changes yet
+      return new Promise(resolve => setTimeout(resolve, 100))
+    })
   }
 
   /**
@@ -265,8 +280,8 @@ class ApiDataFactory extends Helper {
    * @param {*} [options] options for programmatically generate the attributes
    * @returns {Promise<*>}
    */
-  have(factory, params, options) {
-    const item = this._createItem(factory, params, options)
+  async have(factory, params, options) {
+    const item = await this._createItem(factory, params, options)
     this.debug(`Creating ${factory} ${JSON.stringify(item)}`)
     return this._requestCreate(factory, item)
   }
@@ -298,19 +313,22 @@ class ApiDataFactory extends Helper {
     return Promise.all(promises)
   }
 
-  _createItem(model, data, options) {
+  async _createItem(model, data, options) {
     if (!this.factories[model]) {
       throw new Error(`Factory ${model} is not defined in config`)
     }
     let modulePath = this.factories[model].factory
     try {
       try {
-        require.resolve(modulePath)
+        // Try to resolve the path as-is first
+        await import.meta.resolve(modulePath)
       } catch (e) {
+        // If not found, try relative to codecept_dir
         modulePath = path.join(global.codecept_dir, modulePath)
       }
       // check if the new syntax `export default new Factory()` is used and loads the builder, otherwise loads the module that used old syntax `module.exports = new Factory()`.
-      const builder = require(modulePath).default || require(modulePath)
+      const module = await import(modulePath)
+      const builder = module.default || module
       return builder.build(data, options)
     } catch (err) {
       throw new Error(`Couldn't load factory file from ${modulePath}, check that
@@ -383,26 +401,39 @@ Current file error: ${err.message}`)
       const url = this.factories[factory].delete[method].replace('{id}', id)
 
       request = {
-        method,
+        method: method.toUpperCase(), // Ensure HTTP method is uppercase
         url,
       }
     }
 
+    // Ensure method is uppercase (some servers require uppercase HTTP methods)
+    if (request.method) {
+      request.method = request.method.toUpperCase()
+    }
+
     request.baseURL = this.config.endpoint
 
     if (request.url.match(/^undefined/)) {
       return this.debugSection('Please configure the delete request in your ApiDataFactory helper', "delete: () => ({ method: 'DELETE',  url: '/api/users' })")
     }
 
-    return this.restHelper._executeRequest(request).then(() => {
+    this.debugSection('Deleting', `${request.method} ${request.baseURL}${request.url} (ID: ${id})`)
+
+    return this.restHelper._executeRequest(request).then((resp) => {
       const idx = this.created[factory].indexOf(id)
-      this.debugSection('Deleted Id', `Id: ${id}`)
-      this.created[factory].splice(idx, 1)
+      this.debugSection('Deleted Successfully', `${factory} ID: ${id}, Status: ${resp.status || 'OK'}`)
+      if (idx !== -1) {
+        this.created[factory].splice(idx, 1)
+      }
+      return resp
+    }).catch(err => {
+      this.debugSection('Delete Failed', `${factory} ID: ${id}, Error: ${err.message}`)
+      throw err
     })
   }
 }
 
-module.exports = ApiDataFactory
+export { ApiDataFactory as default }
 
 function createRequestFromFunction(param, data) {
   if (typeof param !== 'function') return