codeceptjs 4.0.1-beta.9 → 4.0.1

package/lib/command/workers/runTests.js

@@ -11,7 +11,7 @@ import { parentPort, workerData } from 'worker_threads'
 
 // 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 event, container, Codecept, getConfig, tryOrDefault, deepMerge, fixErrorStack
 
 let stdout = ''
 
@@ -19,6 +19,44 @@ const stderr = ''
 
 const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
+// Global error handlers to catch critical errors but not test failures
+process.on('uncaughtException', (err) => {
+  if (container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = container.tsFileMapping()
+    if (fileMapping) {
+      fixErrorStack(err, fileMapping)
+    }
+  }
+
+  // Log to stderr to bypass stdout suppression
+  process.stderr.write(`[Worker ${workerIndex}] UNCAUGHT EXCEPTION: ${err.message}\n`)
+  process.stderr.write(`${err.stack}\n`)
+
+  // Don't exit on test assertion errors - those are handled by mocha
+  if (err.name === 'AssertionError' || err.message?.includes('expected')) {
+    return
+  }
+  process.exit(1)
+})
+
+process.on('unhandledRejection', (reason, promise) => {
+  if (reason && typeof reason === 'object' && reason.stack && container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = container.tsFileMapping()
+    if (fileMapping) {
+      fixErrorStack(reason, fileMapping)
+    }
+  }
+
+  // Log to stderr to bypass stdout suppression
+  const msg = reason?.message || String(reason)
+  process.stderr.write(`[Worker ${workerIndex}] UNHANDLED REJECTION: ${msg}\n`)
+  if (reason?.stack) {
+    process.stderr.write(`${reason.stack}\n`)
+  }
+
+  // Do not exit — killing the worker silently drops every remaining test from the report.
+})
+
 // hide worker output
 // In pool mode, only suppress output if debug is NOT enabled
 // In regular mode, hide result output but allow step output in verbose/debug
