codeceptjs 4.0.1-beta.9 → 4.0.2-beta.10

package/bin/codecept.js

@@ -174,7 +174,7 @@ program
   .option('-R, --reporter <name>', 'specify the reporter to use')
   .option('-S, --sort', 'sort test files')
   .option('-b, --bail', 'bail after first test failure')
-  .option('-d, --debug', "enable node's debugger, synonym for node --debug")
+  .option('--inspec', "enable node's debugger, synonym for node --debug")
   .option('-g, --grep <pattern>', 'only run tests matching <pattern>')
   .option('-f, --fgrep <string>', 'only run tests containing <string>')
   .option('-i, --invert', 'inverts --grep and --fgrep matches')
@@ -276,7 +276,7 @@ program
   .option('-R, --reporter <name>', 'specify the reporter to use')
   .option('-S, --sort', 'sort test files')
   .option('-b, --bail', 'bail after first test failure')
-  .option('-d, --debug', "enable node's debugger, synonym for node --debug")
+  .option('--inspect', "enable node's debugger, synonym for node --debug")
   .option('-g, --grep <pattern>', 'only run tests matching <pattern>')
   .option('-f, --fgrep <string>', 'only run tests containing <string>')
   .option('-i, --invert', 'inverts --grep and --fgrep matches')

package/lib/command/definitions.js

