fix issues

Author: kobenguyent

lib/container.js

@@ -68,7 +68,44 @@ class Container {
     container.plugins = await createPlugins(config.plugins || {}, opts)
     container.result = new Result()
 
-    createActor(config.include?.I)
+    // Preload includes (so proxies can expose real objects synchronously)
+    const includes = config.include || {}
+
+    // Ensure I is available for DI modules at import time
+    if (Object.prototype.hasOwnProperty.call(includes, 'I')) {
+      try {
+        const mod = includes.I
+        if (typeof mod === 'string') {
+          container.support.I = await loadSupportObject(mod, 'I')
+        } else if (typeof mod === 'function') {
+          container.support.I = await loadSupportObject(mod, 'I')
+        } else if (mod && typeof mod === 'object') {
+          container.support.I = mod
+        }
+      } catch (e) {
+        throw new Error(`Could not include object I: ${e.message}`)
+      }
+    } else {
+      // Create default actor if not provided via includes
+      createActor()
+    }
+
+    // Load remaining includes except I
+    for (const [name, mod] of Object.entries(includes)) {
+      if (name === 'I') continue
+      try {
+        if (typeof mod === 'string') {
+          container.support[name] = await loadSupportObject(mod, name)
+        } else if (typeof mod === 'function') {
+          // function or class
+          container.support[name] = await loadSupportObject(mod, name)
+        } else if (mod && typeof mod === 'object') {
+          container.support[name] = mod
+        }
+      } catch (e) {
+        throw new Error(`Could not include object ${name}: ${e.message}`)
+      }
+    }
 
     if (opts && opts.ai) ai.enable(config.ai) // enable AI Assistant
     if (config.gherkin) await loadGherkinStepsAsync(config.gherkin.steps || [])
@@ -228,7 +265,7 @@ function createHelpers(config) {
       }
 
       // ESM import (legacy check)
-      if (!HelperClass && helperName?.constructor === Function && helperName.prototype) {
+      if (!HelperClass && typeof helperName === 'function' && helperName.prototype) {
         HelperClass = helperName
         helperName = HelperClass.constructor.name
       }
@@ -445,7 +482,7 @@ function createSupportObjects(config) {
           return {
             enumerable: true,
             configurable: true,
-            value: this.get(target, prop),
+            value: container.support[name][prop],
           }
         },
         ownKeys() {
@@ -472,10 +509,21 @@ function createSupportObjects(config) {
         return {
           enumerable: true,
           configurable: true,
-          value: this.get(target, prop),
+          value: target[prop],
         }
       },
       get(target, key) {
+        if (typeof key === 'symbol') {
+          // safely ignore symbol-based meta properties used by tooling
+          return undefined
+        }
+        // Allow special I even if not declared in includes
+        if (key === 'I') {
+          return lazyLoad('I')
+        }
+        if (!keys.includes(key)) {
+          throw new Error(`Support object "${String(key)}" is not defined`)
+        }
         return lazyLoad(key)
       },
     },
@@ -485,12 +533,8 @@ function createSupportObjects(config) {
 function createActor(actorPath) {
   if (container.support.I) return container.support.I
 
-  if (actorPath) {
-    // Actor path loading must be handled async during container creation
-    throw new Error(`Custom actor loading from path '${actorPath}' must be handled asynchronously during container creation`)
-  } else {
-    container.support.I = actorFactory({}, Container)
-  }
+  // Default actor
+  container.support.I = actorFactory({}, Container)
 
   return container.support.I
 }
@@ -508,7 +552,7 @@ async function loadPluginAsync(modulePath, config) {
   if (typeof pluginFactory !== 'function') {
     throw new Error(`Plugin '${modulePath}' is not a function. Expected a plugin factory function.`)
   }
-  
+
   return pluginFactory(config)
 }
 
@@ -537,7 +581,7 @@ async function createPlugins(config, options = {}) {
       } else {
         module = `./plugin/${pluginName}.js`
       }
-      
+
       // Use async loading for all plugins (ESM and CJS)
       plugins[pluginName] = await loadPluginAsync(module, config[pluginName])
       debug(`plugin ${pluginName} loaded via async import`)
@@ -592,12 +636,31 @@ async function loadSupportObject(modulePath, supportObjectName) {
   if (!modulePath) {
     throw new Error(`Support object "${supportObjectName}" is not defined`)
   }
-  if (modulePath.charAt(0) === '.') {
+  // If function/class provided directly
+  if (typeof modulePath === 'function') {
+    try {
+      // class constructor
+      if (modulePath.prototype && modulePath.prototype.constructor === modulePath) {
+        return new modulePath()
+      }
+      // plain function factory
+      return modulePath()
+    } catch (err) {
+      throw new Error(`Could not include object ${supportObjectName} from function: ${err.message}`)
+    }
+  }
+  if (typeof modulePath === 'string' && modulePath.charAt(0) === '.') {
     modulePath = path.join(global.codecept_dir, modulePath)
   }
   try {
     // Use dynamic import for both ESM and CJS modules
-    const obj = await import(modulePath)
+    let importPath = modulePath
+    // Append .js if no extension provided (ESM resolution requires it)
+    if (typeof importPath === 'string') {
+      const ext = path.extname(importPath)
+      if (!ext) importPath = `${importPath}.js`
+    }
+    const obj = await import(importPath)
 
     // Handle ESM module wrapper
     let actualObj = obj

lib/effects.js

@@ -132,6 +132,7 @@ async function hopeThat(callback) {
         const msg = err.inspect ? err.inspect() : err.toString()
         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)

lib/els.js

@@ -4,7 +4,7 @@ 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 { truth } from './assert/truth.js'
 import { isAsyncFunction, humanizeFunction } from './utils.js'
 
 function element(purpose, locator, fn) {

lib/mocha/asyncWrapper.js

@@ -54,6 +54,8 @@ function test(test) {
 
   test.fn = function (done) {
     const doneFn = makeDoneCallableOnce(done)
+    // Ensure recorder is running so any steps added inside test function are executed
+    recorder.startUnlessRunning()
     recorder.errHandler(err => {
       recorder.session.start('teardown')
       recorder.cleanAsyncErr()
@@ -74,40 +76,26 @@ function test(test) {
       event.emit(event.test.finished, test)
       recorder.add(() => doneFn(err))
     })
-
-    if (isAsyncFunction(testFn)) {
-      event.emit(event.test.started, test)
-      getInjectedArguments(testFn, test).then(args => {
-        testFn
-          .call(test, args)
-          .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
-    }
-
-    getInjectedArguments(testFn, test).then(args => {
+    // Schedule the test execution inside recorder to ensure any external recorder.add
+    // calls happen after this and steps added within testFn are executed before finishing
+    recorder.add('execute test function', async () => {
       try {
+        const args = await getInjectedArguments(testFn, test)
         event.emit(event.test.started, test)
-        testFn.call(test, args)
-      } catch (err) {
-        recorder.throw(err)
-      } finally {
+        if (isAsyncFunction(testFn)) {
+          await testFn.call(test, args)
+        } else {
+          testFn.call(test, args)
+        }
+        // After testFn schedules its own steps, enqueue passed/finished
         recorder.add('fire test.passed', () => {
           event.emit(event.test.passed, test)
           event.emit(event.test.finished, test)
         })
+      } catch (err) {
+        recorder.throw(err)
+      } finally {
+        // Finish test after queued tasks
         recorder.add('finish test', doneFn)
         recorder.catch()
       }

lib/mocha/ui.js

@@ -45,7 +45,7 @@ export default function (suite) {
   let afterEachHooksAreLoaded
 
   suite.on('pre-require', (context, file, mocha) => {
-    common(suites, context, mocha)
+    const cmn = common(suites, context, mocha)
 
     const addScenario = function (title, opts = {}, fn) {
       const suite = suites[0]
@@ -67,8 +67,8 @@ export default function (suite) {
 
     // create dispatcher
 
-    context.BeforeAll = common.before
-    context.AfterAll = common.after
+    context.BeforeAll = cmn.before
+    context.AfterAll = cmn.after
 
     context.run = mocha.options.delay && common.runWithSuite(suite)
     /**

test/unit/container_test.js

@@ -25,7 +25,6 @@ describe('Container', () => {
   })
 
   describe('#translation', () => {
-
     it('should create empty translation', async () => {
       await container.create({})
       expect(container.translation()).to.be.instanceOf(Translation)
@@ -158,7 +157,7 @@ describe('Container', () => {
       const config = {
         helpers: {
           MyHelper: {
-            require: './data/helper',
+            require: './data/helper.js',
           },
           FileSystem: {},
         },
@@ -182,7 +181,7 @@ describe('Container', () => {
     it('should load DI and return a reference to the module', async () => {
       await container.create({
         include: {
-          dummyPage: './data/dummy_page',
+          dummyPage: './data/dummy_page.js',
         },
       })
       const dummyPage = await import('../data/dummy_page.js')
@@ -192,7 +191,7 @@ describe('Container', () => {
     it('should load I from path and execute', async () => {
       await container.create({
         include: {
-          I: './data/I',
+          I: './data/I.js',
         },
       })
       expect(container.support('I')).is.ok
@@ -214,8 +213,8 @@ describe('Container', () => {
     it('should load DI and inject I into PO', async () => {
       await container.create({
         include: {
-          dummyPage: './data/dummy_page',
-          I: './data/I',
+          dummyPage: './data/dummy_page.js',
+          I: './data/I.js',
         },
       })
       expect(container.support('dummyPage')).is.ok
@@ -227,8 +226,8 @@ describe('Container', () => {
     it('should load DI and inject custom I into PO', async () => {
       await container.create({
         include: {
-          dummyPage: './data/dummy_page',
-          I: './data/I',
+          dummyPage: './data/dummy_page.js',
+          I: './data/I.js',
         },
       })
       expect(container.support('dummyPage')).is.ok