@@ -26,6 +64,10 @@ 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 => {
+    // Always allow Worker logs
+    if (string.includes('[Worker')) {
+      return originalWrite.call(process.stdout, string)
+    }
     // Allow test names (✔ or ✖), Scenario Steps, failures, and important markers
     if (
       string.includes('✔') ||
@@ -45,7 +87,12 @@ if (poolMode && !options.debug) {
     return originalWrite.call(process.stdout, string)
   }
 } else if (!poolMode && !options.debug && !options.verbose) {
+  const originalWrite = process.stdout.write
   process.stdout.write = string => {
+    // Always allow Worker logs
+    if (string.includes('[Worker')) {
+      return originalWrite.call(process.stdout, string)
+    }
     stdout += string
     return true
   }
@@ -82,30 +129,69 @@ let config
 // Load test and run
 initPromise = (async function () {
   try {
+    // Add staggered delay at the very start to prevent resource conflicts
+    // Longer delay for browser initialization conflicts
+    const delay = (workerIndex - 1) * 2000 // 0ms, 2s, 4s, etc.
+    if (delay > 0) {
+      await new Promise(resolve => setTimeout(resolve, delay))
+    }
+    
     // 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')
-    
+    const typescriptModule = await import('../../utils/typescript.js')
+
     event = eventModule.default
     container = containerModule.default
     getConfig = utilsModule.getConfig
     tryOrDefault = coreUtilsModule.tryOrDefault
     deepMerge = coreUtilsModule.deepMerge
     Codecept = CodeceptModule.default
+    fixErrorStack = typescriptModule.fixErrorStack
     
     const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
     
-    // IMPORTANT: await is required here since getConfig is async
-    const baseConfig = await getConfig(options.config || testRoot)
+    let baseConfig
+    try {
+      // IMPORTANT: await is required here since getConfig is async
+      baseConfig = await getConfig(options.config || testRoot)
+    } catch (configErr) {
+      if (container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = container.tsFileMapping()
+        if (fileMapping) {
+          fixErrorStack(configErr, fileMapping)
+        }
+      }
+      process.stderr.write(`[Worker ${workerIndex}] FAILED loading config: ${configErr.message}\n`)
+      process.stderr.write(`${configErr.stack}\n`)
+      await new Promise(resolve => setTimeout(resolve, 100))
+      process.exit(1)
+    }
     
     // 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)
+    // Pass workerIndex as child option for output.process() to display worker prefix
+    const optsWithChild = { ...options, child: workerIndex }
+    codecept = new Codecept(config, optsWithChild)
+    
+    try {
+      await codecept.init(testRoot)
+    } catch (initErr) {
+      if (container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = container.tsFileMapping()
+        if (fileMapping) {
+          fixErrorStack(initErr, fileMapping)
+        }
+      }
+      process.stderr.write(`[Worker ${workerIndex}] FAILED during codecept.init(): ${initErr.message}\n`)
+      process.stderr.write(`${initErr.stack}\n`)
+      process.exit(1)
+    }
+    
     codecept.loadTests()
     mocha = container.mocha()
 
@@ -124,10 +210,18 @@ initPromise = (async function () {
       await runTests()
     } else {
       // No tests to run, close the worker
+      console.error(`[Worker ${workerIndex}] ERROR: No tests found after filtering! Assigned ${tests.length} UIDs but none matched.`)
       parentPort?.close()
     }
   } catch (err) {
-    console.error('Error in worker initialization:', err)
+    if (container?.tsFileMapping && fixErrorStack) {
+      const fileMapping = container.tsFileMapping()
+      if (fileMapping) {
+        fixErrorStack(err, fileMapping)
+      }
+    }
+    process.stderr.write(`[Worker ${workerIndex}] FATAL ERROR: ${err.message}\n`)
+    process.stderr.write(`${err.stack}\n`)
     process.exit(1)
   }
 })()
@@ -145,8 +239,14 @@ async function runTests() {
   disablePause()
   try {
     await codecept.run()
+  } catch (err) {
+    throw err
   } finally {
-    await codecept.teardown()
+    try {
+      await codecept.teardown()
+    } catch (err) {
+      // Ignore teardown errors
+    }
   }
 }
 
@@ -334,8 +434,16 @@ function filterTests() {
   mocha.files = files
   mocha.loadFiles()
 
-  for (const suite of mocha.suite.suites) {
+  // Recursively filter tests in all suites (including nested ones)
+  const filterSuiteTests = (suite) => {
     suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
+    for (const childSuite of suite.suites) {
+      filterSuiteTests(childSuite)
+    }
+  }
+
+  for (const suite of mocha.suite.suites) {
+    filterSuiteTests(suite)
   }
 }
 

package/lib/config.js

@@ -2,7 +2,7 @@ import fs from 'fs'
 import path from 'path'
 import { createRequire } from 'module'
 import { fileExists, isFile, deepMerge, deepClone } from './utils.js'
-import { transpileTypeScript, cleanupTempFiles } from './utils/typescript.js'
+import { transpileTypeScript, cleanupTempFiles, fixErrorStack } from './utils/typescript.js'
 
 const defaultConfig = {
   output: './_output',
@@ -15,8 +15,9 @@ const defaultConfig = {
   hooks: [],
   gherkin: {},
   plugins: {
-    screenshotOnFail: {
-      enabled: true, // will be disabled by default in 2.0
+    screenshot: {
+      enabled: true,
+      on: 'fail',
     },
   },
   stepTimeout: 0,
@@ -32,9 +33,27 @@ const defaultConfig = {
   ],
 }
 
+// Array<{ fn: (cfg) => void, ran: boolean, error?: Error }>
 let hooks = []
 let config = {}
 
+// Apply a single hook against `cfg`, swallowing errors so one broken hook
+// can't take down the whole run. The failure is logged through the
+// framework's own output module (when available) so it shows up in test
+// reports; the hook is still marked ran so it doesn't get retried.
+function applyHook(hook, cfg) {
+  try {
+    hook.fn(cfg)
+  } catch (err) {
+    hook.error = err
+    const out = globalThis.codeceptjs?.output
+    if (out && typeof out.error === 'function') out.error(`config hook failed: ${err.message}`)
+    else console.error('config hook failed:', err)
+  } finally {
+    hook.ran = true
+  }
+}
+
 const configFileNames = ['codecept.config.js', 'codecept.conf.js', 'codecept.js', 'codecept.config.cjs', 'codecept.conf.cjs', 'codecept.config.ts', 'codecept.conf.ts']
 
 /**
@@ -49,7 +68,11 @@ class Config {
    */
   static create(newConfig) {
     config = deepMerge(deepClone(defaultConfig), newConfig)
-    hooks.forEach(f => f(config))
+    // Re-apply every hook against the freshly built config; hooks added later
+    // (e.g. from plugin boot) stay pending until runPendingHooks. Array
+    // iterators re-check length on each step, so hooks pushed during a hook
+    // execution are visited in this same pass.
+    for (const hook of hooks) applyHook(hook, config)
     return config
   }
 
@@ -121,7 +144,48 @@ class Config {
   }
 
   static addHook(fn) {
-    hooks.push(fn)
+    hooks.push({ fn, ran: false })
+  }
+
+  /**
+   * Run every hook that hasn't been applied to the current config yet.
+   * Hooks added after `Config.create()` (e.g. from plugin boot code) stay
+   * pending until this is called; once it runs, they're marked applied so
+   * subsequent calls are no-ops. Hooks added while pending hooks are running
+   * are picked up in the same pass (the array iterator re-checks length).
+   *
+   * Failures are logged through `output.error` and don't abort the loop —
+   * a broken hook can't poison the run, but its error is visible.
+   *
+   * @param {Object<string, *>} [cfg] target config (defaults to the live singleton)
+   * @return {boolean} true if any hook ran
+   */
+  static runPendingHooks(cfg = config) {
+    let ran = false
+    for (const hook of hooks) {
+      if (hook.ran) continue
+      applyHook(hook, cfg)
+      ran = true
+    }
+    return ran
+  }
+
+  /**
+   * Number of registered config hooks. Useful for snapshotting before a phase
+   * (e.g. plugin loading) and re-running only the hooks added during it.
+   * @return {number}
+   */
+  static hooksCount() {
+    return hooks.length
+  }
+
+  /**
+   * Run hooks in `[fromIndex, end)` against the given config object, mutating it.
+   * @param {number} fromIndex
+   * @param {Object<string, *>} cfg
+   */
+  static runHooksFrom(fromIndex, cfg) {
+    for (let i = fromIndex; i < hooks.length; i++) hooks[i](cfg)
   }
 
   /**
@@ -150,32 +214,47 @@ async function loadConfigFile(configFile) {
   const require = createRequire(import.meta.url)
   const extensionName = path.extname(configFile)
 
+  // Populate the in-process registry that packages like @codeceptjs/configure
+  // look up at config-import time (their proxies throw if `globalThis.codeceptjs`
+  // is missing). initCodeceptGlobals sets this too, but only later during
+  // bootstrap — config files are imported here first.
+  if (!globalThis.codeceptjs) {
+    const indexModule = await import('./index.js')
+    globalThis.codeceptjs = indexModule.default || indexModule
+  }
+
   // .conf.js config file
   if (extensionName === '.js' || extensionName === '.ts' || extensionName === '.cjs') {
     let configModule
     try {
       // For .ts files, try to compile and load as JavaScript
       if (extensionName === '.ts') {
+        let transpileError = null
+        let tempFile = null
+        let allTempFiles = null
+        let fileMapping = null
+
         try {
           // Use the TypeScript transpilation utility
           const typescript = require('typescript')
-          const { tempFile, allTempFiles } = await transpileTypeScript(configFile, typescript)
+          const result = await transpileTypeScript(configFile, typescript)
+          tempFile = result.tempFile
+          allTempFiles = result.allTempFiles
+          fileMapping = result.fileMapping
 
-          try {
-            configModule = await import(tempFile)
-            cleanupTempFiles(allTempFiles)
-          } catch (err) {
-            cleanupTempFiles(allTempFiles)
-            throw err
+          configModule = await import(tempFile)
+          cleanupTempFiles(allTempFiles)
+        } catch (err) {
+          transpileError = err
+          if (fileMapping) {
+            fixErrorStack(err, fileMapping)
           }
-        } catch (tsError) {
-          // If TypeScript compilation fails, fallback to ts-node
-          try {
-            require('ts-node/register')
-            configModule = require(configFile)
-          } catch (tsNodeError) {
-            throw new Error(`Failed to load TypeScript config: ${tsError.message}`)
+          if (allTempFiles) {
+            cleanupTempFiles(allTempFiles)
           }
+          // Throw immediately with the actual error - don't fall back to ts-node
+          // as it will mask the real error with "Unexpected token 'export'"
+          throw err
         }
       } else {
         // Try ESM import first for JS files