Changes before error encountered

Co-authored-by: kobenguyent <7845001+kobenguyent@users.noreply.github.com>

Author: Copilot

lib/command/generate.js

@@ -18,7 +18,7 @@ Scenario('test something', async ({ {{actor}} }) => {
 `
 
 // generates empty test
-module.exports.test = function (genPath) {
+export const test = function (genPath) {
   const testsPath = getTestRoot(genPath)
   global.codecept_dir = testsPath
   const config = getConfigSync(testsPath)
@@ -107,7 +107,7 @@ export default new {{name}}();
 export = {{name}};
 `
 
-module.exports.pageObject = function (genPath, opts) {
+export const pageObject = function (genPath, opts) {
   const testsPath = getTestRoot(genPath)
   const config = getConfigSync(testsPath)
   const kind = opts.T || 'page'
@@ -227,7 +227,7 @@ class {{name}} extends Helper {
 export default {{name}};
 `
 
-module.exports.helper = function (genPath) {
+export const helper = function (genPath) {
   const testsPath = getTestRoot(genPath)
 
   output.print('Creating a new helper')
@@ -269,7 +269,7 @@ helpers: {
 
 const healTemplate = fs.readFileSync(path.join(__dirname, '../template/heal.js'), 'utf8').toString()
 
-module.exports.heal = function (genPath) {
+export const heal = function (genPath) {
   const testsPath = getTestRoot(genPath)
 
   let configFile = path.join(testsPath, `codecept.conf.${extension}`)

lib/command/info.js

@@ -73,7 +73,7 @@ export default async function (path) {
   output.print('***************************************')
 }
 
-module.exports.getMachineInfo = async () => {
+export const getMachineInfo = async () => {
   const info = {
     nodeInfo: await envinfo.helpers.getNodeInfo(),
     osInfo: await envinfo.helpers.getOSInfo(),

lib/command/run-workers.js

@@ -1,5 +1,6 @@
 // For Node version >=10.5.0, have to use experimental flag
 import { tryOrDefault } from '../utils.js'
+import { getMachineInfo } from './info.js'
 import output from '../output.js'
 import store from '../store.js'
 import event from '../event.js'
@@ -49,7 +50,6 @@ export default async function (workerCount, selectedRuns, options) {
     if (options.verbose || options.debug) store.debugMode = true
 
     if (options.verbose) {
-      import { getMachineInfo  } from './info.js'
       await getMachineInfo()
     }
     await workers.bootstrapAll()

lib/command/run.js

@@ -1,4 +1,5 @@
 import { getConfig, printError, getTestRoot, createOutputDir } from './utils.js'
+import { getMachineInfo } from './info.js'
 import Config from '../config.js'
 import store from '../store.js'
 import Codecept from '../codecept.js'
@@ -32,7 +33,6 @@ export default async function (test, options) {
 
     if (options.verbose) {
       global.debugMode = true
-      import { getMachineInfo  } from './info.js'
       await getMachineInfo()
     }
 

lib/command/utils.js

@@ -4,22 +4,23 @@ import util from 'util'
 import { mkdirp } from 'mkdirp'
 
 import output from '../output.js'
+import Config from '../config.js'
 import { fileExists, beautify, deepMerge } from '../utils.js'
 
 // alias to deep merge
 export { deepMerge }
 
 export const getConfig = async function (configFile) {
   try {
-    return await (await import('../config.js')).default.load(configFile)
+    return await Config.load(configFile)
   } catch (err) {
     fail(err.stack)
   }
 }
 
 export const getConfigSync = function (configFile) {
   try {
-    return (await import('../config.js')).default.loadSync(configFile)
+    return Config.loadSync(configFile)
   } catch (err) {
     fail(err.stack)
   }

lib/container.js

@@ -294,7 +294,7 @@ function checkHelperRequirements(HelperClass) {
 async function requireHelperFromModule(helperName, config, HelperClass) {
   const moduleName = getHelperModuleName(helperName, config)
   if (moduleName.startsWith('./helper/')) {
-    const mod = await import(moduleName);
+    const mod = await import(moduleName + '.js');
     HelperClass = mod.default || mod;
   } else {
     // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
@@ -358,6 +358,44 @@ async function createSupportObjects(config) {
   // Return the support objects directly (simplified for ESM conversion)
   return supportObjects;
 }
+
+async function createPlugins(config, options) {
+  const plugins = {}
+  for (const pluginName in config) {
+    try {
+      let pluginFn
+      const pluginConfig = config[pluginName]
+      
+      if (pluginConfig === false) continue // plugin disabled
+      
+      // Load plugin module
+      let moduleName
+      if (pluginConfig.require) {
+        moduleName = pluginConfig.require
+      } else {
+        moduleName = `./plugin/${pluginName}.js`
+      }
+      
+      const mod = await import(moduleName)
+      pluginFn = mod.default || mod
+      
+      if (typeof pluginFn === 'function') {
+        pluginFn(pluginConfig)
+        plugins[pluginName] = pluginFn
+        debug(`plugin ${pluginName} loaded`)
+      }
+    } catch (err) {
+      throw new Error(`Could not load plugin ${pluginName} (${err.message})`)
+    }
+  }
+  return plugins
+}
+
+async function createActor(actorConfig = {}) {
+  const actorModule = await import('./actor.js')
+  const createActorFn = actorModule.default
+  return createActorFn(actorConfig)
+}
 async function loadGherkinSteps(paths) {
   global.Before = fn => event.dispatcher.on(event.test.started, fn)
   global.After = fn => event.dispatcher.on(event.test.finished, fn)

lib/heal.js

@@ -155,8 +155,8 @@ class Heal {
     recorder.throw(error)
   }
 
-  static setDefaultHealers() {
-    (await import('./template/heal.js')).default
+  static async setDefaultHealers() {
+    return (await import('./template/heal.js')).default
   }
 }
 

lib/helper.js

@@ -1,2 +1,3 @@
 // helper class was moved out from this repository to allow extending from base class
-export default (await import('@codeceptjs/helper')).default;
+const Helper = await import('@codeceptjs/helper');
+export default Helper.default;

lib/mocha/asyncWrapper.js

@@ -25,7 +25,7 @@ function suiteTestFailedHookError(suite, err, hookName) {
   suite.eachTest(test => {
     testInstance.err = err
     if (hookName) hookName = ucfirst(hookName)
-    event.emit(event.testInstance.failed, test, err, hookName)
+    event.emit(event.test.failed, test, err, hookName)
   })
 }
 
@@ -63,28 +63,28 @@ export function test(testInstance) {
         // check that test should actually fail
         try {
           assertThrown(err, testInstance.throws)
-          event.emit(event.testInstance.passed, testInstance)
-          event.emit(event.testInstance.finished, testInstance)
+          event.emit(event.test.passed, testInstance)
+          event.emit(event.test.finished, testInstance)
           recorder.add(doneFn)
           return
         } catch (newErr) {
           err = newErr
         }
       }
       testInstance.err = err
-      event.emit(event.testInstance.failed, testInstance, err)
-      event.emit(event.testInstance.finished, testInstance)
+      event.emit(event.test.failed, testInstance, err)
+      event.emit(event.test.finished, testInstance)
       recorder.add(() => doneFn(err))
     })
 
     if (isAsyncFunction(testFn)) {
-      event.emit(event.testInstance.started, testInstance)
+      event.emit(event.test.started, testInstance)
       testFn
         .call(testInstance, getInjectedArguments(testFn, testInstance))
         .then(() => {
           recorder.add('fire testInstance.passed', () => {
-            event.emit(event.testInstance.passed, testInstance)
-            event.emit(event.testInstance.finished, testInstance)
+            event.emit(event.test.passed, testInstance)
+            event.emit(event.test.finished, testInstance)
           })
           recorder.add('finish test', doneFn)
         })
@@ -98,14 +98,14 @@ export function test(testInstance) {
     }
 
     try {
-      event.emit(event.testInstance.started, testInstance)
+      event.emit(event.test.started, testInstance)
       testFn.call(testInstance, getInjectedArguments(testFn, testInstance))
     } catch (err) {
       recorder.throw(err)
     } finally {
       recorder.add('fire testInstance.passed', () => {
-        event.emit(event.testInstance.passed, testInstance)
-        event.emit(event.testInstance.finished, testInstance)
+        event.emit(event.test.passed, testInstance)
+        event.emit(event.test.finished, testInstance)
       })
       recorder.add('finish test', doneFn)
       recorder.catch()
@@ -129,7 +129,7 @@ export function injected(fn, suite, hookName) {
       if (hookName === 'after') {
         suiteTestFailedHookError(suite, err, hookName)
         suite.eachTest(test => {
-          event.emit(event.testInstance.after, test)
+          event.emit(event.test.after, test)
         })
       }
       if (hookName === 'afterSuite') {
@@ -201,14 +201,14 @@ export function injected(fn, suite, hookName) {
 export function setup(suite) {
   return injectHook(() => {
     recorder.startUnlessRunning()
-    event.emit(event.testInstance.before, enhanceMochaTest(suite?.ctx?.currentTest))
+    event.emit(event.test.before, enhanceMochaTest(suite?.ctx?.currentTest))
   }, suite)
 }
 
 export function teardown(suite) {
   return injectHook(() => {
     recorder.startUnlessRunning()
-    event.emit(event.testInstance.after, enhanceMochaTest(suite?.ctx?.currentTest))
+    event.emit(event.test.after, enhanceMochaTest(suite?.ctx?.currentTest))
   }, suite)
 }
 

lib/mocha/factory.js

@@ -18,6 +18,7 @@ class MochaFactory {
     mocha = new Mocha(Object.assign(config, opts))
     output.process(opts.child)
     mocha.ui(scenarioUi)
+    // mocha.ui('bdd')
 
     Mocha.Runner.prototype.uncaught = function (err) {
       if (err) {