@@ -41,7 +41,7 @@ const getDefinitionsFileContent = ({ hasCustomHelper, hasCustomStepsFile, helper
 
   const importPathsFragment = importPaths.join('\n')
   const supportObjectsTypeFragment = convertMapToType(supportObject)
-  const methodsTypeFragment = helperNames.length > 0 ? `interface Methods extends ${helperNames.join(', ')} {}` : ''
+  const methodsTypeFragment = helperNames.length > 0 ? `interface Methods extends ${helperNames.join(', ')} {}` : 'interface Methods {}'
   const translatedActionsFragment = JSON.stringify(translations.vocabulary.actions, null, 2)
 
   return generateDefinitionsContent({
@@ -239,8 +239,13 @@ function getImportString(testsPath, targetFolderPath, pathsToType, pathsToValue)
   }
 
   for (const name in pathsToValue) {
-    const relativePath = getPath(pathsToValue[name], targetFolderPath, testsPath)
-    importStrings.push(`type ${name} = import('${relativePath}');`)
+    const originalPath = pathsToValue[name]
+    const relativePath = getPath(originalPath, targetFolderPath, testsPath)
+    if (originalPath.endsWith('.js') || originalPath.endsWith('.ts')) {
+      importStrings.push(`type ${name} = InstanceType<typeof import('${relativePath}').default>;`)
+    } else {
+      importStrings.push(`type ${name} = import('${relativePath}');`)
+    }
   }
 
   return importStrings

package/lib/command/run-workers.js

@@ -40,11 +40,22 @@ export default async function (workerCount, selectedRuns, options) {
 
   output.print(`CodeceptJS v${Codecept.version()} ${output.standWithUkraine()}`)
   output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`)
-  output.print()
   store.hasWorkers = true
 
   const workers = new Workers(numberOfWorkers, config)
   workers.overrideConfig(overrideConfigs)
+  
+  // Show test distribution after workers are initialized
+  await workers.bootstrapAll()
+  
+  const workerObjects = workers.getWorkers()
+  output.print()
+  output.print('Test distribution:')
+  workerObjects.forEach((worker, index) => {
+    const testCount = worker.tests.length
+    output.print(`  Worker ${index + 1}: ${testCount} test${testCount !== 1 ? 's' : ''}`)
+  })
+  output.print()
 
   workers.on(event.test.failed, test => {
     output.test.failed(test)
@@ -68,7 +79,6 @@ export default async function (workerCount, selectedRuns, options) {
     if (options.verbose) {
       await getMachineInfo()
     }
-    await workers.bootstrapAll()
     await workers.run()
   } catch (err) {
     output.error(err)

package/lib/command/workers/runTests.js

@@ -19,6 +19,29 @@ const stderr = ''
 
 const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
+// Global error handlers to catch critical errors but not test failures
+process.on('uncaughtException', (err) => {
+  // Don't exit on test assertion errors - those are handled by mocha
+  if (err.name === 'AssertionError' || err.message?.includes('expected')) {
+    console.error(`[Worker ${workerIndex}] Test assertion error (handled by mocha):`, err.message)
+    return
+  }
+  console.error(`[Worker ${workerIndex}] Uncaught exception:`, err.message)
+  console.error(err.stack)
+  process.exit(1)
+})
+
+process.on('unhandledRejection', (reason, promise) => {
+  // Don't exit on test-related rejections
+  const msg = reason?.message || String(reason)
+  if (msg.includes('expected') || msg.includes('AssertionError')) {
+    console.error(`[Worker ${workerIndex}] Test rejection (handled by mocha):`, msg)
+    return
+  }
+  console.error(`[Worker ${workerIndex}] Unhandled rejection:`, reason)
+  process.exit(1)
+})
+
 // 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
@@ -82,6 +105,8 @@ let config
 // Load test and run
 initPromise = (async function () {
   try {
+    console.log(`[Worker ${workerIndex}] Starting initialization...`)
+    
     // 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')
@@ -89,6 +114,8 @@ initPromise = (async function () {
     const coreUtilsModule = await import('../../utils.js')
     const CodeceptModule = await import('../../codecept.js')
     
+    console.log(`[Worker ${workerIndex}] Modules imported`)
+    
     event = eventModule.default
     container = containerModule.default
     getConfig = utilsModule.getConfig
@@ -98,14 +125,24 @@ initPromise = (async function () {
     
     const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
     
+    console.log(`[Worker ${workerIndex}] Loading config...`)
+    
     // IMPORTANT: await is required here since getConfig is async
     const baseConfig = await getConfig(options.config || testRoot)
     
+    console.log(`[Worker ${workerIndex}] Config loaded, creating Codecept...`)
+    
     // important deep merge so dynamic things e.g. functions on config are not overridden
     config = deepMerge(baseConfig, overrideConfigs)
     
-    codecept = new Codecept(config, options)
+    // Pass workerIndex as child option for output.process() to display worker prefix
+    const optsWithChild = { ...options, child: workerIndex }
+    codecept = new Codecept(config, optsWithChild)
+    
+    console.log(`[Worker ${workerIndex}] Initializing Codecept...`)
     await codecept.init(testRoot)
+    
+    console.log(`[Worker ${workerIndex}] Loading tests...`)
     codecept.loadTests()
     mocha = container.mocha()
 
@@ -114,9 +151,14 @@ initPromise = (async function () {
       // We'll reload test files fresh for each test request
     } else {
       // Legacy mode - filter tests upfront
+      console.log(`[Worker ${workerIndex}] Starting test filtering. Assigned ${tests.length} test UIDs`)
       filterTests()
+      const finalCount = mocha.suite.total()
+      console.log(`[Worker ${workerIndex}] After filtering: ${finalCount} tests to run`)
     }
 
+    console.log(`[Worker ${workerIndex}] Initialization complete, starting tests...`)
+
     // run tests
     if (poolMode) {
       await runPoolTests()
@@ -124,10 +166,12 @@ 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)
+    console.error(`[Worker ${workerIndex}] FATAL ERROR:`, err.message)
+    console.error(err.stack)
     process.exit(1)
   }
 })()
@@ -138,6 +182,7 @@ async function runTests() {
   try {
     await codecept.bootstrap()
   } catch (err) {
+    console.error(`[Worker ${workerIndex}] Bootstrap error:`, err.message)
     throw new Error(`Error while running bootstrap file :${err}`)
   }
   listenToParentThread()
@@ -145,8 +190,15 @@ async function runTests() {
   disablePause()
   try {
     await codecept.run()
+  } catch (err) {
+    console.error(`[Worker ${workerIndex}] Runtime error:`, err.message)
+    throw err
   } finally {
-    await codecept.teardown()
+    try {
+      await codecept.teardown()
+    } catch (err) {
+      console.error(`[Worker ${workerIndex}] Teardown error:`, err.message)
+    }
   }
 }
 
@@ -334,8 +386,36 @@ function filterTests() {
   mocha.files = files
   mocha.loadFiles()
 
-  for (const suite of mocha.suite.suites) {
+  // Collect all loaded tests for debugging
+  const allLoadedTests = [];
+  mocha.suite.eachTest(test => {
+    if (test) {
+      allLoadedTests.push({ uid: test.uid, title: test.fullTitle() });
+    }
+  });
+  
+  console.log(`[Worker ${workerIndex}] Loaded ${allLoadedTests.length} tests from ${files.length} files`);
+  console.log(`[Worker ${workerIndex}] Expecting ${tests.length} test UIDs`);
+  
+  const loadedUids = new Set(allLoadedTests.map(t => t.uid));
+  const missingTests = tests.filter(uid => !loadedUids.has(uid));
+  
+  if (missingTests.length > 0) {
+    console.error(`[Worker ${workerIndex}] ERROR: ${missingTests.length} assigned tests NOT FOUND in loaded files!`);
+    console.error(`[Worker ${workerIndex}] Missing UIDs:`, missingTests);
+    console.error(`[Worker ${workerIndex}] Available UIDs:`, Array.from(loadedUids).slice(0, 5), '...');
+  }
+
+  // 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',
@@ -159,12 +159,13 @@ async function loadConfigFile(configFile) {
         try {
           // Use the TypeScript transpilation utility
           const typescript = require('typescript')
-          const { tempFile, allTempFiles } = await transpileTypeScript(configFile, typescript)
+          const { tempFile, allTempFiles, fileMapping } = await transpileTypeScript(configFile, typescript)
 
           try {
             configModule = await import(tempFile)
             cleanupTempFiles(allTempFiles)
           } catch (err) {
+            fixErrorStack(err, fileMapping)
             cleanupTempFiles(allTempFiles)
             throw err
           }

package/lib/container.js

@@ -5,7 +5,7 @@ import debugModule from 'debug'
 const debug = debugModule('codeceptjs:container')
 import { MetaStep } from './step.js'
 import { methodsOfObject, fileExists, isFunction, isAsyncFunction, installedLocally, deepMerge } from './utils.js'
-import { transpileTypeScript, cleanupTempFiles } from './utils/typescript.js'
+import { transpileTypeScript, cleanupTempFiles, fixErrorStack } from './utils/typescript.js'
 import Translation from './translation.js'
 import MochaFactory from './mocha/factory.js'
 import recorder from './recorder.js'
@@ -34,6 +34,7 @@ let container = {
   /** @type {Result | null} */
   result: null,
   sharedKeys: new Set(), // Track keys shared via share() function
+  tsFileMapping: null, // TypeScript file mapping for error stack fixing
 }
 
 /**
@@ -88,7 +89,7 @@ class Container {
           container.support.I = mod
         }
       } catch (e) {
-        throw new Error(`Could not include object I: ${e.message}`)
+        throw e
       }
     } else {
       // Create default actor - this sets up the callback in asyncHelperPromise
@@ -176,6 +177,15 @@ class Container {
     return container.translation
   }
 
+  /**
+   * Get TypeScript file mapping for error stack fixing
+   *
+   * @api
+   */
+  static tsFileMapping() {
+    return container.tsFileMapping
+  }
+
   /**
    * Get Mocha instance
    *
@@ -398,20 +408,66 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
       throw err
     }
   } else {
+    // Handle TypeScript files
+    let importPath = moduleName
+    let tempJsFile = null
+    let fileMapping = null
+    const ext = path.extname(moduleName)
+
+    if (ext === '.ts') {
+      try {
+        // Use the TypeScript transpilation utility
+        const typescript = await import('typescript')
+        const { tempFile, allTempFiles, fileMapping: mapping } = await transpileTypeScript(importPath, typescript)
+
+        debug(`Transpiled TypeScript helper: ${importPath} -> ${tempFile}`)
+
+        importPath = tempFile
+        tempJsFile = allTempFiles
+        fileMapping = mapping
+        // Store file mapping in container for runtime error fixing (merge with existing)
+        if (!container.tsFileMapping) {
+          container.tsFileMapping = new Map()
+        }
+        for (const [key, value] of mapping.entries()) {
+          container.tsFileMapping.set(key, value)
+        }
+      } catch (tsError) {
+        throw new Error(`Failed to load TypeScript helper ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
+      }
+    }
+
     // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
     try {
       // Try dynamic import for both CommonJS and ESM modules
-      const mod = await import(moduleName)
+      const mod = await import(importPath)
       if (!mod && !mod.default) {
         throw new Error(`Helper module '${moduleName}' was not found. Make sure you have installed the package correctly.`)
       }
       HelperClass = mod.default || mod
+
+      // Clean up temp files if created
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
     } catch (err) {
+      // Fix error stack to point to original .ts files
+      if (fileMapping) {
+        fixErrorStack(err, fileMapping)
+      }
+      
+      // Clean up temp files before rethrowing
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
+
       if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES module'))) {
         // This is an ESM module, use dynamic import
         try {
           const pathModule = await import('path')
-          const absolutePath = pathModule.default.resolve(moduleName)
+          const absolutePath = pathModule.default.resolve(importPath)
           const mod = await import(absolutePath)
           HelperClass = mod.default || mod
           debug(`helper ${helperName} loaded via ESM import`)
@@ -699,6 +755,7 @@ async function loadSupportObject(modulePath, supportObjectName) {
     // Use dynamic import for both ESM and CJS modules
     let importPath = modulePath
     let tempJsFile = null
+    let fileMapping = null
 
     if (typeof importPath === 'string') {
       const ext = path.extname(importPath)
@@ -708,7 +765,7 @@ async function loadSupportObject(modulePath, supportObjectName) {
         try {
           // Use the TypeScript transpilation utility
           const typescript = await import('typescript')
-          const { tempFile, allTempFiles } = await transpileTypeScript(importPath, typescript)
+          const { tempFile, allTempFiles, fileMapping: mapping } = await transpileTypeScript(importPath, typescript)
 
           debug(`Transpiled TypeScript file: ${importPath} -> ${tempFile}`)
 
@@ -716,6 +773,14 @@ async function loadSupportObject(modulePath, supportObjectName) {
           importPath = tempFile
           // Store temp files list in a way that cleanup can access them
           tempJsFile = allTempFiles
+          fileMapping = mapping
+          // Store file mapping in container for runtime error fixing (merge with existing)
+          if (!container.tsFileMapping) {
+            container.tsFileMapping = new Map()
+          }
+          for (const [key, value] of mapping.entries()) {
+            container.tsFileMapping.set(key, value)
+          }
         } catch (tsError) {
           throw new Error(`Failed to load TypeScript file ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
         }
@@ -729,6 +794,11 @@ async function loadSupportObject(modulePath, supportObjectName) {
     try {
       obj = await import(importPath)
     } catch (importError) {
+      // Fix error stack to point to original .ts files
+      if (fileMapping) {
+        fixErrorStack(importError, fileMapping)
+      }
+      
       // Clean up temp files if created before rethrowing
       if (tempJsFile) {
         const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
@@ -777,7 +847,9 @@ async function loadSupportObject(modulePath, supportObjectName) {
 
     throw new Error(`Support object "${supportObjectName}" should be an object, class, or function, but got ${typeof actualObj}`)
   } catch (err) {
-    throw new Error(`Could not include object ${supportObjectName} from module '${modulePath}'\n${err.message}\n${err.stack}`)
+    const newErr = new Error(`Could not include object ${supportObjectName} from module '${modulePath}': ${err.message}`)
+    newErr.stack = err.stack
+    throw newErr
   }
 }