codeceptjs 3.7.0-beta.7 → 3.7.0-beta.8

package/lib/command/workers/runTests.js

@@ -75,217 +75,53 @@ function filterTests() {
 }
 
 function initializeListeners() {
-  function simplifyError(error) {
-    if (error) {
-      const { stack, uncaught, message, actual, expected } = error
-
-      return {
-        stack,
-        uncaught,
-        message,
-        actual,
-        expected,
-      }
-    }
-
-    return null
-  }
-  function simplifyTest(test, err = null) {
-    test = { ...test }
-
-    if (test.start && !test.duration) {
-      const end = new Date()
-      test.duration = end - test.start
-    }
-
-    if (test.err) {
-      err = simplifyError(test.err)
-      test.status = 'failed'
-    } else if (err) {
-      err = simplifyError(err)
-      test.status = 'failed'
-    }
-    const parent = {}
-    if (test.parent) {
-      parent.title = test.parent.title
-    }
-
-    if (test.opts) {
-      Object.keys(test.opts).forEach(k => {
-        if (typeof test.opts[k] === 'object') delete test.opts[k]
-        if (typeof test.opts[k] === 'function') delete test.opts[k]
-      })
-    }
-
-    return {
-      opts: test.opts || {},
-      tags: test.tags || [],
-      uid: test.uid,
-      workerIndex,
-      retries: test._retries,
-      title: test.title,
-      status: test.status,
-      notes: test.notes || [],
-      meta: test.meta || {},
-      artifacts: test.artifacts || [],
-      duration: test.duration || 0,
-      err,
-      parent,
-      steps: test.steps && test.steps.length > 0 ? simplifyStepsInTestObject(test.steps, err) : [],
-    }
-  }
-
-  function simplifyStepsInTestObject(steps, err) {
-    steps = [...steps]
-    const _steps = []
-
-    for (step of steps) {
-      const _args = []
-
-      if (step.args) {
-        for (const arg of step.args) {
-          // check if arg is a JOI object
-          if (arg && arg.$_root) {
-            _args.push(JSON.stringify(arg).slice(0, 300))
-            // check if arg is a function
-          } else if (arg && typeof arg === 'function') {
-            _args.push(arg.name)
-          } else {
-            _args.push(arg)
-          }
-        }
-      }
-
-      _steps.push({
-        actor: step.actor,
-        name: step.name,
-        status: step.status,
-        args: JSON.stringify(_args),
-        startedAt: step.startedAt,
-        startTime: step.startTime,
-        endTime: step.endTime,
-        finishedAt: step.finishedAt,
-        duration: step.duration,
-        err,
-      })
-    }
-
-    return _steps
-  }
-
-  function simplifyStep(step, err = null) {
-    step = { ...step }
-
-    if (step.startTime && !step.duration) {
-      const end = new Date()
-      step.duration = end - step.startTime
-    }
-
-    if (step.err) {
-      err = simplifyError(step.err)
-      step.status = 'failed'
-    } else if (err) {
-      err = simplifyError(err)
-      step.status = 'failed'
-    }
-
-    const parent = {}
-    if (step.metaStep) {
-      parent.title = step.metaStep.actor
-    }
-
-    if (step.opts) {
-      Object.keys(step.opts).forEach(k => {
-        if (typeof step.opts[k] === 'object') delete step.opts[k]
-        if (typeof step.opts[k] === 'function') delete step.opts[k]
-      })
-    }
-
-    return {
-      opts: step.opts || {},
-      workerIndex,
-      title: step.name,
-      status: step.status,
-      duration: step.duration || 0,
-      err,
-      parent,
-      test: simplifyTest(step.test),
-    }
-  }
-
-  collectStats()
   // suite
-  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: simplifyTest(suite) }))
-  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: simplifyTest(suite) }))
+  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: suite.simplify() }))
+  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: suite.simplify() }))
 
   // calculate duration
   event.dispatcher.on(event.test.started, test => (test.start = new Date()))
 
   // tests
-  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: simplifyTest(test) }))
-  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: simplifyTest(test) }))
+  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: test.simplify() }))
   // we should force-send correct errors to prevent race condition
-  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: simplifyTest(test) }))
-  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: simplifyTest(test) }))
+  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: test.simplify() }))
 
   // steps
-  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: simplifyStep(step) }))
-  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: simplifyStep(step) }))
-  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: simplifyStep(step) }))
-  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: simplifyStep(step) }))
+  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: step.simplify() }))
 
-  event.dispatcher.on(event.hook.failed, (test, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.hook.passed, (test, err) => sendToParentThread({ event: event.hook.passed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.all.failures, data => sendToParentThread({ event: event.all.failures, workerIndex, data }))
+  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 => 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() })
+  })
   // all
-  event.dispatcher.once(event.all.result, () => parentPort.close())
+  event.dispatcher.once(event.all.result, () => {
+    sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
+    parentPort?.close()
+  })
 }
 
 function disablePause() {
   global.pause = () => {}
 }
 
-function collectStats() {
-  const stats = {
-    passes: 0,
-    failures: 0,
-    skipped: 0,
-    tests: 0,
-    pending: 0,
-  }
-  event.dispatcher.on(event.test.skipped, () => {
-    stats.skipped++
-  })
-  event.dispatcher.on(event.test.passed, () => {
-    stats.passes++
-  })
-  event.dispatcher.on(event.test.failed, test => {
-    if (test.ctx._runnable.title.includes('hook: AfterSuite')) {
-      stats.failedHooks += 1
-    }
-    stats.failures++
-  })
-  event.dispatcher.on(event.test.skipped, () => {
-    stats.pending++
-  })
-  event.dispatcher.on(event.test.finished, () => {
-    stats.tests++
-  })
-  event.dispatcher.once(event.all.after, () => {
-    sendToParentThread({ event: event.all.after, data: stats })
-  })
-}
-
 function sendToParentThread(data) {
-  parentPort.postMessage(data)
+  parentPort?.postMessage(data)
 }
 
 function listenToParentThread() {
-  parentPort.on('message', eventData => {
+  parentPort?.on('message', eventData => {
     container.append({ support: eventData.data })
   })
 }

package/lib/container.js

@@ -9,6 +9,7 @@ const recorder = require('./recorder')
 const event = require('./event')
 const WorkerStorage = require('./workerStorage')
 const store = require('./store')
+const Result = require('./result')
 const ai = require('./ai')
 
 let asyncHelperPromise
@@ -25,6 +26,8 @@ let container = {
    */
   mocha: {},
   translation: {},
+  /** @type {Result | null} */
+  result: null,
 }
 
 /**
@@ -54,6 +57,7 @@ class Container {
     container.translation = loadTranslation(config.translation || null, config.vocabularies || [])
     container.proxySupport = createSupportObjects(config.include || {})
     container.plugins = createPlugins(config.plugins || {}, opts)
+    container.result = new Result()
 
     createActor(config.include?.I)
 
@@ -127,6 +131,18 @@ class Container {
     return container.mocha
   }
 
+  /**
+   * Get result
+   *
+   * @returns {Result}
+   */
+  static result() {
+    if (!container.result) {
+      container.result = new Result()
+    }
+    return container.result
+  }
+
   /**
    * Append new services to container
    *

package/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])
     }
   },
-};
+}

package/lib/listener/exit.js

@@ -1,20 +1,17 @@
 const event = require('../event')
+const debug = require('debug')('codeceptjs:exit')
 
 module.exports = function () {
   let failedTests = []
 
-  event.dispatcher.on(event.test.failed, testOrSuite => {
-    // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
-    // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+  event.dispatcher.on(event.test.failed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
     failedTests.push(id)
   })
 
   // if test was successful after retries
-  event.dispatcher.on(event.test.passed, testOrSuite => {
-    // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
-    // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+  event.dispatcher.on(event.test.passed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
     failedTests = failedTests.filter(failed => id !== failed)
   })
 

package/lib/listener/globalTimeout.js

@@ -4,7 +4,7 @@ const recorder = require('../recorder')
 const Config = require('../config')
 const store = require('../store')
 const debug = require('debug')('codeceptjs:timeout')
-const { TIMEOUT_ORDER } = require('../step/timeout')
+const { TIMEOUT_ORDER, TimeoutError, TestTimeoutError, StepTimeoutError } = require('../timeout')
 const { BeforeSuiteHook, AfterSuiteHook } = require('../mocha/hooks')
 
 module.exports = function () {
@@ -119,24 +119,41 @@ module.exports = function () {
     }
   })
 
+  event.dispatcher.on(event.step.after, step => {
+    if (typeof timeout !== 'number') return
+    if (!store.timeouts) return
+
+    recorder.catchWithoutStop(err => {
+      // we wrap timeout errors in a StepTimeoutError
+      // but only if global timeout is set
+      // should we wrap all timeout errors?
+      if (err instanceof TimeoutError) {
+        const testTimeoutExceeded = timeout && +Date.now() - step.startTime >= timeout
+        debug('Step failed due to global test or suite timeout')
+        if (testTimeoutExceeded) {
+          debug('Test failed due to global test or suite timeout')
+          throw new TestTimeoutError(currentTimeout)
+        }
+        throw new StepTimeoutError(currentTimeout, step)
+      }
+      throw err
+    })
+  })
+
   event.dispatcher.on(event.step.finished, step => {
     if (!store.timeouts) {
       debug('step', step.toCode().trim(), 'timeout disabled')
       return
     }
 
+    if (typeof timeout === 'number') debug('Timeout', timeout)
+
+    debug(`step ${step.toCode().trim()}:${step.status} duration`, step.duration)
     if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration
 
     if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
       debug(`step ${step.toCode().trim()} timed out`)
-      if (currentTest && currentTest.callback) {
-        debug(`Failing test ${currentTest.title} with timeout ${currentTimeout}s`)
-        recorder.reset()
-        // replace mocha timeout with custom timeout
-        currentTest.timeout(0)
-        currentTest.callback(new Error(`Timeout ${currentTimeout}s exceeded (with Before hook)`))
-        currentTest.timedOut = true
-      }
+      recorder.throw(new TestTimeoutError(currentTimeout))
     }
   })
 }

package/lib/listener/result.js

@@ -0,0 +1,12 @@
+const event = require('../event')
+const container = require('../container')
+
+module.exports = function () {
+  event.dispatcher.on(event.hook.failed, err => {
+    container.result().addStats({ failedHooks: 1 })
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    container.result().addTest(test)
+  })
+}

package/lib/listener/steps.js

@@ -13,7 +13,6 @@ let currentHook
 module.exports = function () {
   event.dispatcher.on(event.test.before, test => {
     test.startedAt = +new Date()
-    test.artifacts = {}
   })
 
   event.dispatcher.on(event.test.started, test => {
@@ -71,8 +70,6 @@ module.exports = function () {
   })
 
   event.dispatcher.on(event.step.started, step => {
-    step.startedAt = +new Date()
-    step.test = currentTest
     store.currentStep = step
     if (currentHook && Array.isArray(currentHook.steps)) {
       return currentHook.steps.push(step)
@@ -82,9 +79,6 @@ module.exports = function () {
   })
 
   event.dispatcher.on(event.step.finished, step => {
-    step.finishedAt = +new Date()
-    if (step.startedAt) step.duration = step.finishedAt - step.startedAt
-    debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`)
     store.currentStep = null
     store.stepOptions = null
   })

package/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()
-      event.emit(event.test.failed, suite, 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))
       })
   }
 }