Changes before error encountered

Co-authored-by: kobenguyent <[email protected]>

Author: Copilot

lib/command/workers/runTests.js

@@ -20,7 +20,7 @@ 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 } = workerData
+const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
 // hide worker output
 if (!options.debug && !options.verbose)
@@ -39,11 +39,23 @@ const codecept = new Codecept(config, options)
 codecept.init(testRoot)
 codecept.loadTests()
 const mocha = container.mocha()
-filterTests()
+
+if (poolMode) {
+  // In pool mode, don't filter tests upfront - wait for assignments
+  // Set up the mocha files but don't filter yet
+  const files = codecept.testFiles
+  mocha.files = files
+  mocha.loadFiles()
+} else {
+  // Legacy mode - filter tests upfront
+  filterTests()
+}
 
 // run tests
 ;(async function () {
-  if (mocha.suite.total()) {
+  if (poolMode) {
+    await runPoolTests()
+  } else if (mocha.suite.total()) {
     await runTests()
   }
 })()
@@ -64,7 +76,93 @@ async function runTests() {
   }
 }
 
-function filterTests() {
+async function runPoolTests() {
+  try {
+    await codecept.bootstrap()
+  } catch (err) {
+    throw new Error(`Error while running bootstrap file :${err}`)
+  }
+  
+  initializeListeners()
+  listenToParentThread()
+  disablePause()
+
+  // Request first test
+  sendToParentThread({ type: 'REQUEST_TEST', workerIndex })
+
+  // Wait for tests to be completed
+  await new Promise((resolve, reject) => {
+    let completedTests = 0
+    let hasError = false
+
+    const originalListen = listenToParentThread
+    
+    // Enhanced listener for pool mode
+    const poolListener = () => {
+      parentPort?.on('message', async eventData => {
+        if (eventData.type === 'TEST_ASSIGNED') {
+          const testUid = eventData.test
+          
+          try {
+            // Filter mocha suite to include only the assigned test
+            filterTestById(testUid)
+            
+            if (mocha.suite.total() > 0) {
+              // Run the single test
+              await codecept.run()
+              completedTests++
+            }
+            
+            // Notify completion and request next test
+            sendToParentThread({ type: 'TEST_COMPLETED', workerIndex })
+            sendToParentThread({ type: 'REQUEST_TEST', workerIndex })
+            
+          } catch (err) {
+            hasError = true
+            reject(err)
+          }
+        } else if (eventData.type === 'NO_MORE_TESTS') {
+          // All tests completed
+          resolve()
+        } else {
+          // Handle other message types (support messages, etc.)
+          container.append({ support: eventData.data })
+        }
+      })
+    }
+
+    poolListener()
+  })
+
+  try {
+    // Final cleanup
+    await codecept.teardown()
+  } catch (err) {
+    // Log teardown errors but don't throw
+    console.error('Teardown error:', err)
+  }
+}
+
+function filterTestById(testUid) {
+  // Clear previous tests
+  for (const suite of mocha.suite.suites) {
+    suite.tests = []
+  }
+  
+  // Add only the specific test
+  for (const suite of mocha.suite.suites) {
+    const originalTests = suite.tests
+    suite.tests = suite.tests.filter(test => test.uid === testUid)
+    
+    // If we found the test, break out
+    if (suite.tests.length > 0) {
+      break
+    }
+    
+    // Restore original tests for next iteration
+    suite.tests = originalTests
+  }
+}
   const files = codecept.testFiles
   mocha.files = files
   mocha.loadFiles()

lib/workers.js

@@ -49,13 +49,14 @@ const populateGroups = numberOfWorkers => {
   return groups
 }
 
-const createWorker = workerObject => {
+const createWorker = (workerObject, isPoolMode = false) => {
   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}`))
@@ -236,6 +237,9 @@ class Workers extends EventEmitter {
     this.closedWorkers = 0
     this.workers = []
     this.testGroups = []
+    this.testPool = []
+    this.isPoolMode = config.by === 'pool'
+    this.activeWorkers = new Map()
 
     createOutputDir(config.testConfig)
     if (numberOfWorkers) this._initWorkers(numberOfWorkers, config)
@@ -255,6 +259,7 @@ class Workers extends EventEmitter {
    *
    * - `suite`
    * - `test`
+   * - `pool`
    * - function(numberOfWorkers)
    *
    * This method can be overridden for a better split.
@@ -270,7 +275,11 @@ class Workers extends EventEmitter {
         this.testGroups.push(convertToMochaTests(testGroup))
       }
     } else if (typeof numberOfWorkers === 'number' && numberOfWorkers > 0) {
-      this.testGroups = config.by === 'suite' ? this.createGroupsOfSuites(numberOfWorkers) : this.createGroupsOfTests(numberOfWorkers)
+      if (config.by === 'pool') {
+        this.createTestPool(numberOfWorkers)
+      } else {
+        this.testGroups = config.by === 'suite' ? this.createGroupsOfSuites(numberOfWorkers) : this.createGroupsOfTests(numberOfWorkers)
+      }
     }
   }
 
@@ -311,7 +320,29 @@ class Workers extends EventEmitter {
   /**
    * @param {Number} numberOfWorkers
    */
-  createGroupsOfSuites(numberOfWorkers) {
+  createTestPool(numberOfWorkers) {
+    const files = this.codecept.testFiles
+    const mocha = Container.mocha()
+    mocha.files = files
+    mocha.loadFiles()
+
+    mocha.suite.eachTest(test => {
+      if (test) {
+        this.testPool.push(test.uid)
+      }
+    })
+
+    // For pool mode, create empty groups for each worker
+    this.testGroups = populateGroups(numberOfWorkers)
+  }
+
+  /**
+   * Gets the next test from the pool
+   * @returns {String|null} test uid or null if no tests available
+   */
+  getNextTest() {
+    return this.testPool.shift() || null
+  }
     const files = this.codecept.testFiles
     const groups = populateGroups(numberOfWorkers)
 
@@ -352,7 +383,7 @@ class Workers extends EventEmitter {
     process.env.RUNS_WITH_WORKERS = 'true'
     recorder.add('starting workers', () => {
       for (const worker of this.workers) {
-        const workerThread = createWorker(worker)
+        const workerThread = createWorker(worker, this.isPoolMode)
         this._listenWorkerEvents(workerThread)
       }
     })
@@ -376,9 +407,45 @@ 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 })
+            const workerInfo = this.activeWorkers.get(worker)
+            if (workerInfo) {
+              workerInfo.available = false
+              workerInfo.workerIndex = message.workerIndex
+            }
+          } else {
+            worker.postMessage({ type: 'NO_MORE_TESTS' })
+            const workerInfo = this.activeWorkers.get(worker)
+            if (workerInfo) {
+              workerInfo.available = true
+            }
+          }
+        }
+        return
+      }
+
+      // Handle test completion for pool mode
+      if (message.type === 'TEST_COMPLETED' && this.isPoolMode) {
+        const workerInfo = this.activeWorkers.get(worker)
+        if (workerInfo) {
+          workerInfo.available = true
+        }
+        return
+      }
+
       // deal with events that are not test cycle related
       if (!message.event) {
         return this.emit('message', message)