codeceptjs 4.0.0-beta.7.esm-aria → 4.0.0-beta.8.esm-aria

package/lib/command/generate.js

@@ -288,7 +288,7 @@ export async function heal(genPath) {
 import './heal.js'
 
 export const config = {
-  // ... 
+  // ...
   plugins: {
     heal: {
       enabled: true
@@ -301,3 +301,35 @@ export const config = {
   if (!safeFileWrite(healFile, healTemplate)) return
   output.success(`Heal recipes were created in ${healFile}`)
 }
+
+export async function prompt(promptName, genPath) {
+  if (!promptName) {
+    output.error('Please specify prompt name: writeStep, healStep, or generatePageObject')
+    output.print('Usage: npx codeceptjs generate:prompt <promptName>')
+    return
+  }
+
+  const validPrompts = ['writeStep', 'healStep', 'generatePageObject']
+  if (!validPrompts.includes(promptName)) {
+    output.error(`Invalid prompt name: ${promptName}`)
+    output.print(`Valid prompts: ${validPrompts.join(', ')}`)
+    return
+  }
+
+  const testsPath = getTestRoot(genPath)
+
+  const promptsDir = path.join(testsPath, 'prompts')
+  if (!fileExists(promptsDir)) {
+    mkdirp.sync(promptsDir)
+  }
+
+  const templatePath = path.join(__dirname, `../template/prompts/${promptName}.js`)
+  const promptContent = fs.readFileSync(templatePath, 'utf8')
+
+  const promptFile = path.join(promptsDir, `${promptName}.${extension}`)
+  if (!safeFileWrite(promptFile, promptContent)) return
+
+  output.success(`Prompt ${promptName} was created in ${promptFile}`)
+  output.print('Customize this prompt to fit your needs.')
+  output.print('This prompt will be automatically loaded when AI features are enabled.')
+}

package/lib/command/init.js

@@ -19,6 +19,11 @@ const defaultConfig = {
   output: '',
   helpers: {},
   include: {},
+  plugins: {
+    htmlReporter: {
+      enabled: true,
+    },
+  },
 }
 
 const helpers = ['Playwright', 'WebDriver', 'Puppeteer', 'REST', 'GraphQL', 'Appium']
@@ -35,7 +40,6 @@ const packages = []
 let isTypeScript = false
 let extension = 'js'
 
-const requireCodeceptConfigure = "const { setHeadlessWhen, setCommonPlugins } = require('@codeceptjs/configure');"
 const importCodeceptConfigure = "import { setHeadlessWhen, setCommonPlugins } from '@codeceptjs/configure';"
 
 const configHeader = `
@@ -232,9 +236,9 @@ export default async function (initPath) {
           fs.writeFileSync(typeScriptconfigFile, configSource, 'utf-8')
           print(`Config created at ${typeScriptconfigFile}`)
         } else {
-          configSource = beautify(`/** @type {CodeceptJS.MainConfig} */\nexports.config = ${inspect(config, false, 4, false)}`)
+          configSource = beautify(`/** @type {CodeceptJS.MainConfig} */\nexport const config = ${inspect(config, false, 4, false)}`)
 
-          if (hasConfigure) configSource = requireCodeceptConfigure + configHeader + configSource
+          if (hasConfigure) configSource = importCodeceptConfigure + configHeader + configSource
 
           fs.writeFileSync(configFile, configSource, 'utf-8')
           print(`Config created at ${configFile}`)

package/lib/command/run-workers.js

@@ -12,7 +12,22 @@ export default async function (workerCount, selectedRuns, options) {
 
   const { config: testConfig, override = '' } = options
   const overrideConfigs = tryOrDefault(() => JSON.parse(override), {})
-  const by = options.suites ? 'suite' : 'test'
+
+  // Determine test split strategy
+  let by = 'test' // default
+  if (options.by) {
+    // Explicit --by option takes precedence
+    by = options.by
+  } else if (options.suites) {
+    // Legacy --suites option
+    by = 'suite'
+  }
+
+  // Validate the by option
+  const validStrategies = ['test', 'suite', 'pool']
+  if (!validStrategies.includes(by)) {
+    throw new Error(`Invalid --by strategy: ${by}. Valid options are: ${validStrategies.join(', ')}`)
+  }
   delete options.parent
   const config = {
     by,
@@ -57,8 +72,22 @@ export default async function (workerCount, selectedRuns, options) {
     await workers.run()
   } catch (err) {
     output.error(err)
-    process.exit(1)
+    process.exitCode = 1
   } finally {
     await workers.teardownAll()
+    
+    // Force exit if event loop doesn't clear naturally
+    // This is needed because worker threads may leave handles open
+    // even after proper cleanup, preventing natural process termination
+    if (!options.noExit) {
+      // Use beforeExit to ensure we run after all other exit handlers
+      // have set the correct exit code
+      process.once('beforeExit', (code) => {
+        // Give cleanup a moment to complete, then force exit with the correct code
+        setTimeout(() => {
+          process.exit(code || process.exitCode || 0)
+        }, 100)
+      })
+    }
   }
 }

package/lib/command/run.js

@@ -2,6 +2,7 @@ import { getConfig, printError, getTestRoot, createOutputDir } from './utils.js'
 import Config from '../config.js'
 import store from '../store.js'
 import Codecept from '../codecept.js'
+import container from '../container.js'
 
 export default async function (test, options) {
   // registering options globally to use in config
@@ -42,5 +43,19 @@ export default async function (test, options) {
     process.exitCode = 1
   } finally {
     await codecept.teardown()
+
+    // Schedule a delayed exit to prevent process hanging due to browser helper event loops
+    // Only needed for Playwright/Puppeteer which keep the event loop alive
+    // Wait 1 second to allow final cleanup and output to complete
+    if (!process.env.CODECEPT_DISABLE_AUTO_EXIT) {
+      const helpers = container.helpers()
+      const hasBrowserHelper = helpers && (helpers.Playwright || helpers.Puppeteer || helpers.WebDriver)
+      
+      if (hasBrowserHelper) {
+        setTimeout(() => {
+          process.exit(process.exitCode || 0)
+        }, 1000).unref()
+      }
+    }
   }
 }

package/lib/command/workers/runTests.js

@@ -8,72 +8,336 @@ if (!tty.getWindowSize) {
 }
 
 import { parentPort, workerData } from 'worker_threads'
-import event from '../../event.js'
-import container from '../../container.js'
-import { getConfig } from '../utils.js'
-import { tryOrDefault, deepMerge } from '../../utils.js'
+
+// Delay imports to avoid ES Module loader race conditions in Node 22.x worker threads
+// These will be imported dynamically when needed
+let event, container, Codecept, getConfig, tryOrDefault, deepMerge
 
 let stdout = ''
 
 const stderr = ''
 
-// Importing of Codecept need to be after tty.getWindowSize is available.
-import Codecept from '../../codecept.js'
-
-const { options, tests, testRoot, workerIndex } = workerData
+const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
 // hide worker output
-if (!options.debug && !options.verbose)
+// In pool mode, only suppress output if debug is NOT enabled
+// In regular mode, hide result output but allow step output in verbose/debug
+if (poolMode && !options.debug) {
+  // In pool mode without debug, allow test names and important output but suppress verbose details
+  const originalWrite = process.stdout.write
+  process.stdout.write = string => {
+    // Allow test names (✔ or ✖), Scenario Steps, failures, and important markers
+    if (
+      string.includes('✔') ||
+      string.includes('✖') ||
+      string.includes('Scenario Steps:') ||
+      string.includes('◯ Scenario Steps:') ||
+      string.includes('-- FAILURES:') ||
+      string.includes('AssertionError:') ||
+      string.includes('Feature(')
+    ) {
+      return originalWrite.call(process.stdout, string)
+    }
+    // Suppress result summaries to avoid duplicates
+    if (string.includes('  FAIL  |') || string.includes('  OK  |') || string.includes('◯ File:')) {
+      return true
+    }
+    return originalWrite.call(process.stdout, string)
+  }
+} else if (!poolMode && !options.debug && !options.verbose) {
   process.stdout.write = string => {
     stdout += string
     return true
   }
+} else {
+  // In verbose/debug mode for test/suite modes, show step details
+  // but suppress individual worker result summaries to avoid duplicate output
+  const originalWrite = process.stdout.write
+  const originalConsoleLog = console.log
+
+  process.stdout.write = string => {
+    // Suppress individual worker result summaries and failure reports
+    if (string.includes('  FAIL  |') || string.includes('  OK  |') || string.includes('-- FAILURES:') || string.includes('AssertionError:') || string.includes('◯ File:') || string.includes('◯ Scenario Steps:')) {
+      return true
+    }
+    return originalWrite.call(process.stdout, string)
+  }
 
-const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
+  // Override console.log to catch result summaries
+  console.log = (...args) => {
+    const fullMessage = args.join(' ')
+    if (fullMessage.includes('  FAIL  |') || fullMessage.includes('  OK  |') || fullMessage.includes('-- FAILURES:')) {
+      return
+    }
+    return originalConsoleLog.apply(console, args)
+  }
+}
 
-// important deep merge so dynamic things e.g. functions on config are not overridden
-const config = deepMerge(getConfig(options.config || testRoot), overrideConfigs)
+// Declare codecept and mocha at module level so they can be accessed by functions
+let codecept
+let mocha
+let initPromise
+let config
 
 // Load test and run
-;(async function () {
-  const codecept = new Codecept(config, options)
-  await codecept.init(testRoot)
-  codecept.loadTests()
-  const mocha = container.mocha()
+initPromise = (async function () {
+  try {
+    // Import modules dynamically to avoid ES Module loader race conditions in Node 22.x
+    const eventModule = await import('../../event.js')
+    const containerModule = await import('../../container.js')
+    const utilsModule = await import('../utils.js')
+    const coreUtilsModule = await import('../../utils.js')
+    const CodeceptModule = await import('../../codecept.js')
+    
+    event = eventModule.default
+    container = containerModule.default
+    getConfig = utilsModule.getConfig
+    tryOrDefault = coreUtilsModule.tryOrDefault
+    deepMerge = coreUtilsModule.deepMerge
+    Codecept = CodeceptModule.default
+    
+    const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
+    
+    // IMPORTANT: await is required here since getConfig is async
+    const baseConfig = await getConfig(options.config || testRoot)
+    
+    // important deep merge so dynamic things e.g. functions on config are not overridden
+    config = deepMerge(baseConfig, overrideConfigs)
+    
+    codecept = new Codecept(config, options)
+    await codecept.init(testRoot)
+    codecept.loadTests()
+    mocha = container.mocha()
 
-  function filterTests() {
-    const files = codecept.testFiles
-    mocha.files = files
-    mocha.loadFiles()
+    if (poolMode) {
+      // In pool mode, don't filter tests upfront - wait for assignments
+      // We'll reload test files fresh for each test request
+    } else {
+      // Legacy mode - filter tests upfront
+      filterTests()
+    }
 
-    for (const suite of mocha.suite.suites) {
-      suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
+    // run tests
+    if (poolMode) {
+      await runPoolTests()
+    } else if (mocha.suite.total()) {
+      await runTests()
+    } else {
+      // No tests to run, close the worker
+      parentPort?.close()
     }
+  } catch (err) {
+    console.error('Error in worker initialization:', err)
+    process.exit(1)
   }
+})()
 
-  async function runTests() {
-    try {
-      await codecept.bootstrap()
-    } catch (err) {
-      throw new Error(`Error while running bootstrap file :${err}`)
+let globalStats = { passes: 0, failures: 0, tests: 0, pending: 0, failedHooks: 0 }
+
+async function runTests() {
+  try {
+    await codecept.bootstrap()
+  } catch (err) {
+    throw new Error(`Error while running bootstrap file :${err}`)
+  }
+  listenToParentThread()
+  initializeListeners()
+  disablePause()
+  try {
+    await codecept.run()
+  } finally {
+    await codecept.teardown()
+  }
+}
+
+async function runPoolTests() {
+  try {
+    await codecept.bootstrap()
+  } catch (err) {
+    throw new Error(`Error while running bootstrap file :${err}`)
+  }
+
+  initializeListeners()
+  disablePause()
+
+  // Emit event.all.before once at the start of pool mode
+  event.dispatcher.emit(event.all.before, codecept)
+
+  // Accumulate results across all tests in pool mode
+  let consolidatedStats = { passes: 0, failures: 0, tests: 0, pending: 0, failedHooks: 0 }
+  let allTests = []
+  let allFailures = []
+  let previousStats = { passes: 0, failures: 0, tests: 0, pending: 0, failedHooks: 0 }
+
+  // Keep requesting tests until no more available
+  while (true) {
+    // Request a test assignment and wait for response
+    const testResult = await new Promise((resolve, reject) => {
+      // Set up pool mode message handler FIRST before sending request
+      const messageHandler = async eventData => {
+        // Remove handler immediately to prevent duplicate processing
+        parentPort?.off('message', messageHandler)
+        
+        if (eventData.type === 'TEST_ASSIGNED') {
+          // In pool mode with ESM, we receive test FILE paths instead of UIDs
+          // because UIDs are not stable across different mocha instances
+          const testIdentifier = eventData.test
+
+          try {
+            // Create a fresh Mocha instance for each test file
+            container.createMocha()
+            const mocha = container.mocha()
+            
+            // Load only the assigned test file
+            mocha.files = [testIdentifier]
+            mocha.loadFiles()
+
+            try {
+              require('fs').appendFileSync('/tmp/config_listener_debug.log', `${new Date().toISOString()} [POOL] Loaded ${testIdentifier}, tests: ${mocha.suite.total()}\n`)
+            } catch (e) { /* ignore */ }
+
+            if (mocha.suite.total() > 0) {
+              // Run only the tests in the current mocha suite
+              // Don't use codecept.run() as it overwrites mocha.files with ALL test files
+              await new Promise((resolve, reject) => {
+                mocha.run(() => {
+                  try {
+                    require('fs').appendFileSync('/tmp/config_listener_debug.log', `${new Date().toISOString()} [POOL] Finished ${testIdentifier}\n`)
+                  } catch (e) { /* ignore */ }
+                  resolve()
+                })
+              })
+
+              // Get the results from this specific test run
+              const result = container.result()
+              const currentStats = result.stats || {}
+
+              // Calculate the difference from previous accumulated stats
+              const newPasses = Math.max(0, (currentStats.passes || 0) - previousStats.passes)
+              const newFailures = Math.max(0, (currentStats.failures || 0) - previousStats.failures)
+              const newTests = Math.max(0, (currentStats.tests || 0) - previousStats.tests)
+              const newPending = Math.max(0, (currentStats.pending || 0) - previousStats.pending)
+              const newFailedHooks = Math.max(0, (currentStats.failedHooks || 0) - previousStats.failedHooks)
+
+              // Add only the new results
+              consolidatedStats.passes += newPasses
+              consolidatedStats.failures += newFailures
+              consolidatedStats.tests += newTests
+              consolidatedStats.pending += newPending
+              consolidatedStats.failedHooks += newFailedHooks
+
+              // Update previous stats for next comparison
+              previousStats = { ...currentStats }
+
+              // Add new failures to consolidated collections
+              if (result.failures && result.failures.length > allFailures.length) {
+                const newFailures = result.failures.slice(allFailures.length)
+                allFailures.push(...newFailures)
+              }
+            }
+
+            // Signal test completed
+            resolve('TEST_COMPLETED')
+          } catch (err) {
+            reject(err)
+          }
+        } else if (eventData.type === 'NO_MORE_TESTS') {
+          // No tests available, exit worker
+          resolve('NO_MORE_TESTS')
+        } else {
+          // Handle other message types (support messages, etc.)
+          container.append({ support: eventData.data })
+          // Don't re-add handler - each test request creates its own one-time handler
+        }
+      }
+
+      // Set up handler BEFORE sending request to avoid race condition
+      parentPort?.on('message', messageHandler)
+      
+      // Now send the request
+      sendToParentThread({ type: 'REQUEST_TEST', workerIndex })
+    })
+
+    // Exit if no more tests
+    if (testResult === 'NO_MORE_TESTS') {
+      break
     }
-    listenToParentThread()
-    initializeListeners()
-    disablePause()
-    try {
-      await codecept.run()
-    } finally {
-      await codecept.teardown()
+  }
+
+  // Emit event.all.after once at the end of pool mode
+  event.dispatcher.emit(event.all.after, codecept)
+
+  try {
+    await codecept.teardown()
+  } catch (err) {
+    // Log teardown errors but don't fail
+    console.error('Teardown error:', err)
+  }
+
+  // Send final consolidated results for the entire worker
+  const finalResult = {
+    hasFailed: consolidatedStats.failures > 0,
+    stats: consolidatedStats,
+    duration: 0, // Pool mode doesn't track duration per worker
+    tests: [], // Keep tests empty to avoid serialization issues - stats are sufficient
+    failures: allFailures, // Include all failures for error reporting
+  }
+
+  sendToParentThread({ event: event.all.after, workerIndex, data: finalResult })
+  sendToParentThread({ event: event.all.result, workerIndex, data: finalResult })
+
+  // Add longer delay to ensure messages are delivered before closing
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  // Close worker thread when pool mode is complete
+  parentPort?.close()
+}
+
+function filterTestById(testUid) {
+  // In pool mode with ESM, test files are already loaded once at initialization
+  // We just need to filter the existing mocha suite to only include the target test
+  
+  // Get the existing mocha instance
+  const mocha = container.mocha()
+
+  // Save reference to all suites before clearing
+  const allSuites = [...mocha.suite.suites]
+  
+  // Clear suites and tests but preserve other mocha settings
+  mocha.suite.suites = []
+  mocha.suite.tests = []
+
+  // Find and add only the suite containing our target test
+  let foundTest = false
+  for (const suite of allSuites) {
+    const originalTests = [...suite.tests]
+    
+    // Check if this suite has our target test
+    const targetTest = originalTests.find(test => test.uid === testUid)
+    
+    if (targetTest) {
+      // Create a filtered suite with only the target test
+      suite.tests = [targetTest]
+      mocha.suite.suites.push(suite)
+      foundTest = true
+      break // Only include one test
     }
   }
 
-  filterTests()
+  if (!foundTest) {
+    console.error(`WARNING: Test with UID ${testUid} not found in mocha suites`)
+  }
+}
 
-  // run tests
-  if (mocha.suite.total()) {
-    await runTests()
+function filterTests() {
+  const files = codecept.testFiles
+  mocha.files = files
+  mocha.loadFiles()
+
+  for (const suite of mocha.suite.suites) {
+    suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
   }
-})()
+}
 
 function initializeListeners() {
   // suite
@@ -92,10 +356,11 @@ function initializeListeners() {
     const serializableErr = serializeError(err)
     safelySendToParent({ event: event.test.finished, workerIndex, data: { ...simplifiedData, err: serializableErr } })
   })
-  event.dispatcher.on(event.test.failed, (test, err) => {
+  event.dispatcher.on(event.test.failed, (test, err, hookName) => {
     const simplifiedData = test.simplify()
     const serializableErr = serializeError(err)
-    safelySendToParent({ event: event.test.failed, workerIndex, data: { ...simplifiedData, err: serializableErr } })
+    // Include hookName to identify hook failures
+    safelySendToParent({ event: event.test.failed, workerIndex, data: { ...simplifiedData, err: serializableErr, hookName } })
   })
   event.dispatcher.on(event.test.passed, (test, err) => safelySendToParent({ event: event.test.passed, workerIndex, data: { ...test.simplify(), err } }))
   event.dispatcher.on(event.test.started, test => safelySendToParent({ event: event.test.started, workerIndex, data: test.simplify() }))
@@ -107,19 +372,24 @@ function initializeListeners() {
   event.dispatcher.on(event.step.passed, step => safelySendToParent({ event: event.step.passed, workerIndex, data: step.simplify() }))
   event.dispatcher.on(event.step.failed, step => safelySendToParent({ event: event.step.failed, workerIndex, data: step.simplify() }))
 
-  event.dispatcher.on(event.hook.failed, (hook, err) => {
-    const serializableErr = serializeError(err)
-    safelySendToParent({ event: event.hook.failed, workerIndex, data: { ...hook.simplify(), err: serializableErr } })
-  })
-  event.dispatcher.on(event.hook.passed, hook => safelySendToParent({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
-  event.dispatcher.on(event.hook.finished, hook => safelySendToParent({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
-
-  event.dispatcher.once(event.all.after, () => safelySendToParent({ event: event.all.after, workerIndex, data: container.result().simplify() }))
-  // all
-  event.dispatcher.once(event.all.result, () => {
-    safelySendToParent({ event: event.all.result, workerIndex, data: container.result().simplify() })
-    parentPort?.close()
-  })
+  event.dispatcher.on(event.hook.failed, (hook, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: { ...hook.simplify(), err } }))
+  event.dispatcher.on(event.hook.passed, hook => sendToParentThread({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
+  event.dispatcher.on(event.hook.finished, hook => sendToParentThread({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
+
+  if (!poolMode) {
+    // In regular mode, close worker after all tests are complete
+    event.dispatcher.once(event.all.after, () => {
+      sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })
+    })
+    // all
+    event.dispatcher.once(event.all.result, () => {
+      sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
+      parentPort?.close()
+    })
+  } else {
+    // In pool mode, don't send result events for individual tests
+    // Results will be sent once when the worker completes all tests
+  }
 }
 
 function disablePause() {
@@ -175,7 +445,10 @@ function sendToParentThread(data) {
 }
 
 function listenToParentThread() {
-  parentPort?.on('message', eventData => {
-    container.append({ support: eventData.data })
-  })
+  if (!poolMode) {
+    parentPort?.on('message', eventData => {
+      container.append({ support: eventData.data })
+    })
+  }
+  // In pool mode, message handling is done in runPoolTests()
 }

package/lib/config.js

@@ -34,7 +34,7 @@ const defaultConfig = {
 let hooks = []
 let config = {}
 
-const configFileNames = ['codecept.config.js', 'codecept.conf.js', 'codecept.js', 'codecept.config.ts', 'codecept.conf.ts']
+const configFileNames = ['codecept.config.js', 'codecept.conf.js', 'codecept.js', 'codecept.config.cjs', 'codecept.conf.cjs', 'codecept.config.ts', 'codecept.conf.ts']
 
 /**
  * Current configuration
@@ -69,9 +69,20 @@ class Config {
     configFile = path.resolve(configFile || '.')
 
     if (!fileExists(configFile)) {
-      configFile = configFile.replace('.js', '.ts')
-
-      if (!fileExists(configFile)) {
+      // Try different extensions if the file doesn't exist
+      const extensions = ['.ts', '.cjs', '.mjs']
+      let found = false
+      
+      for (const ext of extensions) {
+        const altConfig = configFile.replace(/\.js$/, ext)
+        if (fileExists(altConfig)) {
+          configFile = altConfig
+          found = true
+          break
+        }
+      }
+      
+      if (!found) {
         throw new Error(`Config file ${configFile} does not exist. Execute 'codeceptjs init' to create config`)
       }
     }
@@ -198,7 +209,7 @@ async function loadConfigFile(configFile) {
       }
     }
 
-    const rawConfig = configModule.config || configModule.default?.config || configModule
+    const rawConfig = configModule.config || configModule.default?.config || configModule.default || configModule
 
     // Process helpers to extract imported classes
     if (rawConfig.helpers) {