codeceptjs 4.0.0-beta.5 → 4.0.0-beta.6.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,20 +7,20 @@ 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'
+import event from '../../event.js'
+import container from '../../container.js'
+import { getConfig } from '../utils.js'
+import { tryOrDefault, deepMerge } from '../../utils.js'
 
 let stdout = ''
 
 const stderr = ''
 
-// Requiring of Codecept need to be after tty.getWindowSize is available.
-const Codecept = require(process.env.CODECEPT_CLASS_PATH || '../../codecept')
+// Importing of Codecept need to be after tty.getWindowSize is available.
+import Codecept from '../../codecept.js'
 
-const { options, tests, testRoot, workerIndex, poolMode } = workerData
+const { options, tests, testRoot, workerIndex } = workerData
 
 // hide worker output
 if (!options.debug && !options.verbose)
@@ -35,288 +35,139 @@ const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
 const config = deepMerge(getConfig(options.config || testRoot), overrideConfigs)
 
 // 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()
-}
-
-// run tests
 ;(async function () {
-  if (poolMode) {
-    await runPoolTests()
-  } else if (mocha.suite.total()) {
-    await runTests()
-  }
-})()
-
-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()
-
-  // 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
-    sendToParentThread({ type: 'REQUEST_TEST', workerIndex })
-
-    const testResult = await new Promise((resolve, reject) => {
-      // Set up pool mode message handler
-      const messageHandler = async eventData => {
-        if (eventData.type === 'TEST_ASSIGNED') {
-          const testUid = 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)
-            const mocha = container.mocha()
-
-            if (mocha.suite.total() > 0) {
-              // Run the test and complete
-              await codecept.run()
-
-              // 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 and request next
-            parentPort?.off('message', messageHandler)
-            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 })
-        }
-      }
-
-      parentPort?.on('message', messageHandler)
-    })
-
-    // Exit if no more tests
-    if (testResult === 'NO_MORE_TESTS') {
-      break
-    }
-  }
-
-  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) {
-  // Reload test files fresh for each test in pool mode
-  const files = codecept.testFiles
-
-  // Get the existing mocha instance
+  const codecept = new Codecept(config, options)
+  await codecept.init(testRoot)
+  codecept.loadTests()
   const mocha = container.mocha()
 
-  // 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
-  let foundTest = false
-  for (const suite of mocha.suite.suites) {
-    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)
-    }
-  }
-
-  // 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 = []
+  function filterTests() {
+    const files = codecept.testFiles
+    mocha.files = files
     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
-        }
-      }
+      suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
     }
+  }
 
-    // Clean up empty suites again
-    mocha.suite.suites = mocha.suite.suites.filter(suite => suite.tests.length > 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()
+    }
   }
-}
 
-function filterTests() {
-  const files = codecept.testFiles
-  mocha.files = files
-  mocha.loadFiles()
+  filterTests()
 
-  for (const suite of mocha.suite.suites) {
-    suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
+  // run tests
+  if (mocha.suite.total()) {
+    await runTests()
   }
-}
+})()
 
 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) => {
+    const simplifiedData = test.simplify()
+    const serializableErr = serializeError(err)
+    safelySendToParent({ event: event.test.failed, workerIndex, data: { ...simplifiedData, err: serializableErr } })
+  })
+  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) => {
+    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() }))
+function disablePause() {
+  global.pause = () => {}
+}
 
-  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 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 disablePause() {
-  global.pause = () => {}
+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) {
@@ -324,10 +175,7 @@ function sendToParentThread(data) {
 }
 
 function listenToParentThread() {
-  if (!poolMode) {
-    parentPort?.on('message', eventData => {
-      container.append({ support: eventData.data })
-    })
-  }
-  // In pool mode, message handling is done in runPoolTests()
+  parentPort?.on('message', eventData => {
+    container.append({ support: eventData.data })
+  })
 }

package/lib/config.js

@@ -1,11 +1,7 @@
-const fs = require('fs');
-const path = require('path');
-const {
-  fileExists,
-  isFile,
-  deepMerge,
-  deepClone,
-} = require('./utils');
+import fs from 'fs'
+import path from 'path'
+import { createRequire } from 'module'
+import { fileExists, isFile, deepMerge, deepClone } from './utils.js'
 
 const defaultConfig = {
   output: './_output',
@@ -33,18 +29,12 @@ const defaultConfig = {
       timeout: 0,
     },
   ],
-};
+}
 
-let hooks = [];
-let config = {};
+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.ts', 'codecept.conf.ts']
 
 /**
  * Current configuration
@@ -57,9 +47,9 @@ class Config {
    * @return {Object<string, *>}
    */
   static create(newConfig) {
-    config = deepMerge(deepClone(defaultConfig), newConfig);
-    hooks.forEach(f => f(config));
-    return config;
+    config = deepMerge(deepClone(defaultConfig), newConfig)
+    hooks.forEach(f => f(config))
+    return config
   }
 
   /**
@@ -75,34 +65,34 @@ class Config {
    * @param {string} configFile
    * @return {*}
    */
