codeceptjs 3.7.6-beta.4 → 4.0.0-beta.10.esm-aria

package/lib/command/workers/runTests.js

@@ -1,4 +1,4 @@
-const tty = require('tty')
+import tty from 'tty'
 
 if (!tty.getWindowSize) {
   // this is really old method, long removed from Node, but Mocha
@@ -7,33 +7,39 @@ if (!tty.getWindowSize) {
   tty.getWindowSize = () => [40, 80]
 }
 
-const { parentPort, workerData } = require('worker_threads')
-const event = require('../../event')
-const container = require('../../container')
-const { getConfig } = require('../utils')
-const { tryOrDefault, deepMerge } = require('../../utils')
+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 stdout = ''
 
 const stderr = ''
 
-// Requiring of Codecept need to be after tty.getWindowSize is available.
-const Codecept = require(process.env.CODECEPT_CLASS_PATH || '../../codecept')
-
 const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
 // 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
 if (poolMode && !options.debug) {
-  // In pool mode without debug, suppress only result summaries and failures, but allow Scenario Steps
+  // 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 Scenario Steps output (including the circle symbol)
-    if (string.includes('Scenario Steps:') || string.includes('◯ Scenario Steps:')) {
+    // 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)
     }
-    if (string.includes('  FAIL  |') || string.includes('  OK  |') || string.includes('-- FAILURES:') || string.includes('AssertionError:') || string.includes('◯ File:')) {
+    // Suppress result summaries to avoid duplicates
+    if (string.includes('  FAIL  |') || string.includes('  OK  |') || string.includes('◯ File:')) {
       return true
     }
     return originalWrite.call(process.stdout, string)
@@ -67,31 +73,62 @@ if (poolMode && !options.debug) {
   }
 }
 
-const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
-
-// 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
-const codecept = new Codecept(config, options)
-codecept.init(testRoot)
-codecept.loadTests()
-const mocha = container.mocha()
-
-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()
-}
+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()
+
+    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()
+    }
 
-// run tests
-;(async function () {
-  if (poolMode) {
-    await runPoolTests()
-  } else if (mocha.suite.total()) {
-    await runTests()
+    // 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)
   }
 })()
 
@@ -123,6 +160,9 @@ async function runPoolTests() {
   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 = []
@@ -131,25 +171,42 @@ async function runPoolTests() {
 
   // Keep requesting tests until no more available
   while (true) {
-    // Request a test assignment
-    sendToParentThread({ type: 'REQUEST_TEST', workerIndex })
-
+    // Request a test assignment and wait for response
     const testResult = await new Promise((resolve, reject) => {
-      // Set up pool mode message handler
+      // 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') {
-          const testUid = eventData.test
+          // 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 {
-            // In pool mode, we need to create a fresh Mocha instance for each test
-            // because Mocha instances become disposed after running tests
-            container.createMocha() // Create fresh Mocha instance
-            filterTestById(testUid)
+            // 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 the test and complete
-              await codecept.run()
+              // 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()
@@ -179,24 +236,26 @@ async function runPoolTests() {
               }
             }
 
-            // Signal test completed and request next
-            parentPort?.off('message', messageHandler)
+            // Signal test completed
             resolve('TEST_COMPLETED')
           } catch (err) {
-            parentPort?.off('message', messageHandler)
             reject(err)
           }
         } else if (eventData.type === 'NO_MORE_TESTS') {
           // No tests available, exit worker
-          parentPort?.off('message', messageHandler)
           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
@@ -205,6 +264,9 @@ async function runPoolTests() {
     }
   }
 
+  // Emit event.all.after once at the end of pool mode
+  event.dispatcher.emit(event.all.after, codecept)
+
   try {
     await codecept.teardown()
   } catch (err) {
@@ -232,70 +294,38 @@ async function runPoolTests() {
 }
 
 function filterTestById(testUid) {
-  // Reload test files fresh for each test in pool mode
-  const files = codecept.testFiles
-
+  // 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 = []
 
-  // Clear require cache for test files to ensure fresh loading
-  files.forEach(file => {
-    delete require.cache[require.resolve(file)]
-  })
-
-  // Set files and load them
-  mocha.files = files
-  mocha.loadFiles()
-
-  // Now filter to only the target test - use a more robust approach
+  // Find and add only the suite containing our target test
   let foundTest = false
-  for (const suite of mocha.suite.suites) {
+  for (const suite of allSuites) {
     const originalTests = [...suite.tests]
-    suite.tests = []
-
-    for (const test of originalTests) {
-      if (test.uid === testUid) {
-        suite.tests.push(test)
-        foundTest = true
-        break // Only add one matching test
-      }
-    }
-
-    // If no tests found in this suite, remove it
-    if (suite.tests.length === 0) {
-      suite.parent.suites = suite.parent.suites.filter(s => s !== suite)
+    
+    // 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
     }
   }
 
-  // Filter out empty suites from the root
-  mocha.suite.suites = mocha.suite.suites.filter(suite => suite.tests.length > 0)
-
   if (!foundTest) {
-    // If testUid doesn't match, maybe it's a simple test name - try fallback
-    mocha.suite.suites = []
-    mocha.suite.tests = []
-    mocha.loadFiles()
-
-    // Try matching by title
-    for (const suite of mocha.suite.suites) {
-      const originalTests = [...suite.tests]
-      suite.tests = []
-
-      for (const test of originalTests) {
-        if (test.title === testUid || test.fullTitle() === testUid || test.uid === testUid) {
-          suite.tests.push(test)
-          foundTest = true
-          break
-        }
-      }
-    }
-
-    // Clean up empty suites again
-    mocha.suite.suites = mocha.suite.suites.filter(suite => suite.tests.length > 0)
+    console.error(`WARNING: Test with UID ${testUid} not found in mocha suites`)
   }
 }
 
@@ -311,27 +341,36 @@ function filterTests() {
 
 function initializeListeners() {
   // suite
-  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: suite.simplify() }))
-  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: suite.simplify() }))
+  event.dispatcher.on(event.suite.before, suite => safelySendToParent({ event: event.suite.before, workerIndex, data: suite.simplify() }))
+  event.dispatcher.on(event.suite.after, suite => safelySendToParent({ event: event.suite.after, workerIndex, data: suite.simplify() }))
 
   // calculate duration
   event.dispatcher.on(event.test.started, test => (test.start = new Date()))
 
   // tests
