codeceptjs 4.0.0-beta.5 → 4.0.0-beta.6.esm-aria

package/lib/workerStorage.js

@@ -1,20 +1,19 @@
-const { isMainThread, parentPort } = require('worker_threads');
+import { isMainThread, parentPort } from 'worker_threads'
 
-const workerObjects = {};
-const shareEvent = 'share';
+const workerObjects = {}
+const shareEvent = 'share'
 
-const invokeWorkerListeners = (workerObj) => {
-  const { threadId } = workerObj;
-  workerObj.on('message', (messageData) => {
+const invokeWorkerListeners = workerObj => {
+  const { threadId } = workerObj
+  workerObj.on('message', messageData => {
     if (messageData.event === shareEvent) {
-      const Container = require('./container');
-      Container.share(messageData.data);
+      share(messageData.data)
     }
-  });
+  })
   workerObj.on('exit', () => {
-    delete workerObjects[threadId];
-  });
-};
+    delete workerObjects[threadId]
+  })
+}
 
 class WorkerStorage {
   /**
@@ -24,8 +23,8 @@ class WorkerStorage {
    * @param {Worker} workerObj
    */
   static addWorker(workerObj) {
-    workerObjects[workerObj.threadId] = workerObj;
-    invokeWorkerListeners(workerObj);
+    workerObjects[workerObj.threadId] = workerObj
+    invokeWorkerListeners(workerObj)
   }
 
   /**
@@ -36,12 +35,12 @@ class WorkerStorage {
   static share(data) {
     if (isMainThread) {
       for (const workerObj of Object.values(workerObjects)) {
-        workerObj.postMessage({ data });
+        workerObj.postMessage({ data })
       }
     } else {
-      parentPort.postMessage({ data, event: shareEvent });
+      parentPort.postMessage({ data, event: shareEvent })
     }
   }
 }
 
-module.exports = WorkerStorage;
+export default WorkerStorage

package/lib/workers.js

@@ -1,36 +1,41 @@
-const path = require('path')
-const mkdirp = require('mkdirp')
-const { Worker } = require('worker_threads')
-const { EventEmitter } = require('events')
-const ms = require('ms')
-const Codecept = require('./codecept')
-const MochaFactory = require('./mocha/factory')
-const Container = require('./container')
-const { getTestRoot } = require('./command/utils')
-const { isFunction, fileExists } = require('./utils')
-const { replaceValueDeep, deepClone } = require('./utils')
-const mainConfig = require('./config')
-const output = require('./output')
-const event = require('./event')
-const { deserializeTest } = require('./mocha/test')
-const { deserializeSuite } = require('./mocha/suite')
-const recorder = require('./recorder')
-const runHook = require('./hooks')
-const WorkerStorage = require('./workerStorage')
-const collection = require('./command/run-multiple/collection')
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import { mkdirp } from 'mkdirp'
+import { Worker } from 'worker_threads'
+import { EventEmitter } from 'events'
+import ms from 'ms'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+import Codecept from './codecept.js'
+import MochaFactory from './mocha/factory.js'
+import Container from './container.js'
+import { getTestRoot } from './command/utils.js'
+import { isFunction, fileExists, replaceValueDeep, deepClone } from './utils.js'
+import mainConfig from './config.js'
+import output from './output.js'
+import event from './event.js'
+import { deserializeTest } from './mocha/test.js'
+import { deserializeSuite } from './mocha/suite.js'
+import recorder from './recorder.js'
+import runHook from './hooks.js'
+import WorkerStorage from './workerStorage.js'
+import { createRuns } from './command/run-multiple/collection.js'
 
 const pathToWorker = path.join(__dirname, 'command', 'workers', 'runTests.js')
 
-const initializeCodecept = (configPath, options = {}) => {
-  const codecept = new Codecept(mainConfig.load(configPath || '.'), options)
-  codecept.init(getTestRoot(configPath))
+const initializeCodecept = async (configPath, options = {}) => {
+  const config = await mainConfig.load(configPath || '.')
+  const codecept = new Codecept(config, options)
+  await codecept.init(getTestRoot(configPath))
   codecept.loadTests()
 
   return codecept
 }
 
-const createOutputDir = configPath => {
-  const config = mainConfig.load(configPath || '.')
+const createOutputDir = async configPath => {
+  const config = await mainConfig.load(configPath || '.')
   const testRoot = getTestRoot(configPath)
   const outputDir = path.isAbsolute(config.output) ? config.output : path.join(testRoot, config.output)
 
@@ -49,14 +54,13 @@ const populateGroups = numberOfWorkers => {
   return groups
 }
 
-const createWorker = (workerObject, isPoolMode = false) => {
+const createWorker = workerObject => {
   const worker = new Worker(pathToWorker, {
     workerData: {
       options: simplifyObject(workerObject.options),
       tests: workerObject.tests,
       testRoot: workerObject.testRoot,
       workerIndex: workerObject.workerIndex + 1,
-      poolMode: isPoolMode,
     },
   })
   worker.on('error', err => output.error(`Worker Error: ${err.stack}`))
@@ -99,7 +103,7 @@ const createWorkerObjects = (testGroups, config, testRoot, options, selectedRuns
     currentMochaJunitReporterFile = config.mocha.reporterOptions['mocha-junit-reporter'].options.mochaFile
   }
 
-  collection.createRuns(selectedRuns, config).forEach(worker => {
+  createRuns(selectedRuns, config).forEach(worker => {
     const separator = path.sep
     const _config = { ...config }
     let workerName = worker.name.replace(':', '_')
@@ -231,25 +235,43 @@ class Workers extends EventEmitter {
   constructor(numberOfWorkers, config = { by: 'test' }) {
     super()
     this.setMaxListeners(50)
-    this.codecept = initializeCodecept(config.testConfig, config.options)
-    this.options = config.options || {}
+    this.codeceptPromise = initializeCodecept(config.testConfig, config.options)
+    this.codecept = null
     this.errors = []
     this.numberOfWorkers = 0
     this.closedWorkers = 0
     this.workers = []
     this.testGroups = []
-    this.testPool = []
-    this.testPoolInitialized = false
-    this.isPoolMode = config.by === 'pool'
-    this.activeWorkers = new Map()
-    this.maxWorkers = numberOfWorkers // Track original worker count for pool mode
+    this.config = config
+    this.numberOfWorkersRequested = numberOfWorkers
+  // Track emitted pass events to avoid double-counting duplicates from retries/race conditions
+  this._passedUids = new Set()
 
     createOutputDir(config.testConfig)
-    if (numberOfWorkers) this._initWorkers(numberOfWorkers, config)
+    // Defer worker initialization until codecept is ready
+  }
+
+  async _ensureInitialized() {
+    if (!this.codecept) {
+      this.codecept = await this.codeceptPromise
+      // 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))
+      )
+      
+      if (shouldAutoInit) {
+        this._initWorkers(this.numberOfWorkersRequested, this.config)
+      }
+    }
   }
 
   _initWorkers(numberOfWorkers, config) {
     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.numberOfWorkers = this.workers.length
   }
@@ -262,7 +284,6 @@ class Workers extends EventEmitter {
    *
    * - `suite`
    * - `test`
-   * - `pool`
    * - function(numberOfWorkers)
    *
    * This method can be overridden for a better split.
@@ -278,11 +299,7 @@ class Workers extends EventEmitter {
         this.testGroups.push(convertToMochaTests(testGroup))
       }
     } else if (typeof numberOfWorkers === 'number' && numberOfWorkers > 0) {
-      if (config.by === 'pool') {
-        this.createTestPool(numberOfWorkers)
-      } else {
-        this.testGroups = config.by === 'suite' ? this.createGroupsOfSuites(numberOfWorkers) : this.createGroupsOfTests(numberOfWorkers)
-      }
+      this.testGroups = config.by === 'suite' ? this.createGroupsOfSuites(numberOfWorkers) : this.createGroupsOfTests(numberOfWorkers)
     }
   }
 
@@ -302,7 +319,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfTests(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 mocha = Container.mocha()
     mocha.files = files
     mocha.loadFiles()
@@ -320,90 +339,13 @@ class Workers extends EventEmitter {
     return groups
   }
 
-  /**
-   * @param {Number} numberOfWorkers
-   */
-  createTestPool(numberOfWorkers) {
-    // For pool mode, create empty groups for each worker and initialize empty pool
-    // Test pool will be populated lazily when getNextTest() is first called
-    this.testPool = []
-    this.testPoolInitialized = false
-    this.testGroups = populateGroups(numberOfWorkers)
-  }
-
-  /**
-   * Initialize the test pool if not already done
-   * This is called lazily to avoid state pollution issues during construction
-   */
-  _initializeTestPool() {
-    if (this.testPoolInitialized) {
-      return
-    }
-
-    const files = this.codecept.testFiles
-    if (!files || files.length === 0) {
-      this.testPoolInitialized = true
-      return
-    }
-
-    try {
-      const mocha = Container.mocha()
-      mocha.files = files
-      mocha.loadFiles()
-
-      mocha.suite.eachTest(test => {
-        if (test) {
-          this.testPool.push(test.uid)
-        }
-      })
-    } catch (e) {
-      // If mocha loading fails due to state pollution, skip
-    }
-
-    // If no tests were found, fallback to using createGroupsOfTests approach
-    // This works around state pollution issues
-    if (this.testPool.length === 0 && files.length > 0) {
-      try {
-        const testGroups = this.createGroupsOfTests(2) // Use 2 as a default for fallback
-        for (const group of testGroups) {
-          this.testPool.push(...group)
-        }
-      } catch (e) {
-        // If createGroupsOfTests fails, fallback to simple file names
-        for (const file of files) {
-          this.testPool.push(`test_${file.replace(/[^a-zA-Z0-9]/g, '_')}`)
-        }
-      }
-    }
-
-    // Last resort fallback for unit tests - add dummy test UIDs
-    if (this.testPool.length === 0) {
-      for (let i = 0; i < Math.min(files.length, 5); i++) {
-        this.testPool.push(`dummy_test_${i}_${Date.now()}`)
-      }
-    }
-
-    this.testPoolInitialized = true
-  }
-
-  /**
-   * Gets the next test from the pool
-   * @returns {String|null} test uid or null if no tests available
-   */
-  getNextTest() {
-    // Initialize test pool lazily on first access
-    if (!this.testPoolInitialized) {
-      this._initializeTestPool()
-    }
-
-    return this.testPool.shift() || null
-  }
-
   /**
    * @param {Number} numberOfWorkers
    */
   createGroupsOfSuites(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)
 
     const mocha = Container.mocha()
@@ -430,20 +372,23 @@ class Workers extends EventEmitter {
   }
 
   async bootstrapAll() {
+    await this._ensureInitialized()
     return runHook(this.codecept.config.bootstrapAll, 'bootstrapAll')
   }
 
   async teardownAll() {
+    await this._ensureInitialized()
     return runHook(this.codecept.config.teardownAll, 'teardownAll')
   }
 
-  run() {
+  async run() {
+    await this._ensureInitialized()
     recorder.startUnlessRunning()
     event.dispatcher.emit(event.workers.before)
     process.env.RUNS_WITH_WORKERS = 'true'
     recorder.add('starting workers', () => {
       for (const worker of this.workers) {
-        const workerThread = createWorker(worker, this.isPoolMode)
+        const workerThread = createWorker(worker)
         this._listenWorkerEvents(workerThread)
       }
     })
@@ -467,27 +412,9 @@ class Workers extends EventEmitter {
   }
 
   _listenWorkerEvents(worker) {
-    // Track worker thread for pool mode
-    if (this.isPoolMode) {
-      this.activeWorkers.set(worker, { available: true, workerIndex: null })
-    }
-
     worker.on('message', message => {
       output.process(message.workerIndex)
 
-      // Handle test requests for pool mode
-      if (message.type === 'REQUEST_TEST') {
-        if (this.isPoolMode) {
-          const nextTest = this.getNextTest()
-          if (nextTest) {
-            worker.postMessage({ type: 'TEST_ASSIGNED', test: nextTest })
-          } else {
-            worker.postMessage({ type: 'NO_MORE_TESTS' })
-          }
-        }
-        return
-      }
-
       // deal with events that are not test cycle related
       if (!message.event) {
         return this.emit('message', message)
@@ -496,21 +423,11 @@ class Workers extends EventEmitter {
       switch (message.event) {
         case event.all.result:
           // we ensure consistency of result by adding tests in the very end
-          // Check if message.data.stats is valid before adding
-          if (message.data.stats) {
-            Container.result().addStats(message.data.stats)
-          }
-
-          if (message.data.failures) {
-            Container.result().addFailures(message.data.failures)
-          }
-
-          if (message.data.tests) {
-            message.data.tests.forEach(test => {
-              Container.result().addTest(deserializeTest(test))
-            })
-          }
-
+          Container.result().addFailures(message.data.failures)
+          Container.result().addStats(message.data.stats)
+          message.data.tests.forEach(test => {
+            Container.result().addTest(deserializeTest(test))
+          })
           break
         case event.suite.before:
           this.emit(event.suite.before, deserializeSuite(message.data))
@@ -522,16 +439,43 @@ class Workers extends EventEmitter {
           this.emit(event.test.started, deserializeTest(message.data))
           break
         case event.test.failed:
-          this.emit(event.test.failed, deserializeTest(message.data))
+          // Skip individual failed events - we'll emit based on finished state
           break
         case event.test.passed:
-          this.emit(event.test.passed, deserializeTest(message.data))
+          // Skip individual passed events - we'll emit based on finished state  
           break
         case event.test.skipped:
           this.emit(event.test.skipped, deserializeTest(message.data))
           break
         case event.test.finished:
-          this.emit(event.test.finished, deserializeTest(message.data))
+          // Handle different types of test completion properly
+          {
+            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 })
+              }
+              
+              const testState = this._testStates.get(uid)
+              testState.states.push({ isFailed, data })
+              testState.lastData = data
+            } else {
+              // For tests without UID, emit immediately
+              if (isFailed) {
+                this.emit(event.test.failed, deserializeTest(data))
+              } else {
+                this.emit(event.test.passed, deserializeTest(data))
+              }
+            }
+            
+            this.emit(event.test.finished, deserializeTest(data))
+          }
           break
         case event.test.after:
           this.emit(event.test.after, deserializeTest(message.data))
@@ -548,6 +492,11 @@ class Workers extends EventEmitter {
         case event.step.failed:
           this.emit(event.step.failed, message.data, message.data.error)
           break
+        case event.hook.failed:
+          // Count hook failures as test failures for event counting
+          this.emit(event.test.failed, { title: `Hook failure: ${message.data.hookName || 'unknown'}`, err: message.data.error })
+          this.emit(event.hook.failed, message.data)
+          break
       }
     })
 
@@ -557,14 +506,7 @@ class Workers extends EventEmitter {
 
     worker.on('exit', () => {
       this.closedWorkers += 1
-
-      if (this.isPoolMode) {
-        // Pool mode: finish when all workers have exited and no more tests
-        if (this.closedWorkers === this.numberOfWorkers) {
-          this._finishRun()
-        }
-      } else if (this.closedWorkers === this.numberOfWorkers) {
-        // Regular mode: finish when all original workers have exited
+      if (this.closedWorkers === this.numberOfWorkers) {
         this._finishRun()
       }
     })
@@ -578,6 +520,38 @@ class Workers extends EventEmitter {
       process.exitCode = 0
     }
 
+    // Emit states for all tracked tests before emitting results
+    if (this._testStates) {
+      for (const [uid, { states, lastData }] of this._testStates) {
+        // 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)
+        
+        if (hasRetryPattern) {
+          // Emit all intermediate failures and final success for retries
+          for (const state of states) {
+            if (state.isFailed) {
+              this.emit(event.test.failed, deserializeTest(state.data))
+            } else {
+              this.emit(event.test.passed, deserializeTest(state.data))
+            }
+          }
+        } else {
+          // For non-retries (like step failures), emit only the final state
+          if (lastState.isFailed) {
+            this.emit(event.test.failed, deserializeTest(lastState.data))
+          } else {
+            this.emit(event.test.passed, deserializeTest(lastState.data))
+          }
+        }
+      }
+      this._testStates.clear()
+    }
+
     this.emit(event.all.result, Container.result())
     event.dispatcher.emit(event.workers.result, Container.result())
     this.emit('end') // internal event
@@ -602,10 +576,10 @@ class Workers extends EventEmitter {
       this.failuresLog.forEach(log => output.print(...log))
     }
 
-    output.result(result.stats.passes, result.stats.failures, result.stats.pending, ms(result.duration), result.stats.failedHooks)
+    output.result(result.stats?.passes || 0, result.stats?.failures || 0, result.stats?.pending || 0, ms(result.duration), result.stats?.failedHooks || 0)
 
     process.env.RUNS_WITH_WORKERS = 'false'
   }
 }
 
-module.exports = Workers
+export default Workers