-  static load(configFile) {
-    configFile = path.resolve(configFile || '.');
+  static async load(configFile) {
+    configFile = path.resolve(configFile || '.')
 
     if (!fileExists(configFile)) {
-      configFile = configFile.replace('.js', '.ts');
+      configFile = configFile.replace('.js', '.ts')
 
       if (!fileExists(configFile)) {
-        throw new Error(`Config file ${configFile} does not exist. Execute 'codeceptjs init' to create config`);
+        throw new Error(`Config file ${configFile} does not exist. Execute 'codeceptjs init' to create config`)
       }
     }
 
     // is config file
     if (isFile(configFile)) {
-      return loadConfigFile(configFile);
+      return await loadConfigFile(configFile)
     }
 
     for (const name of configFileNames) {
       // is path to directory
-      const jsConfig = path.join(configFile, name);
+      const jsConfig = path.join(configFile, name)
 
       if (isFile(jsConfig)) {
-        return loadConfigFile(jsConfig);
+        return await loadConfigFile(jsConfig)
       }
     }
 
-    const configPaths = configFileNames.map(name => path.join(configFile, name)).join(' or ');
+    const configPaths = configFileNames.map(name => path.join(configFile, name)).join(' or ')
 
-    throw new Error(`Can not load config from ${configPaths}\nCodeceptJS is not initialized in this dir. Execute 'codeceptjs init' to start`);
+    throw new Error(`Can not load config from ${configPaths}\nCodeceptJS is not initialized in this dir. Execute 'codeceptjs init' to start`)
   }
 
   /**
@@ -113,13 +103,13 @@ class Config {
    */
   static get(key, val) {
     if (key) {
-      return config[key] || val;
+      return config[key] || val
     }
-    return config;
+    return config
   }
 
   static addHook(fn) {
-    hooks.push(fn);
+    hooks.push(fn)
   }
 
   /**
@@ -129,7 +119,7 @@ class Config {
    * @return {Object<string, *>}
    */
   static append(additionalConfig) {
-    return config = deepMerge(config, additionalConfig);
+    return (config = deepMerge(config, additionalConfig))
   }
 
   /**
@@ -137,33 +127,105 @@ class Config {
    * @return {Object<string, *>}
    */
   static reset() {
-    hooks = [];
-    return config = { ...defaultConfig };
+    hooks = []
+    return (config = { ...defaultConfig })
   }
 }
 
-module.exports = Config;
+export default Config
 
-function loadConfigFile(configFile) {
-  const extensionName = path.extname(configFile);
+async function loadConfigFile(configFile) {
+  const require = createRequire(import.meta.url)
+  const extensionName = path.extname(configFile)
 
-  if (extensionName === '.ts') {
+  // .conf.js config file
+  if (extensionName === '.js' || extensionName === '.ts' || extensionName === '.cjs') {
+    let configModule
     try {
-      require('ts-node/register');
-    } catch (err) {
-      console.log('ts-node package is required to parse codecept.conf.ts config correctly');
+      // For .ts files, try to compile and load as JavaScript
+      if (extensionName === '.ts') {
+        try {
+          // Try to load ts-node and compile the file
+          const { transpile } = require('typescript')
+          const tsContent = fs.readFileSync(configFile, 'utf8')
+
+          // Transpile TypeScript to JavaScript with ES module output
+          const jsContent = transpile(tsContent, {
+            module: 99, // ModuleKind.ESNext
+            target: 99, // ScriptTarget.ESNext
+            esModuleInterop: true,
+            allowSyntheticDefaultImports: true,
+          })
+
+          // Create a temporary JS file with .mjs extension to force ES module treatment
+          const tempJsFile = configFile.replace('.ts', '.temp.mjs')
+          fs.writeFileSync(tempJsFile, jsContent)
+
+          try {
+            configModule = await import(tempJsFile)
+            // Clean up temp file
+            fs.unlinkSync(tempJsFile)
+          } catch (err) {
+            // Clean up temp file even on error
+            if (fs.existsSync(tempJsFile)) {
+              fs.unlinkSync(tempJsFile)
+            }
+            throw err
+          }
+        } 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}`)
+          }
+        }
+      } else {
+        // Try ESM import first for JS files
+        configModule = await import(configFile)
+      }
+    } catch (importError) {
+      try {
+        // Fall back to CommonJS require for .js/.cjs files
+        if (extensionName !== '.ts') {
+          configModule = require(configFile)
+        } else {
+          throw importError
+        }
+      } catch (requireError) {
+        throw new Error(`Failed to load config file ${configFile}: ${importError.message}`)
+      }
     }
-  }
 
-  // .conf.js config file
-  if (extensionName === '.js' || extensionName === '.ts' || extensionName === '.cjs') {
-    return Config.create(require(configFile).config);
+    const rawConfig = configModule.config || configModule.default?.config || configModule
+
+    // Process helpers to extract imported classes
+    if (rawConfig.helpers) {
+      const processedHelpers = {}
+      for (const [helperName, helperConfig] of Object.entries(rawConfig.helpers)) {
+        // Check if the helper name itself is a class (ESM import)
+        if (typeof helperName === 'function' && helperName.prototype) {
+          // This is an imported class, use its constructor name
+          const className = helperName.name
+          processedHelpers[className] = {
+            ...helperConfig,
+            _helperClass: helperName,
+          }
+        } else {
+          processedHelpers[helperName] = helperConfig
+        }
+      }
+      rawConfig.helpers = processedHelpers
+    }
+
+    return Config.create(rawConfig)
   }
 
   // json config provided
   if (extensionName === '.json') {
-    return Config.create(JSON.parse(fs.readFileSync(configFile, 'utf8')));
+    return Config.create(JSON.parse(fs.readFileSync(configFile, 'utf8')))
   }
 
-  throw new Error(`Config file ${configFile} can't be loaded`);
+  throw new Error(`Config file ${configFile} can't be loaded`)
 }