feat: cli reporter improvements

Author: kobenguyent

lib/command/workers/runTests.js

@@ -203,6 +203,16 @@ class Cli extends Base {
           log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('File:')} file://${test.file}\n`
         }
 
+        // Add retry information if this test had retries
+        if (test.retryHistory && test.retryHistory.length > 0) {
+          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('Retry History:')}`
+          test.retryHistory.forEach((attempt, idx) => {
+            const status = attempt.passed ? output.styles.success('✓ passed') : output.styles.error('✗ failed')
+            log += `\n  Attempt ${idx + 1}: ${status} (${attempt.duration}ms)`
+          })
+          log += '\n'
+        }
+
         const steps = test.steps || (test.ctx && test.ctx.test.steps)
 
         if (steps && steps.length) {

lib/mocha/cli.js

@@ -36,14 +36,19 @@ class Hook {
     return {
       hookName: this.hookName,
       title: this.title,
+      suiteName: this.suite?.title || 'unknown',
+      testName: this.test?.title || this.ctx?.test?.title || 'unknown',
+      file: this.suite?.file || this.test?.file,
       // test: this.test ? serializeTest(this.test) : null,
       // suite: this.suite ? serializeSuite(this.suite) : null,
       error: this.err ? serializeError(this.err) : null,
     }
   }
 
   toString() {
-    return this.hookName
+    const suiteName = this.suite?.title || ''
+    const testName = this.test?.title || this.ctx?.test?.title || ''
+    return `${this.hookName}${suiteName ? ` for "${suiteName}"` : ''}${testName ? ` › "${testName}"` : ''}`
   }
 
   toCode() {

lib/mocha/hooks.js

@@ -35,12 +35,28 @@ function enhanceMochaTest(test) {
   test.inject = {}
   test.opts = {}
   test.meta = {}
+  test.retryHistory = [] // Track retry attempts
 
   test.notes = []
   test.addNote = (type, note) => {
     test.notes.push({ type, text: note })
   }
 
+  /**
+   * Records a retry attempt
+   * @param {boolean} passed - Whether the attempt passed
+   * @param {number} duration - Duration of the attempt in ms
+   * @param {Error} [error] - Error if the attempt failed
+   */
+  test.recordRetryAttempt = function (passed, duration, error = null) {
+    test.retryHistory.push({
+      passed,
+      duration,
+      error: error ? error.message : null,
+      timestamp: new Date().toISOString(),
+    })
+  }
+
   // Add new methods
   /**
    * @param {Mocha.Suite} suite - The Mocha suite to add this test to
@@ -125,6 +141,8 @@ function serializeTest(test, error = null) {
     tags: test.tags || [],
     uid: test.uid,
     retries: test._retries,
+    retryHistory: test.retryHistory || [],
+    workerIndex: test.workerIndex,
     title: test.title,
     state: test.state,
     notes: test.notes || [],

lib/mocha/test.js

@@ -247,15 +247,22 @@ module.exports = {
   hook: {
     started(hook) {
       if (outputLevel < 1) return
-      print(`  ${colors.dim.bold(hook.toCode())}`)
+      // Show more detailed hook information instead of generic "Before" or "After"
+      const hookType = hook.hookName || 'Hook'
+      const context = hook.title || (hook.ctx?.test?.title ? `"${hook.ctx.test.title}"` : '')
+      const displayName = context ? `${hookType} for ${context}` : hookType
+      print(`  ${colors.dim.bold(`${displayName}()`)}`)
     },
     passed(hook) {
       if (outputLevel < 1) return
       print()
     },
     failed(hook) {
       if (outputLevel < 1) return
-      print(`  ${colors.red.bold(hook.toCode())}`)
+      const hookType = hook.hookName || 'Hook'
+      const context = hook.title || (hook.ctx?.test?.title ? `"${hook.ctx.test.title}"` : '')
+      const displayName = context ? `${hookType} for ${context}` : hookType
+      print(`  ${colors.red.bold(`${displayName}()`)}`)
     },
   },
 

lib/output.js

@@ -3,6 +3,7 @@ const mkdirp = require('mkdirp')
 const { Worker } = require('worker_threads')
 const { EventEmitter } = require('events')
 const ms = require('ms')
+const colors = require('chalk')
 const Codecept = require('./codecept')
 const MochaFactory = require('./mocha/factory')
 const Container = require('./container')
@@ -507,7 +508,10 @@ class Workers extends EventEmitter {
 
           if (message.data.tests) {
             message.data.tests.forEach(test => {
-              Container.result().addTest(deserializeTest(test))
+              const deserializedTest = deserializeTest(test)
+              // Add worker index to test for grouping
+              deserializedTest.workerIndex = message.workerIndex
+              Container.result().addTest(deserializedTest)
             })
           }
 
@@ -516,25 +520,39 @@ class Workers extends EventEmitter {
           this.emit(event.suite.before, deserializeSuite(message.data))
           break
         case event.test.before:
-          this.emit(event.test.before, deserializeTest(message.data))
+          const testBefore = deserializeTest(message.data)
+          testBefore.workerIndex = message.workerIndex
+          this.emit(event.test.before, testBefore)
           break
         case event.test.started:
-          this.emit(event.test.started, deserializeTest(message.data))
+          const testStarted = deserializeTest(message.data)
+          testStarted.workerIndex = message.workerIndex
+          this.emit(event.test.started, testStarted)
           break
         case event.test.failed:
-          this.emit(event.test.failed, deserializeTest(message.data))
+          const testFailed = deserializeTest(message.data)
+          testFailed.workerIndex = message.workerIndex
+          this.emit(event.test.failed, testFailed)
           break
         case event.test.passed:
-          this.emit(event.test.passed, deserializeTest(message.data))
+          const testPassed = deserializeTest(message.data)
+          testPassed.workerIndex = message.workerIndex
+          this.emit(event.test.passed, testPassed)
           break
         case event.test.skipped:
-          this.emit(event.test.skipped, deserializeTest(message.data))
+          const testSkipped = deserializeTest(message.data)
+          testSkipped.workerIndex = message.workerIndex
+          this.emit(event.test.skipped, testSkipped)
           break
         case event.test.finished:
-          this.emit(event.test.finished, deserializeTest(message.data))
+          const testFinished = deserializeTest(message.data)
+          testFinished.workerIndex = message.workerIndex
+          this.emit(event.test.finished, testFinished)
           break
         case event.test.after:
-          this.emit(event.test.after, deserializeTest(message.data))
+          const testAfter = deserializeTest(message.data)
+          testAfter.workerIndex = message.workerIndex
+          this.emit(event.test.after, testAfter)
           break
         case event.step.finished:
           this.emit(event.step.finished, message.data)
@@ -591,6 +609,10 @@ class Workers extends EventEmitter {
     output.process(null)
     output.print()
 
+    // Group tests by feature for better organization
+    const testsByFeature = this._groupTestsByFeature(result.tests)
+    const testsByWorker = this._groupTestsByWorker(result.tests)
+
     this.failuresLog = result.failures
       .filter(log => log.length && typeof log[1] === 'number')
       // mocha/lib/reporters/base.js
@@ -602,10 +624,133 @@ 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)
+    // Print enhanced summary with worker info and feature grouping
+    this._printEnhancedWorkersSummary(result, testsByFeature, testsByWorker)
 
     process.env.RUNS_WITH_WORKERS = 'false'
   }
+
+  /**
+   * Groups tests by their feature/suite name
+   * @private
+   */
+  _groupTestsByFeature(tests) {
+    const groups = {}
+    tests.forEach(test => {
+      const featureName = test.parent?.title || test.suite || 'Ungrouped Tests'
+      if (!groups[featureName]) {
+        groups[featureName] = {
+          passed: 0,
+          failed: 0,
+          skipped: 0,
+          tests: [],
+        }
+      }
+      groups[featureName].tests.push(test)
+      if (test.state === 'passed') groups[featureName].passed++
+      else if (test.state === 'failed') groups[featureName].failed++
+      else if (test.state === 'skipped' || test.state === 'pending') groups[featureName].skipped++
+    })
+    return groups
+  }
+
+  /**
+   * Groups tests by worker
+   * @private
+   */
+  _groupTestsByWorker(tests) {
+    const groups = {}
+    tests.forEach(test => {
+      const workerIndex = test.workerIndex || 'unknown'
+      if (!groups[workerIndex]) {
+        groups[workerIndex] = {
+          passed: 0,
+          failed: 0,
+          skipped: 0,
+          tests: [],
+        }
+      }
+      groups[workerIndex].tests.push(test)
+      if (test.state === 'passed') groups[workerIndex].passed++
+      else if (test.state === 'failed') groups[workerIndex].failed++
+      else if (test.state === 'skipped' || test.state === 'pending') groups[workerIndex].skipped++
+    })
+    return groups
+  }
+
+  /**
+   * Prints enhanced summary with worker info, feature grouping and metrics
+   * @private
+   */
+  _printEnhancedWorkersSummary(result, testsByFeature, testsByWorker) {
+    // Calculate accurate stats from actual test objects instead of relying on Container stats
+    // which may not aggregate correctly in all scenarios
+    let actualPassed = 0
+    let actualFailed = 0
+    let actualPending = 0
+
+    result.tests.forEach(test => {
+      if (test.state === 'passed') actualPassed++
+      else if (test.state === 'failed') actualFailed++
+      else if (test.state === 'pending' || test.state === 'skipped') actualPending++
+    })
+
+    const actualTotal = result.tests.length
+    const actualFailedHooks = result.stats?.failedHooks || 0
+
+    // Use result.duration (wall-clock time) instead of stats.duration (which gets overwritten)
+    const duration = result.duration || result.stats?.duration || 0
+    output.print()
+    output.print(output.styles.bold('-- TEST SUMMARY:'))
+    output.print()
+
+    // Print tests grouped by feature
+    if (Object.keys(testsByFeature).length > 0) {
+      output.print(output.styles.bold('Results by Feature:'))
+      Object.entries(testsByFeature).forEach(([featureName, data]) => {
+        const totalTests = data.tests.length
+        const passRate = totalTests > 0 ? Math.round((data.passed / totalTests) * 100) : 0
+        const status = data.failed > 0 ? output.styles.error('✗') : output.styles.success('✓')
+        output.print(`  ${status} ${output.styles.bold(featureName)}`)
+        output.print(`     Passed: ${output.styles.success(data.passed)} | Failed: ${output.styles.error(data.failed)} | Skipped: ${data.skipped} | Pass Rate: ${passRate}%`)
+      })
+      output.print()
+    }
+
+    // Print worker statistics
+    if (Object.keys(testsByWorker).length > 1) {
+      output.print(output.styles.bold('Results by Worker:'))
+      Object.entries(testsByWorker)
+        .sort((a, b) => parseInt(a[0]) - parseInt(b[0]))
+        .forEach(([workerIndex, data]) => {
+          const totalTests = data.tests.length
+          const passRate = totalTests > 0 ? Math.round((data.passed / totalTests) * 100) : 0
+          const status = data.failed > 0 ? output.styles.error('✗') : output.styles.success('✓')
+          output.print(`  ${status} Worker ${workerIndex}`)
+          output.print(`     Tests: ${totalTests} | Passed: ${output.styles.success(data.passed)} | Failed: ${output.styles.error(data.failed)} | Pass Rate: ${passRate}%`)
+        })
+      output.print()
+    }
+
+    // Print overall metrics using accurate counts from test objects
+    output.print(output.styles.bold('Overall Metrics:'))
+    const passRate = actualTotal > 0 ? Math.round((actualPassed / actualTotal) * 100) : 0
+    const failRate = actualTotal > 0 ? Math.round((actualFailed / actualTotal) * 100) : 0
+    output.print(`  Total Tests: ${actualTotal}`)
+    output.print(`  Passed: ${output.styles.success(actualPassed)} (${passRate}%)`)
+    output.print(`  Failed: ${output.styles.error(actualFailed)} (${failRate}%)`)
+    output.print(`  Skipped: ${actualPending}`)
+    if (actualFailedHooks > 0) {
+      output.print(`  Failed Hooks: ${output.styles.error(actualFailedHooks)}`)
+    }
+    output.print(`  Duration: ${ms(duration)}`)
+    output.print(`  Workers: ${this.numberOfWorkers}`)
+    output.print(`  Strategy: ${this.isPoolMode ? 'pool' : 'test/suite'}`)
+    output.print()
+
+    // Print the classic result line with accurate counts
+    output.result(actualPassed, actualFailed, actualPending, ms(duration), actualFailedHooks)
+  }
 }
 
 module.exports = Workers