-  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: test.simplify() }))
-  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.before, test => safelySendToParent({ event: event.test.before, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.after, test => safelySendToParent({ event: event.test.after, workerIndex, data: test.simplify() }))
   // we should force-send correct errors to prevent race condition
-  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: { ...test.simplify(), err } }))
-  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: { ...test.simplify(), err } }))
-  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: { ...test.simplify(), err } }))
-  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: test.simplify() }))
-  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.finished, (test, err) => {
+    const simplifiedData = test.simplify()
+    const serializableErr = serializeError(err)
+    safelySendToParent({ event: event.test.finished, workerIndex, data: { ...simplifiedData, err: serializableErr } })
+  })
+  event.dispatcher.on(event.test.failed, (test, err, hookName) => {
+    const simplifiedData = test.simplify()
+    const serializableErr = serializeError(err)
+    // 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() }))
+  event.dispatcher.on(event.test.skipped, test => safelySendToParent({ event: event.test.skipped, workerIndex, data: test.simplify() }))
 
   // steps
-  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: step.simplify() }))
-  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: step.simplify() }))
-  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: step.simplify() }))
-  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.finished, step => safelySendToParent({ event: event.step.finished, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.started, step => safelySendToParent({ event: event.step.started, workerIndex, data: step.simplify() }))
+  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) => 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() }))
@@ -357,6 +396,50 @@ function disablePause() {
   global.pause = () => {}
 }
 
+function serializeError(err) {
+  if (!err) return null
+  try {
+    return {
+      message: err.message,
+      stack: err.stack,
+      name: err.name,
+      actual: err.actual,
+      expected: err.expected,
+    }
+  } catch {
+    return { message: 'Error could not be serialized', name: 'Error' }
+  }
+}
+
+function safelySendToParent(data) {
+  try {
+    parentPort?.postMessage(data)
+  } catch (cloneError) {
+    // Fallback for non-serializable data
+    const fallbackData = { ...data }
+
+    // Try to serialize error objects if present
+    if (fallbackData.data && fallbackData.data.err) {
+      fallbackData.data.err = serializeError(fallbackData.data.err)
+    }
+
+    // If still fails, send minimal data
+    try {
+      parentPort?.postMessage(fallbackData)
+    } catch (finalError) {
+      parentPort?.postMessage({
+        event: data.event,
+        workerIndex,
+        data: {
+          title: fallbackData.data?.title || 'Unknown',
+          state: fallbackData.data?.state || 'error',
+          err: { message: 'Data could not be serialized' },
+        },
+      })
+    }
+  }
+}
+
 function sendToParentThread(data) {
   parentPort?.postMessage(data)
 }