codeceptjs 4.0.0-beta.9.esm-aria → 4.0.0-rc.10

package/lib/utils.js

@@ -150,6 +150,24 @@ export const decodeUrl = function (url) {
   return decodeURIComponent(decodeURIComponent(decodeURIComponent(url)))
 }
 
+export const normalizePath = function (path) {
+  if (path === '' || path === '/') return '/'
+  return path
+    .replace(/\/+/g, '/')
+    .replace(/\/$/, '') || '/'
+}
+
+export const resolveUrl = function (url, baseUrl) {
+  if (!url) return url
+  if (url.indexOf('http') === 0) return url
+  if (!baseUrl) return url
+  try {
+    return new URL(url, baseUrl).href
+  } catch (e) {
+    return url
+  }
+}
+
 export const xpathLocator = {
   /**
    * @param {string} string
@@ -640,6 +658,36 @@ export const base64EncodeFile = function (filePath) {
   return Buffer.from(fs.readFileSync(filePath)).toString('base64')
 }
 
+export const getMimeType = function (fileName) {
+  const ext = path.extname(fileName).toLowerCase()
+  const mimeTypes = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.zip': 'application/zip',
+    '.csv': 'text/csv',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.wav': 'audio/wav',
+  }
+  return mimeTypes[ext] || 'application/octet-stream'
+}
+
 export const markdownToAnsi = function (markdown) {
   return (
     markdown

package/lib/workers.js

@@ -5,6 +5,7 @@ import { mkdirp } from 'mkdirp'
 import { Worker } from 'worker_threads'
 import { EventEmitter } from 'events'
 import ms from 'ms'
+import merge from 'lodash.merge'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -27,7 +28,7 @@ const pathToWorker = path.join(__dirname, 'command', 'workers', 'runTests.js')
 
 const initializeCodecept = async (configPath, options = {}) => {
   const config = await mainConfig.load(configPath || '.')
-  const codecept = new Codecept(config, options)
+  const codecept = new Codecept(config, { ...options, skipDefaultListeners: true })
   await codecept.init(getTestRoot(configPath))
   codecept.loadTests()
 
@@ -66,21 +67,21 @@ const createWorker = (workerObject, isPoolMode = false) => {
     stdout: true,
     stderr: true,
   })
-  
+
   // Pipe worker stdout/stderr to main process
   if (worker.stdout) {
     worker.stdout.setEncoding('utf8')
-    worker.stdout.on('data', (data) => {
+    worker.stdout.on('data', data => {
       process.stdout.write(data)
     })
   }
   if (worker.stderr) {
     worker.stderr.setEncoding('utf8')
-    worker.stderr.on('data', (data) => {
+    worker.stderr.on('data', data => {
       process.stderr.write(data)
     })
   }
-  
+
   worker.on('error', err => {
     console.error(`[Main] Worker Error:`, err)
     output.error(`Worker Error: ${err.stack}`)
@@ -221,13 +222,14 @@ class WorkerObject {
 
   addConfig(config) {
     const oldConfig = JSON.parse(this.options.override || '{}')
-    
+
     // Remove customLocatorStrategies from both old and new config before JSON serialization
-    // since functions cannot be serialized and will be lost, causing workers to have empty strategies
+    // since functions cannot be serialized and will be lost, causing workers to have empty strategies.
+    // Note: Only WebDriver helper supports customLocatorStrategies
     const configWithoutFunctions = { ...config }
-    
+
     // Clean both old and new config
-    const cleanConfig = (cfg) => {
+    const cleanConfig = cfg => {
       if (cfg.helpers) {
         cfg.helpers = { ...cfg.helpers }
         Object.keys(cfg.helpers).forEach(helperName => {
@@ -239,14 +241,12 @@ class WorkerObject {
       }
       return cfg
     }
-    
+
     const cleanedOldConfig = cleanConfig(oldConfig)
     const cleanedNewConfig = cleanConfig(configWithoutFunctions)
-    
-    const newConfig = {
-      ...cleanedOldConfig,
-      ...cleanedNewConfig,
-    }
+
+    // Deep merge configurations to preserve all helpers from base config
+    const newConfig = merge({}, cleanedOldConfig, cleanedNewConfig)
     this.options.override = JSON.stringify(newConfig)
   }
 
@@ -280,8 +280,8 @@ class Workers extends EventEmitter {
     this.setMaxListeners(50)
     this.codeceptPromise = initializeCodecept(config.testConfig, config.options)
     this.codecept = null
-    this.config = config  // Save config
-    this.numberOfWorkersRequested = numberOfWorkers  // Save requested worker count
+    this.config = config // Save config
+    this.numberOfWorkersRequested = numberOfWorkers // Save requested worker count
     this.options = config.options || {}
     this.errors = []
     this.numberOfWorkers = 0
@@ -304,11 +304,8 @@ class Workers extends EventEmitter {
       // Initialize workers in these cases:
       // 1. Positive number requested AND no manual workers pre-spawned
       // 2. Function-based grouping (indicated by negative number) AND no manual workers pre-spawned
-      const shouldAutoInit = this.workers.length === 0 && (
-        (Number.isInteger(this.numberOfWorkersRequested) && this.numberOfWorkersRequested > 0) ||
-        (this.numberOfWorkersRequested < 0 && isFunction(this.config.by))
-      )
-      
+      const shouldAutoInit = this.workers.length === 0 && ((Number.isInteger(this.numberOfWorkersRequested) && this.numberOfWorkersRequested > 0) || (this.numberOfWorkersRequested < 0 && isFunction(this.config.by)))
+
       if (shouldAutoInit) {
         this._initWorkers(this.numberOfWorkersRequested, this.config)
       }
@@ -319,7 +316,7 @@ class Workers extends EventEmitter {
     this.splitTestsByGroups(numberOfWorkers, config)
     // For function-based grouping, use the actual number of test groups created
     const actualNumberOfWorkers = isFunction(config.by) ? this.testGroups.length : numberOfWorkers
-    this.workers = createWorkerObjects(this.testGroups, this.codecept.config, config.testConfig, config.options, config.selectedRuns)
+    this.workers = createWorkerObjects(this.testGroups, this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
     this.numberOfWorkers = this.workers.length
   }
 
@@ -371,9 +368,12 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfTests(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(numberOfWorkers)
-  const files = this.codecept.testFiles
+    // If Codecept isn't initialized yet, return empty groups as a safe fallback
+    if (!this.codecept) return populateGroups(numberOfWorkers)
+    const files = this.codecept.testFiles
+    
+    // Create a fresh mocha instance to avoid state pollution
+    Container.createMocha(this.codecept.config.mocha || {}, this.options)
     const mocha = Container.mocha()
     mocha.files = files
     mocha.loadFiles()
@@ -388,6 +388,10 @@ class Workers extends EventEmitter {
         groupCounter++
       }
     })
+    
+    // Clean up after collecting test UIDs
+    mocha.unloadFiles()
+    
     return groups
   }
 
@@ -430,7 +434,7 @@ class Workers extends EventEmitter {
     for (const file of files) {
       this.testPool.push(file)
     }
-    
+
     this.testPoolInitialized = true
   }
 
@@ -443,7 +447,7 @@ class Workers extends EventEmitter {
     if (!this.testPoolInitialized) {
       this._initializeTestPool()
     }
-    
+
     return this.testPool.shift()
   }
 
@@ -451,14 +455,17 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfSuites(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(numberOfWorkers)
-  const files = this.codecept.testFiles
+    // If Codecept isn't initialized yet, return empty groups as a safe fallback
+    if (!this.codecept) return populateGroups(numberOfWorkers)
+    const files = this.codecept.testFiles
     const groups = populateGroups(numberOfWorkers)
 
+    // Create a fresh mocha instance to avoid state pollution
+    Container.createMocha(this.codecept.config.mocha || {}, this.options)
     const mocha = Container.mocha()
     mocha.files = files
     mocha.loadFiles()
+    
     mocha.suite.suites.forEach(suite => {
       const i = indexOfSmallestElement(groups)
       suite.tests.forEach(test => {
@@ -467,6 +474,10 @@ class Workers extends EventEmitter {
         }
       })
     })
+    
+    // Clean up after collecting test UIDs
+    mocha.unloadFiles()
+    
     return groups
   }
 
@@ -494,7 +505,7 @@ class Workers extends EventEmitter {
     recorder.startUnlessRunning()
     event.dispatcher.emit(event.workers.before)
     process.env.RUNS_WITH_WORKERS = 'true'
-    
+
     // Create workers and set up message handlers immediately (not in recorder queue)
     // This prevents a race condition where workers start sending messages before handlers are attached
     const workerThreads = []
@@ -503,13 +514,29 @@ class Workers extends EventEmitter {
       this._listenWorkerEvents(workerThread)
       workerThreads.push(workerThread)
     }
-    
+
     recorder.add('workers started', () => {
       // Workers are already running, this is just a placeholder step
     })
-    
+
+    // Add overall timeout to prevent infinite hanging
+    const overallTimeout = setTimeout(() => {
+      console.error('[Main] Overall timeout reached (10 minutes). Force terminating remaining workers...')
+      workerThreads.forEach(w => {
+        try {
+          w.terminate()
+        } catch (e) {
+          // ignore
+        }
+      })
+      this._finishRun()
+    }, 600000) // 10 minutes
+
     return new Promise(resolve => {
-      this.on('end', resolve)
+      this.on('end', () => {
+        clearTimeout(overallTimeout)
+        resolve()
+      })
     })
   }
 
@@ -532,8 +559,32 @@ class Workers extends EventEmitter {
     if (this.isPoolMode) {
       this.activeWorkers.set(worker, { available: true, workerIndex: null })
     }
+    
+    // Track last activity time to detect hanging workers
+    let lastActivity = Date.now()
+    let currentTest = null
+    const workerTimeout = 300000 // 5 minutes
+    
+    const timeoutChecker = setInterval(() => {
+      const elapsed = Date.now() - lastActivity
+      if (elapsed > workerTimeout) {
+        console.error(`[Main] Worker appears to be hanging (no activity for ${Math.floor(elapsed/1000)}s). Terminating...`)
+        if (currentTest) {
+          console.error(`[Main] Last test: ${currentTest}`)
+        }
+        clearInterval(timeoutChecker)
+        worker.terminate()
+      }
+    }, 30000) // Check every 30 seconds
 
     worker.on('message', message => {
+      lastActivity = Date.now() // Update activity timestamp
+      
+      // Track current test
+      if (message.event === event.test.started && message.data) {
+        currentTest = message.data.title || message.data.fullTitle
+      }
+      
       output.process(message.workerIndex)
 
       // Handle test requests for pool mode
@@ -574,13 +625,32 @@ class Workers extends EventEmitter {
 
           break
         case event.suite.before:
-          this.emit(event.suite.before, deserializeSuite(message.data))
+          {
+            const suite = deserializeSuite(message.data)
+            this.emit(event.suite.before, suite)
+            event.dispatcher.emit(event.suite.before, suite)
+          }
+          break
+        case event.suite.after:
+          {
+            const suite = deserializeSuite(message.data)
+            this.emit(event.suite.after, suite)
+            event.dispatcher.emit(event.suite.after, suite)
+          }
           break
         case event.test.before:
-          this.emit(event.test.before, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.before, test)
+            event.dispatcher.emit(event.test.before, test)
+          }
           break
         case event.test.started:
-          this.emit(event.test.started, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.started, test)
+            event.dispatcher.emit(event.test.started, test)
+          }
           break
         case event.test.failed:
           // For hook failures, emit immediately as there won't be a test.finished event
@@ -591,10 +661,14 @@ class Workers extends EventEmitter {
           // Otherwise skip - we'll emit based on finished state
           break
         case event.test.passed:
-          // Skip individual passed events - we'll emit based on finished state  
+          // Skip individual passed events - we'll emit based on finished state
           break
         case event.test.skipped:
-          this.emit(event.test.skipped, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.skipped, test)
+            event.dispatcher.emit(event.test.skipped, test)
+          }
           break
         case event.test.finished:
           // Handle different types of test completion properly
@@ -602,15 +676,15 @@ class Workers extends EventEmitter {
             const data = message.data
             const uid = data?.uid
             const isFailed = !!data?.err || data?.state === 'failed'
-            
+
             if (uid) {
               // Track states for each test UID
               if (!this._testStates) this._testStates = new Map()
-              
+
               if (!this._testStates.has(uid)) {
-                this._testStates.set(uid, { states: [], lastData: data })
+                this._testStates.set(uid, { states: [], lastData: data, workerIndex: message.workerIndex })
               }
-              
+
               const testState = this._testStates.get(uid)
               testState.states.push({ isFailed, data })
               testState.lastData = data
@@ -622,39 +696,72 @@ class Workers extends EventEmitter {
                 this.emit(event.test.passed, deserializeTest(data))
               }
             }
-            
-            this.emit(event.test.finished, deserializeTest(data))
+
+            const test = deserializeTest(data)
+            this.emit(event.test.finished, test)
+            event.dispatcher.emit(event.test.finished, test)
           }
           break
         case event.test.after:
-          this.emit(event.test.after, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.after, test)
+            event.dispatcher.emit(event.test.after, test)
+          }
           break
         case event.step.finished:
           this.emit(event.step.finished, message.data)
+          event.dispatcher.emit(event.step.finished, message.data)
           break
         case event.step.started:
           this.emit(event.step.started, message.data)
+          event.dispatcher.emit(event.step.started, message.data)
           break
         case event.step.passed:
           this.emit(event.step.passed, message.data)
+          event.dispatcher.emit(event.step.passed, message.data)
           break
         case event.step.failed:
           this.emit(event.step.failed, message.data, message.data.error)
+          event.dispatcher.emit(event.step.failed, message.data, message.data.error)
           break
         case event.hook.failed:
           // Hook failures are already reported as test failures by the worker
           // Just emit the hook.failed event for listeners
           this.emit(event.hook.failed, message.data)
+          event.dispatcher.emit(event.hook.failed, message.data)
+          break
+        case event.hook.passed:
+          this.emit(event.hook.passed, message.data)
+          event.dispatcher.emit(event.hook.passed, message.data)
+          break
+        case event.hook.finished:
+          this.emit(event.hook.finished, message.data)
+          event.dispatcher.emit(event.hook.finished, message.data)
           break
       }
     })
 
     worker.on('error', err => {
+      console.error(`[Main] Worker error:`, err.message || err)
+      if (currentTest) {
+        console.error(`[Main] Failed during test: ${currentTest}`)
+      }
       this.errors.push(err)
     })
 
-    worker.on('exit', () => {
+    worker.on('exit', (code) => {
+      clearInterval(timeoutChecker)
       this.closedWorkers += 1
+      
+      if (code !== 0) {
+        console.error(`[Main] Worker exited with code ${code}`)
+        if (currentTest) {
+          console.error(`[Main] Last test running: ${currentTest}`)
+        }
+        // Mark as failed
+        process.exitCode = 1
+      }
 
       if (this.isPoolMode) {
         // Pool mode: finish when all workers have exited and no more tests
@@ -670,7 +777,7 @@ class Workers extends EventEmitter {
 
   _finishRun() {
     event.dispatcher.emit(event.workers.after, { tests: this.workers.map(worker => worker.tests) })
-    if (Container.result().hasFailed) {
+    if (Container.result().hasFailed || this.errors.length > 0) {
       process.exitCode = 1
     } else {
       process.exitCode = 0
@@ -678,15 +785,17 @@ class Workers extends EventEmitter {
 
     // Emit states for all tracked tests before emitting results
     if (this._testStates) {
-      for (const [uid, { states, lastData }] of this._testStates) {
+      for (const [uid, { states, lastData, workerIndex }] of this._testStates) {
+        // Set correct worker index for output
+        output.process(workerIndex)
+
         // For tests with retries configured, emit all failures + final success
         // For tests without retries, emit only final state
         const lastState = states[states.length - 1]
-        
+
         // Check if this test had retries by looking for failure followed by success
-        const hasRetryPattern = states.length > 1 && 
-          states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
-        
+        const hasRetryPattern = states.length > 1 && states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
+
         if (hasRetryPattern) {
           // Emit all intermediate failures and final success for retries
           for (const state of states) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.0-beta.9.esm-aria",
+  "version": "4.0.0-rc.10",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
@@ -44,9 +44,10 @@
     "./store": "./lib/store.js"
   },
   "bin": {
-    "codeceptjs": "./bin/codecept.js"
+    "codeceptjs": "./bin/codecept.js",
+    "codeceptjs-mcp": "./bin/mcp-server.js"
   },
-  "repository": "Codeception/codeceptjs",
+  "repository": "codeceptjs/CodeceptJS",
   "scripts": {
     "test-server": "node bin/test-server.js test/data/rest/db.json --host 0.0.0.0 -p 8010 --read-only",
     "test-server:writable": "node bin/test-server.js test/data/rest/db.json --host 0.0.0.0 -p 8010",
@@ -88,31 +89,32 @@
     "@codeceptjs/configure": "1.0.6",
     "@codeceptjs/helper": "2.0.4",
     "@cucumber/cucumber-expressions": "18",
-    "@cucumber/gherkin": "35.1.0",
-    "@cucumber/messages": "29.0.1",
+    "@cucumber/gherkin": "38.0.0",
+    "@cucumber/messages": "32.0.1",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "@xmldom/xmldom": "0.9.8",
     "acorn": "8.15.0",
-    "ai": "^5.0.60",
+    "ai": "^6.0.43",
     "arrify": "3.0.0",
-    "axios": "1.12.2",
+    "axios": "1.13.2",
     "chalk": "4.1.2",
     "cheerio": "^1.0.0",
-    "chokidar": "^4.0.3",
-    "commander": "11.1.0",
+    "chokidar": "^5.0.0",
+    "commander": "14.0.3",
     "cross-spawn": "7.0.6",
     "css-to-xpath": "0.1.0",
     "csstoxpath": "1.6.0",
-    "envinfo": "7.20.0",
+    "envinfo": "7.21.0",
     "escape-string-regexp": "4.0.0",
     "figures": "3.2.0",
     "fn-args": "4.0.0",
-    "fs-extra": "11.3.2",
+    "fs-extra": "11.3.3",
     "fuse.js": "^7.0.0",
-    "glob": ">=9.0.0 <12",
+    "glob": ">=9.0.0 <14",
     "html-minifier-terser": "7.2.0",
     "inquirer": "^8.2.7",
     "invisi-data": "^1.0.0",
-    "joi": "18.0.1",
+    "joi": "18.0.2",
     "js-beautify": "1.15.4",
     "lodash.clonedeep": "4.5.0",
     "lodash.merge": "4.6.2",
@@ -137,33 +139,33 @@
     "@apollo/server": "^5",
     "@codeceptjs/expect-helper": "^1.0.2",
     "@codeceptjs/mock-request": "0.3.1",
-    "@eslint/eslintrc": "3.3.1",
-    "@eslint/js": "9.36.0",
-    "@faker-js/faker": "9.8.0",
-    "@inquirer/testing": "^2.1.49",
+    "@eslint/eslintrc": "3.3.3",
+    "@eslint/js": "9.39.2",
+    "@faker-js/faker": "10.2.0",
+    "@inquirer/testing": "^3.0.3",
     "@pollyjs/adapter-puppeteer": "6.0.6",
     "@pollyjs/core": "6.0.6",
     "@testomatio/reporter": "^2.3.1",
-    "@types/chai": "5.2.2",
+    "@types/chai": "5.2.3",
     "@types/inquirer": "9.0.9",
-    "@types/node": "^24.9.2",
+    "@types/node": "^25.0.3",
     "@wdio/sauce-service": "9.12.5",
     "@wdio/selenium-standalone-service": "8.15.0",
-    "@wdio/utils": "9.20.0",
+    "@wdio/utils": "9.23.3",
     "@xmldom/xmldom": "0.9.8",
     "bunosh": "latest",
-    "chai": "^4.5.0",
-    "chai-as-promised": "7.1.2",
+    "chai": "^6.2.1",
+    "chai-as-promised": "^8.0.2",
     "chai-subset": "1.6.0",
     "documentation": "14.0.3",
-    "electron": "38.2.0",
+    "electron": "40.1.0",
     "eslint": "^9.36.0",
     "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-mocha": "11.1.0",
+    "eslint-plugin-mocha": "11.2.0",
     "expect": "30.2.0",
     "express": "^5.1.0",
-    "globals": "16.4.0",
-    "graphql": "16.11.0",
+    "globals": "17.3.0",
+    "graphql": "16.12.0",
     "graphql-tag": "^2.12.6",
     "husky": "9.1.7",
     "jsdoc": "^3.6.11",
@@ -172,25 +174,34 @@
     "mochawesome": "^7.1.3",
     "playwright": "1.55.1",
     "prettier": "^3.3.2",
-    "puppeteer": "24.15.0",
+    "puppeteer": "24.36.0",
     "qrcode-terminal": "0.12.0",
     "rosie": "2.1.1",
     "runok": "^0.9.3",
     "semver": "7.7.3",
-    "sinon": "21.0.0",
-    "sinon-chai": "3.7.0",
+    "sinon": "21.0.1",
+    "sinon-chai": "^4.0.1",
     "ts-morph": "27.0.2",
     "ts-node": "10.9.2",
     "tsd": "^0.33.0",
     "tsd-jsdoc": "2.5.0",
-    "typedoc": "0.28.13",
+    "tsx": "^4.19.2",
+    "typedoc": "0.28.16",
     "typedoc-plugin-markdown": "4.9.0",
-    "typescript": "5.8.3",
+    "typescript": "5.9.3",
     "wdio-docker-service": "3.2.1",
-    "webdriverio": "9.12.5",
+    "webdriverio": "9.23.0",
     "xml2js": "0.6.2",
     "xpath": "0.0.34"
   },
+  "peerDependencies": {
+    "tsx": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "tsx": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=16.0",
     "npm": ">=5.6.0"