fixed mocha hooks, analyze plugin, added custom reporter tests

Author: DavertMik

lib/codecept.js

@@ -205,7 +205,7 @@ class Codecept {
       }
 
       try {
-        event.emit(event.all.before, container.result())
+        event.emit(event.all.before)
         mocha.run(() => done())
       } catch (e) {
         output.error(e.stack)

lib/command/run-workers.js

@@ -8,12 +8,6 @@ const Workers = require('../workers')
 module.exports = async function (workerCount, selectedRuns, options) {
   process.env.profile = options.profile
 
-  const suiteArr = []
-  const passedTestArr = []
-  const failedTestArr = []
-  const skippedTestArr = []
-  const stepArr = []
-
   const { config: testConfig, override = '' } = options
   const overrideConfigs = tryOrDefault(() => JSON.parse(override), {})
   const by = options.suites ? 'suite' : 'test'
@@ -36,17 +30,14 @@ module.exports = async function (workerCount, selectedRuns, options) {
   workers.overrideConfig(overrideConfigs)
 
   workers.on(event.test.failed, test => {
-    failedTestArr.push(test)
     output.test.failed(test)
   })
 
   workers.on(event.test.passed, test => {
-    passedTestArr.push(test)
     output.test.passed(test)
   })
 
   workers.on(event.test.skipped, test => {
-    skippedTestArr.push(test)
     output.test.skipped(test)
   })
 

lib/command/workers/runTests.js

@@ -99,7 +99,8 @@ function initializeListeners() {
   event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: step.simplify() }))
 
   event.dispatcher.on(event.hook.failed, (hook, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: { ...hook.simplify(), err } }))
