codeceptjs 4.0.1-beta.5 → 4.0.1-beta.8

package/lib/actor.js

@@ -75,7 +75,8 @@ export default function (obj = {}, container) {
   if (!container) {
     container = Container
   }
-  
+
+  // Get existing actor or create a new one
   const actor = container.actor() || new Actor()
 
   // load all helpers once container initialized
@@ -111,14 +112,17 @@ export default function (obj = {}, container) {
       }
     })
 
-    container.append({
-      support: {
-        I: actor,
-      },
-    })
+    // Update container.support.I to ensure it has the latest actor reference
+    if (!container.actor() || container.actor() !== actor) {
+      container.append({
+        support: {
+          I: actor,
+        },
+      })
+    }
   })
-  // store.actor = actor;
-  // add custom steps from actor
+
+  // add custom steps from actor immediately
   Object.keys(obj).forEach(key => {
     const ms = new MetaStep('I', key)
     ms.setContext(actor)

package/lib/container.js

@@ -22,6 +22,7 @@ let container = {
   helpers: {},
   support: {},
   proxySupport: {},
+  proxySupportConfig: {}, // Track config used to create proxySupport
   plugins: {},
   actor: null,
   /**
@@ -67,14 +68,15 @@ class Container {
     container.support = {}
     container.helpers = await createHelpers(config.helpers || {})
     container.translation = await loadTranslation(config.translation || null, config.vocabularies || [])
-    container.proxySupport = createSupportObjects(config.include || {})
+    container.proxySupportConfig = config.include || {}
+    container.proxySupport = createSupportObjects(container.proxySupportConfig)
     container.plugins = await createPlugins(config.plugins || {}, opts)
     container.result = new Result()
 
     // Preload includes (so proxies can expose real objects synchronously)
     const includes = config.include || {}
 
-    // Ensure I is available for DI modules at import time
+    // Check if custom I is provided
     if (Object.prototype.hasOwnProperty.call(includes, 'I')) {
       try {
         const mod = includes.I
@@ -89,7 +91,7 @@ class Container {
         throw new Error(`Could not include object I: ${e.message}`)
       }
     } else {
-      // Create default actor if not provided via includes
+      // Create default actor - this sets up the callback in asyncHelperPromise
       createActor()
     }
 
@@ -110,7 +112,7 @@ class Container {
       }
     }
 
-    // Wait for all async helpers to finish loading and populate the actor with helper methods
+    // Wait for all async helpers to finish loading and populate the actor
     await asyncHelperPromise
 
     if (opts && opts.ai) ai.enable(config.ai) // enable AI Assistant
@@ -207,8 +209,10 @@ class Container {
 
     // If new support objects are added, update the proxy support
     if (newContainer.support) {
-      const newProxySupport = createSupportObjects(newContainer.support)
-      container.proxySupport = { ...container.proxySupport, ...newProxySupport }
+      // Merge the new support config with existing config
+      container.proxySupportConfig = { ...container.proxySupportConfig, ...newContainer.support }
+      // Recreate the proxy with merged config
+      container.proxySupport = createSupportObjects(container.proxySupportConfig)
     }
 
     debug('appended', JSON.stringify(newContainer).slice(0, 300))
@@ -224,6 +228,7 @@ class Container {
   static async clear(newHelpers = {}, newSupport = {}, newPlugins = {}) {
     container.helpers = newHelpers
     container.translation = await loadTranslation()
+    container.proxySupportConfig = newSupport
     container.proxySupport = createSupportObjects(newSupport)
     container.plugins = newPlugins
     container.sharedKeys = new Set() // Clear shared keys
@@ -350,16 +355,17 @@ async function createHelpers(config) {
     }
   }
 
-  // Wait for all async helpers to be fully loaded
-  await asyncHelperPromise
-
-  // Call _init on all helpers after they're all loaded
-  for (const name in helpers) {
-    if (helpers[name]._init) {
-      await helpers[name]._init()
-      debug(`helper ${name} _init() called`)
+  // Don't await here - let Container.create() handle the await
+  // This allows actor callbacks to be registered before resolution
+  asyncHelperPromise = asyncHelperPromise.then(async () => {
+    // Call _init on all helpers after they're all loaded
+    for (const name in helpers) {
+      if (helpers[name]._init) {
+        await helpers[name]._init()
+        debug(`helper ${name} _init() called`)
+      }
     }
-  }
+  })
 
   return helpers
 }
@@ -534,10 +540,17 @@ function createSupportObjects(config) {
         return [...new Set([...keys, ...container.sharedKeys])]
       },
       getOwnPropertyDescriptor(target, prop) {
+        // For destructuring to work, we need to return the actual value from the getter
+        let value
+        if (container.sharedKeys.has(prop) && prop in container.support) {
+          value = container.support[prop]
+        } else {
+          value = lazyLoad(prop)
+        }
         return {
           enumerable: true,
           configurable: true,
-          value: target[prop],
+          value: value,
         }
       },
       get(target, key) {

package/lib/helper/GraphQL.js

@@ -45,6 +45,8 @@ class GraphQL extends Helper {
       timeout: 10000,
       defaultHeaders: {},
       endpoint: '',
+      onRequest: null,
+      onResponse: null,
     }
     this.options = Object.assign(this.options, config)
     this.headers = { ...this.options.defaultHeaders }

package/lib/helper/Playwright.js

@@ -416,6 +416,7 @@ class Playwright extends Helper {
       ignoreHTTPSErrors: false, // Adding it here o that context can be set up to ignore the SSL errors,
       highlightElement: false,
       storageState: undefined,
+      onResponse: null,
     }
 
     process.env.testIdAttribute = 'data-testid'

package/lib/helper/REST.js

@@ -94,7 +94,9 @@ const config = {}
 class REST extends Helper {
   constructor(config) {
     super(config)
-    this.options = {
+
+    // Set defaults first
+    const defaults = {
       timeout: 10000,
       defaultHeaders: {},
       endpoint: '',
@@ -103,15 +105,16 @@ class REST extends Helper {
       onResponse: null,
     }
 
+    // Merge config with defaults
+    this._setConfig(config)
+    this.options = { ...defaults, ...this.options }
+
     if (this.options.maxContentLength) {
       const maxContentLength = this.options.maxUploadFileSize * 1024 * 1024
       this.options.maxContentLength = maxContentLength
       this.options.maxBodyLength = maxContentLength
     }
 
-    // override defaults with config
-    this._setConfig(config)
-
     this.headers = { ...this.options.defaultHeaders }
 
     // Create an agent with SSL certificate
@@ -215,8 +218,9 @@ class REST extends Helper {
       }
     }
 
-    if (this.options.onRequest) {
-      await this.options.onRequest(request)
+    const onRequest = this.options.onRequest || this.config.onRequest
+    if (onRequest) {
+      await onRequest(request)
     }
 
     try {
@@ -245,8 +249,9 @@ class REST extends Helper {
       }
       response = err.response
     }
-    if (this.options.onResponse) {
-      await this.options.onResponse(response)
+    const onResponse = this.options.onResponse || this.config.onResponse
+    if (onResponse) {
+      await onResponse(response)
     }
     try {
       this.options.prettyPrintJson ? this.debugSection('Response', beautify(JSON.stringify(response.data))) : this.debugSection('Response', JSON.stringify(response.data))

package/lib/workers.js

@@ -5,6 +5,7 @@ import { mkdirp } from 'mkdirp'
 import { Worker } from 'worker_threads'
 import { EventEmitter } from 'events'
 import ms from 'ms'
+import merge from 'lodash.merge'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -66,21 +67,21 @@ const createWorker = (workerObject, isPoolMode = false) => {
     stdout: true,
     stderr: true,
   })
-  
+
   // Pipe worker stdout/stderr to main process
   if (worker.stdout) {
     worker.stdout.setEncoding('utf8')
-    worker.stdout.on('data', (data) => {
+    worker.stdout.on('data', data => {
       process.stdout.write(data)
     })
   }
   if (worker.stderr) {
     worker.stderr.setEncoding('utf8')
-    worker.stderr.on('data', (data) => {
+    worker.stderr.on('data', data => {
       process.stderr.write(data)
     })
   }
-  
+
   worker.on('error', err => {
     console.error(`[Main] Worker Error:`, err)
     output.error(`Worker Error: ${err.stack}`)
@@ -221,13 +222,13 @@ class WorkerObject {
 
   addConfig(config) {
     const oldConfig = JSON.parse(this.options.override || '{}')
-    
+
     // Remove customLocatorStrategies from both old and new config before JSON serialization
     // since functions cannot be serialized and will be lost, causing workers to have empty strategies
     const configWithoutFunctions = { ...config }
-    
+
     // Clean both old and new config
-    const cleanConfig = (cfg) => {
+    const cleanConfig = cfg => {
       if (cfg.helpers) {
         cfg.helpers = { ...cfg.helpers }
         Object.keys(cfg.helpers).forEach(helperName => {
@@ -239,14 +240,12 @@ class WorkerObject {
       }
       return cfg
     }
-    
+
     const cleanedOldConfig = cleanConfig(oldConfig)
     const cleanedNewConfig = cleanConfig(configWithoutFunctions)
-    
-    const newConfig = {
-      ...cleanedOldConfig,
-      ...cleanedNewConfig,
-    }
+
+    // Deep merge configurations to preserve all helpers from base config
+    const newConfig = merge({}, cleanedOldConfig, cleanedNewConfig)
     this.options.override = JSON.stringify(newConfig)
   }
 
@@ -280,8 +279,8 @@ class Workers extends EventEmitter {
     this.setMaxListeners(50)
     this.codeceptPromise = initializeCodecept(config.testConfig, config.options)
     this.codecept = null
-    this.config = config  // Save config
-    this.numberOfWorkersRequested = numberOfWorkers  // Save requested worker count
+    this.config = config // Save config
+    this.numberOfWorkersRequested = numberOfWorkers // Save requested worker count
     this.options = config.options || {}
     this.errors = []
     this.numberOfWorkers = 0
@@ -304,11 +303,8 @@ class Workers extends EventEmitter {
       // Initialize workers in these cases:
       // 1. Positive number requested AND no manual workers pre-spawned
       // 2. Function-based grouping (indicated by negative number) AND no manual workers pre-spawned
-      const shouldAutoInit = this.workers.length === 0 && (
-        (Number.isInteger(this.numberOfWorkersRequested) && this.numberOfWorkersRequested > 0) ||
-        (this.numberOfWorkersRequested < 0 && isFunction(this.config.by))
-      )
-      
+      const shouldAutoInit = this.workers.length === 0 && ((Number.isInteger(this.numberOfWorkersRequested) && this.numberOfWorkersRequested > 0) || (this.numberOfWorkersRequested < 0 && isFunction(this.config.by)))
+
       if (shouldAutoInit) {
         this._initWorkers(this.numberOfWorkersRequested, this.config)
       }
@@ -319,7 +315,7 @@ class Workers extends EventEmitter {
     this.splitTestsByGroups(numberOfWorkers, config)
     // For function-based grouping, use the actual number of test groups created
     const actualNumberOfWorkers = isFunction(config.by) ? this.testGroups.length : numberOfWorkers
-    this.workers = createWorkerObjects(this.testGroups, this.codecept.config, config.testConfig, config.options, config.selectedRuns)
+    this.workers = createWorkerObjects(this.testGroups, this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
     this.numberOfWorkers = this.workers.length
   }
 
@@ -371,9 +367,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfTests(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(numberOfWorkers)
-  const files = this.codecept.testFiles
+    // If Codecept isn't initialized yet, return empty groups as a safe fallback
+    if (!this.codecept) return populateGroups(numberOfWorkers)
+    const files = this.codecept.testFiles
     const mocha = Container.mocha()
     mocha.files = files
     mocha.loadFiles()
@@ -430,7 +426,7 @@ class Workers extends EventEmitter {
     for (const file of files) {
       this.testPool.push(file)
     }
-    
+
     this.testPoolInitialized = true
   }
 
@@ -443,7 +439,7 @@ class Workers extends EventEmitter {
     if (!this.testPoolInitialized) {
       this._initializeTestPool()
     }
-    
+
     return this.testPool.shift()
   }
 
@@ -451,9 +447,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfSuites(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(numberOfWorkers)
-  const files = this.codecept.testFiles
+    // If Codecept isn't initialized yet, return empty groups as a safe fallback
+    if (!this.codecept) return populateGroups(numberOfWorkers)
+    const files = this.codecept.testFiles
     const groups = populateGroups(numberOfWorkers)
 
     const mocha = Container.mocha()
@@ -494,7 +490,7 @@ class Workers extends EventEmitter {
     recorder.startUnlessRunning()
     event.dispatcher.emit(event.workers.before)
     process.env.RUNS_WITH_WORKERS = 'true'
-    
+
     // Create workers and set up message handlers immediately (not in recorder queue)
     // This prevents a race condition where workers start sending messages before handlers are attached
     const workerThreads = []
@@ -503,11 +499,11 @@ class Workers extends EventEmitter {
       this._listenWorkerEvents(workerThread)
       workerThreads.push(workerThread)
     }
-    
+
     recorder.add('workers started', () => {
       // Workers are already running, this is just a placeholder step
     })
-    
+
     return new Promise(resolve => {
       this.on('end', resolve)
     })
@@ -591,7 +587,7 @@ class Workers extends EventEmitter {
           // Otherwise skip - we'll emit based on finished state
           break
         case event.test.passed:
-          // Skip individual passed events - we'll emit based on finished state  
+          // Skip individual passed events - we'll emit based on finished state
           break
         case event.test.skipped:
           this.emit(event.test.skipped, deserializeTest(message.data))
@@ -602,15 +598,15 @@ class Workers extends EventEmitter {
             const data = message.data
             const uid = data?.uid
             const isFailed = !!data?.err || data?.state === 'failed'
-            
+
             if (uid) {
               // Track states for each test UID
               if (!this._testStates) this._testStates = new Map()
-              
+
               if (!this._testStates.has(uid)) {
                 this._testStates.set(uid, { states: [], lastData: data })
               }
-              
+
               const testState = this._testStates.get(uid)
               testState.states.push({ isFailed, data })
               testState.lastData = data
@@ -622,7 +618,7 @@ class Workers extends EventEmitter {
                 this.emit(event.test.passed, deserializeTest(data))
               }
             }
-            
+
             this.emit(event.test.finished, deserializeTest(data))
           }
           break
@@ -682,11 +678,10 @@ class Workers extends EventEmitter {
         // For tests with retries configured, emit all failures + final success
         // For tests without retries, emit only final state
         const lastState = states[states.length - 1]
-        
+
         // Check if this test had retries by looking for failure followed by success
-        const hasRetryPattern = states.length > 1 && 
-          states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
-        
+        const hasRetryPattern = states.length > 1 && states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
+
         if (hasRetryPattern) {
           // Emit all intermediate failures and final success for retries
           for (const state of states) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.1-beta.5",
+  "version": "4.0.1-beta.8",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [