Fix test stats issue in pool mode - consolidate results properly

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

Author: Copilot

lib/command/workers/runTests.js

@@ -83,6 +83,11 @@ async function runPoolTests() {
   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 = []
+
   // Keep requesting tests until no more available
   while (true) {
     // Request a test assignment
@@ -106,6 +111,22 @@ async function runPoolTests() {
             if (mocha.suite.total() > 0) {
               // Run the test and complete
               await codecept.run()
+              
+              // Accumulate the results from this test run
+              const result = container.result()
+              consolidatedStats.passes += result.stats.passes || 0
+              consolidatedStats.failures += result.stats.failures || 0
+              consolidatedStats.tests += result.stats.tests || 0
+              consolidatedStats.pending += result.stats.pending || 0
+              consolidatedStats.failedHooks += result.stats.failedHooks || 0
+              
+              // Add tests and failures to consolidated collections
+              if (result.tests) {
+                allTests.push(...result.tests)
+              }
+              if (result.failures) {
+                allFailures.push(...result.failures)
+              }
             }
 
             // Signal test completed and request next
@@ -141,6 +162,17 @@ async function runPoolTests() {
     console.error('Teardown error:', err)
   }
 
+  // Send final consolidated results for the entire worker
+  const finalResult = {
+    stats: consolidatedStats,
+    tests: allTests,
+    failures: allFailures,
+    hasFailed: consolidatedStats.failures > 0
+  }
+  
+  sendToParentThread({ event: event.all.after, workerIndex, data: finalResult })
+  sendToParentThread({ event: event.all.result, workerIndex, data: finalResult })
+
   // Close worker thread when pool mode is complete
   parentPort?.close()
 }
@@ -220,15 +252,8 @@ function initializeListeners() {
       parentPort?.close()
     })
   } else {
-    // In pool mode, don't close worker after individual test completion
-    // The worker will close when it receives 'NO_MORE_TESTS' message
-    event.dispatcher.on(event.all.after, () => {
-      sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })
-    })
-    event.dispatcher.on(event.all.result, () => {
-      sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
-      // Don't close parentPort in pool mode - let the pool manager handle worker lifecycle
-    })
+    // In pool mode, don't send result events for individual tests
+    // Results will be sent once when the worker completes all tests
   }
 }
 

test/unit/worker_test.js

@@ -333,4 +333,39 @@ describe('Workers', function () {
     expect('pool').not.equal('test')
     expect('pool').not.equal('suite')
   })
+
+  it('should handle pool mode result accumulation correctly', (done) => {
+    const workerConfig = {
+      by: 'pool',
+      testConfig: './test/data/sandbox/codecept.workers.conf.js',
+    }
+    
+    let resultEventCount = 0
+    const workers = new Workers(2, workerConfig)
+
+    // Mock Container.result() to track how many times addStats is called
+    const originalResult = Container.result()
+    const mockStats = { passes: 0, failures: 0, tests: 0 }
+    const originalAddStats = originalResult.addStats.bind(originalResult)
+    
+    originalResult.addStats = (newStats) => {
+      resultEventCount++
+      mockStats.passes += newStats.passes || 0
+      mockStats.failures += newStats.failures || 0  
+      mockStats.tests += newStats.tests || 0
+      return originalAddStats(newStats)
+    }
+
+    workers.on(event.all.result, (result) => {
+      // In pool mode, we should receive consolidated results, not individual test results
+      // The number of result events should be limited (one per worker, not per test)
+      expect(resultEventCount).to.be.lessThan(10) // Should be much less than total number of tests
+      
+      // Restore original method
+      originalResult.addStats = originalAddStats
+      done()
+    })
+
+    workers.run()
+  })
 })