-  event.dispatcher.on(event.hook.passed, (hook, err) => sendToParentThread({ event: event.hook.passed, workerIndex, data: { ...hook.simplify(), err } }))
+  event.dispatcher.on(event.hook.passed, hook => sendToParentThread({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
+  event.dispatcher.on(event.hook.finished, hook => sendToParentThread({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
 
   event.dispatcher.once(event.all.after, () => {
     sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })

lib/event.js

@@ -1,10 +1,10 @@
-const debug = require('debug')('codeceptjs:event');
-const events = require('events');
-const { error } = require('./output');
+const debug = require('debug')('codeceptjs:event')
+const events = require('events')
+const { error } = require('./output')
 
-const dispatcher = new events.EventEmitter();
+const dispatcher = new events.EventEmitter()
 
-dispatcher.setMaxListeners(50);
+dispatcher.setMaxListeners(50)
 /**
  * @namespace
  * @alias event
@@ -59,6 +59,7 @@ module.exports = {
     started: 'hook.start',
     passed: 'hook.passed',
     failed: 'hook.failed',
+    finished: 'hook.finished',
   },
 
   /**
@@ -141,33 +142,33 @@ module.exports = {
    * @param {*} [param]
    */
   emit(event, param) {
-    let msg = `Emitted | ${event}`;
+    let msg = `Emitted | ${event}`
     if (param && param.toString()) {
-      msg += ` (${param.toString()})`;
+      msg += ` (${param.toString()})`
     }
-    debug(msg);
+    debug(msg)
     try {
-      this.dispatcher.emit.apply(this.dispatcher, arguments);
+      this.dispatcher.emit.apply(this.dispatcher, arguments)
     } catch (err) {
-      error(`Error processing ${event} event:`);
-      error(err.stack);
+      error(`Error processing ${event} event:`)
+      error(err.stack)
     }
   },
 
   /** for testing only! */
   cleanDispatcher: () => {
-    let event;
+    let event
     for (event in this.test) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
     for (event in this.suite) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
     for (event in this.step) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
     for (event in this.all) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
   },
-};
+}

lib/listener/globalTimeout.js

@@ -130,7 +130,7 @@ module.exports = function () {
 
     if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
       debug(`step ${step.toCode().trim()} timed out`)
-      if (currentTest && currentTest.callback && currentTest.type == 'test') {
+      if (currentTest && currentTest.callback) {
         debug(`Failing test ${currentTest.title} with timeout ${currentTimeout}s`)
         recorder.reset()
         // replace mocha timeout with custom timeout

lib/listener/result.js

@@ -6,7 +6,7 @@ module.exports = function () {
     container.result().addStats({ failedHooks: 1 })
   })
 
-  event.dispatcher.on(event.test.started, test => {
+  event.dispatcher.on(event.test.before, test => {
     container.result().addTest(test)
   })
 }

lib/mocha/asyncWrapper.js

@@ -13,12 +13,19 @@ const injectHook = function (inject, suite) {
     recorder.throw(err)
   }
   recorder.catch(err => {
-    event.emit(event.test.failed, suite, err)
+    suiteTestFailedHookError(suite, err)
     throw err
   })
   return recorder.promise()
 }
 
+function suiteTestFailedHookError(suite, err) {
+  suite.eachTest(test => {
+    test.err = err
+    event.emit(event.test.failed, test, err)
+  })
+}
+
 function makeDoneCallableOnce(done) {
   let called = false
   return function (err) {
@@ -61,6 +68,7 @@ module.exports.test = test => {
           err = newErr
         }
       }
+      test.err = err
       event.emit(event.test.failed, test, err)
       event.emit(event.test.finished, test)
       recorder.add(() => doneFn(err))
@@ -112,7 +120,7 @@ module.exports.injected = function (fn, suite, hookName) {
     const errHandler = err => {
       recorder.session.start('teardown')
       recorder.cleanAsyncErr()
-      if (hookName == 'before' || hookName == 'beforeSuite') suite.eachTest(test => event.emit(event.test.failed, test, err))
+      if (hookName == 'before' || hookName == 'beforeSuite') suiteTestFailedHookError(suite, err)
       if (hookName === 'after') event.emit(event.test.after, suite)
       if (hookName === 'afterSuite') event.emit(event.suite.after, suite)
       recorder.add(() => doneFn(err))
@@ -156,6 +164,7 @@ module.exports.injected = function (fn, suite, hookName) {
     )
       .then(() => {
         recorder.add('fire hook.passed', () => fireHook(event.hook.passed, suite))
+        recorder.add('fire hook.finished', () => fireHook(event.hook.finished, suite))
         recorder.add(`finish ${hookName} hook`, doneFn)
         recorder.catch()
       })
@@ -166,6 +175,7 @@ module.exports.injected = function (fn, suite, hookName) {
           errHandler(err)
         })
         recorder.add('fire hook.failed', () => fireHook(event.hook.failed, suite, e))
+        recorder.add('fire hook.finished', () => fireHook(event.hook.finished, suite))
       })
   }
 }

lib/mocha/cli.js

@@ -230,7 +230,7 @@ class Cli extends Base {
             stack.shift()
           }
 
-          if (stack[0].trim() == 'Error:') {
+          if (stack[0] && stack[0].trim() == 'Error:') {
             stack.shift()
           }
 

lib/mocha/hooks.js

@@ -2,13 +2,30 @@ const event = require('../event')
 const { serializeError } = require('../utils')
 // const { serializeTest } = require('./test')
 
+/**
+ * Represents a test hook in the testing framework
+ * @class
+ * @property {Object} suite - The test suite this hook belongs to
+ * @property {Object} test - The test object associated with this hook
+ * @property {Object} runnable - The current test being executed
+ * @property {Object} ctx - The context object
+ * @property {Error|null} err - The error that occurred during hook execution, if any
+ */
 class Hook {
+  /**
+   * Creates a new Hook instance
+   * @param {Object} context - The context object containing suite and test information
+   * @param {Object} context.suite - The test suite
+   * @param {Object} context.test - The test object
+   * @param {Object} context.ctx - The context object
+   * @param {Error} error - The error object if hook execution failed
+   */
   constructor(context, error) {
     this.suite = context.suite
     this.test = context.test
     this.runnable = context?.ctx?.test
     this.ctx = context.ctx
-    this.error = error
+    this.err = error
   }
 
   get hookName() {
@@ -21,7 +38,7 @@ class Hook {
       title: this.title,
       // test: this.test ? serializeTest(this.test) : null,
       // suite: this.suite ? serializeSuite(this.suite) : null,
-      error: this.error ? serializeError(this.error) : null,
+      error: this.err ? serializeError(this.err) : null,
     }
   }
 
@@ -58,13 +75,13 @@ function fireHook(eventType, suite, error) {
   const hook = suite.ctx?.test?.title?.match(/"([^"]*)"/)[1]
   switch (hook) {
     case 'before each':
-      event.emit(eventType, new BeforeHook(suite))
+      event.emit(eventType, new BeforeHook(suite, error))
       break
     case 'after each':
       event.emit(eventType, new AfterHook(suite, error))
       break
     case 'before all':
-      event.emit(eventType, new BeforeSuiteHook(suite))
+      event.emit(eventType, new BeforeSuiteHook(suite, error))
       break
     case 'after all':
       event.emit(eventType, new AfterSuiteHook(suite, error))

lib/mocha/test.js

@@ -46,7 +46,7 @@ function enhanceMochaTest(test) {
   test.addToSuite = function (suite) {
     enhanceMochaSuite(suite)
     suite.addTest(testWrapper(this))
-    if (test.file) suite.file = relativeDir(test.file)
+    if (test.file && !suite.file) suite.file = test.file
     test.tags = [...(test.tags || []), ...(suite.tags || [])]
     test.fullTitle = () => `${suite.title}: ${test.title}`
     test.uid = genTestId(test)
@@ -78,20 +78,22 @@ function deserializeTest(test) {
   return test
 }
 
-function serializeTest(test, err = null) {
+function serializeTest(test, error = null) {
   // test = { ...test }
 
   if (test.start && !test.duration) {
     const end = +new Date()
     test.duration = end - test.start
   }
 
+  let err
+
   if (test.err) {
     err = serializeError(test.err)
-    test.status = 'failed'
-  } else if (err) {
-    err = serializeError(err)
-    test.status = 'failed'
+    test.state = 'failed'
+  } else if (error) {
+    err = serializeError(error)
+    test.state = 'failed'
   }
   const parent = {}
   if (test.parent) {
@@ -105,6 +107,11 @@ function serializeTest(test, err = null) {
     })
   }
 
+  let steps = undefined
+  if (Array.isArray(test.steps)) {
+    steps = test.steps.map(step => (step.simplify ? step.simplify() : step))
+  }
+
   return {
     opts: test.opts || {},
     tags: test.tags || [],
@@ -118,7 +125,7 @@ function serializeTest(test, err = null) {
     duration: test.duration || 0,
     err,
     parent,
-    steps: test.steps?.toArray()?.map(step => (step.simplify ? step.simplify() : step)),
+    steps,
   }
 }