codeceptjs 3.7.0-beta.7 → 3.7.0-beta.9

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/listener/store.js

@@ -2,11 +2,19 @@ const event = require('../event')
 const store = require('../store')
 
 module.exports = function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    store.currentSuite = suite
+  })
+
+  event.dispatcher.on(event.suite.after, () => {
+    store.currentSuite = null
+  })
+
   event.dispatcher.on(event.test.before, test => {
     store.currentTest = test
   })
 
-  event.dispatcher.on(event.test.finished, test => {
+  event.dispatcher.on(event.test.finished, () => {
     store.currentTest = 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, hookName) {
+  suite.eachTest(test => {
+    test.err = err
+    event.emit(event.test.failed, test, err, ucfirst(hookName))
+  })
+}
+
 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, hookName)
       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))
       })
   }
 }

package/lib/mocha/cli.js

@@ -1,12 +1,12 @@
 const {
   reporters: { Base },
 } = require('mocha')
-const figures = require('figures')
 const ms = require('ms')
+const figures = require('figures')
 const event = require('../event')
 const AssertionFailedError = require('../assert/error')
 const output = require('../output')
-
+const { cloneTest } = require('./test')
 const cursor = Base.cursor
 let currentMetaStep = []
 let codeceptjsEventDispatchersRegistered = false
@@ -32,6 +32,16 @@ class Cli extends Base {
       output.print(output.styles.debug(`Plugins: ${Object.keys(Containter.plugins()).join(', ')}`))
     }
 
+    if (level >= 3) {
+      process.on('warning', warning => {
+        console.log('\nWarning Details:')
+        console.log('Name:', warning.name)
+        console.log('Message:', warning.message)
+        console.log('Stack:', warning.stack)
+        console.log('-------------------')
+      })
+    }
+
     runner.on('start', () => {
       console.log()
     })
@@ -91,9 +101,11 @@ class Cli extends Base {
         event.dispatcher.on(event.step.started, step => {
           let processingStep = step
           const metaSteps = []
+          let isHidden = false
           while (processingStep.metaStep) {
             metaSteps.unshift(processingStep.metaStep)
             processingStep = processingStep.metaStep
+            if (processingStep.collapsed) isHidden = true
           }
           const shift = metaSteps.length
 
@@ -107,10 +119,9 @@ class Cli extends Base {
             }
           }
           currentMetaStep = metaSteps
+          if (isHidden) return
           output.stepShift = 3 + 2 * shift
-          if (step.helper.constructor.name !== 'ExpectHelper') {
-            output.step(step)
-          }
+          output.step(step)
         })
 
         event.dispatcher.on(event.step.finished, () => {
@@ -138,16 +149,19 @@ class Cli extends Base {
         }
       }
 
-      this.stats.pending += skippedCount
-      this.stats.tests += skippedCount
+      const container = require('../container')
+      container.result().addStats({ pending: skippedCount, tests: skippedCount })
     })
 
     runner.on('end', this.result.bind(this))
   }
 
   result() {
-    const stats = this.stats
-    stats.failedHooks = 0
+    const container = require('../container')
+    container.result().addStats(this.stats)
+    container.result().finish()
+
+    const stats = container.result().stats
     console.log()
 
     // passes
@@ -160,7 +174,8 @@ class Cli extends Base {
     // failures
     if (stats.failures) {
       // append step traces
-      this.failures.map(test => {
+      this.failures = this.failures.map(test => {
+        // we will change the stack trace, so we need to clone the test
         const err = test.err
 
         let log = ''
@@ -170,20 +185,38 @@ class Cli extends Base {
           err.message = err.inspect()
         }
 
-        // multi-line error messages
-        err.message = '\n  ' + (err.message || '').replace(/^/gm, '  ').trim()
+        // multi-line error messages (for Playwright)
+        if (err.message && err.message.includes('\n')) {
+          const lines = err.message.split('\n')
+          const truncatedLines = lines.slice(0, 5)
+          if (lines.length > 5) {
+            truncatedLines.push('...')
+          }
+          err.message = truncatedLines.join('\n').replace(/^/gm, '  ').trim()
+        }
+
+        // add new line before the message
+        err.message = '\n  ' + err.message
+
+        // explicitly show file with error
+        if (test.file) {
+          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('File:')} ${output.styles.basic(test.file)}\n`
+        }
 
         const steps = test.steps || (test.ctx && test.ctx.test.steps)
 
         if (steps && steps.length) {
           let scenarioTrace = ''
-          steps.reverse().forEach(step => {
-            const hasFailed = step.status === 'failed'
-            let line = `${hasFailed ? output.styles.bold(figures.cross) : figures.tick} ${step.toCode()} ${step.line()}`
-            if (hasFailed) line = output.styles.bold(line)
-            scenarioTrace += `\n${line}`
-          })
-          log += `${output.styles.basic(figures.circle)} ${output.styles.section('Scenario Steps')}:${scenarioTrace}\n`
+          steps
+            .reverse()
+            .slice(0, 10)
+            .forEach(step => {
+              const hasFailed = step.status === 'failed'
+              let line = `${hasFailed ? output.styles.bold(figures.cross) : figures.tick} ${step.toCode()} ${step.line()}`
+              if (hasFailed) line = output.styles.bold(line)
+              scenarioTrace += `\n${line}`
+            })
+          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('Scenario Steps')}:${scenarioTrace}\n`
         }
 
         // display artifacts in debug mode
@@ -204,25 +237,30 @@ class Cli extends Base {
 
         try {
           let stack = err.stack
-          stack = stack.replace(originalMessage, '')
+          stack = (stack || '').replace(originalMessage, '')
           stack = stack ? stack.split('\n') : []
 
           if (stack[0] && stack[0].includes(err.message)) {
             stack.shift()
           }
 
+          if (stack[0] && stack[0].trim() == 'Error:') {
+            stack.shift()
+          }
+
           if (output.level() < 3) {
             stack = stack.slice(0, 3)
           }
 
           err.stack = `${stack.join('\n')}\n\n${output.colors.blue(log)}`
-
-          // clone err object so stack trace adjustments won't affect test other reports
-          test.err = err
-          return test
         } catch (e) {
-          throw Error(e)
+          console.error(e)
         }
+
+        // we will change the stack trace, so we need to clone the test
+        test = cloneTest(test)
+        test.err = err
+        return test
       })
 
       const originalLog = Base.consoleLog
@@ -235,12 +273,8 @@ class Cli extends Base {
       console.log()
     }
 
-    this.failures.forEach(failure => {
-      if (failure.constructor.name === 'Hook') {
-        stats.failedHooks += 1
-      }
-    })
-    event.emit(event.all.failures, { failuresLog, stats })
+    container.result().addFailures(failuresLog)
+
     output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration), stats.failedHooks)
 
     if (stats.failures && output.level() < 3) {

package/lib/mocha/hooks.js

@@ -1,18 +1,47 @@
 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() {
     return this.constructor.name.replace('Hook', '')
   }
 
+  simplify() {
+    return {
+      hookName: this.hookName,
+      title: this.title,
+      // 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
   }
@@ -46,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))

package/lib/mocha/suite.js

@@ -1,5 +1,4 @@
 const MochaSuite = require('mocha/lib/suite')
-
 /**
  * @typedef {import('mocha')} Mocha
  */
@@ -34,6 +33,10 @@ function enhanceMochaSuite(suite) {
     }
   }
 
+  suite.simplify = function () {
+    return serializeSuite(this)
+  }
+
   return suite
 }
 
@@ -49,7 +52,30 @@ function createSuite(parent, title) {
   return enhanceMochaSuite(suite)
 }
 
+function serializeSuite(suite) {
+  suite = { ...suite }
+
+  return {
+    opts: suite.opts || {},
+    tags: suite.tags || [],
+    retries: suite._retries,
+    title: suite.title,
+    status: suite.status,
+    notes: suite.notes || [],
+    meta: suite.meta || {},
+    duration: suite.duration || 0,
+  }
+}
+
+function deserializeSuite(suite) {
+  suite = Object.assign(new MochaSuite(suite.title), suite)
+  enhanceMochaSuite(suite)
+  return suite
+}
+
 module.exports = {
   createSuite,
   enhanceMochaSuite,
+  serializeSuite,
+  deserializeSuite,
 }

package/lib/mocha/test.js

@@ -1,9 +1,9 @@
 const Test = require('mocha/lib/test')
 const Suite = require('mocha/lib/suite')
 const { test: testWrapper } = require('./asyncWrapper')
-const { enhanceMochaSuite } = require('./suite')
-const { genTestId } = require('../utils')
-
+const { enhanceMochaSuite, createSuite } = require('./suite')
+const { genTestId, serializeError, clearString, relativeDir } = require('../utils')
+const Step = require('../step/base')
 /**
  * Factory function to create enhanced tests
  * @param {string} title - Test title
@@ -46,6 +46,7 @@ function enhanceMochaTest(test) {
   test.addToSuite = function (suite) {
     enhanceMochaSuite(suite)
     suite.addTest(testWrapper(this))
+    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)
@@ -59,17 +60,100 @@ function enhanceMochaTest(test) {
     if (opts.retries) this.retries(opts.retries)
   }
 
+  test.simplify = function () {
+    return serializeTest(this)
+  }
+
   return test
 }
 
-function repackTestForWorkersTransport(test) {
-  test = Object.assign(new Test(test.title || '', () => {}), test)
-  test.parent = Object.assign(new Suite(test.parent.title), test.parent)
+function deserializeTest(test) {
+  test = Object.assign(
+    createTest(test.title || '', () => {}),
+    test,
+  )
+  test.parent = Object.assign(new Suite(test.parent?.title || 'Suite'), test.parent)
+  enhanceMochaSuite(test.parent)
+  if (test.steps) test.steps = test.steps.map(step => Object.assign(new Step(step.title), step))
   return test
 }
 
+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.state = 'failed'
+  } else if (error) {
+    err = serializeError(error)
+    test.state = '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]
+    })
+  }
+
+  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 || [],
+    uid: test.uid,
+    retries: test._retries,
+    title: test.title,
+    state: test.state,
+    notes: test.notes || [],
+    meta: test.meta || {},
+    artifacts: test.artifacts || {},
+    duration: test.duration || 0,
+    err,
+    parent,
+    steps,
+  }
+}
+
+function cloneTest(test) {
+  return deserializeTest(serializeTest(test))
+}
+
+function testToFileName(test) {
+  let fileName = clearString(test.title)
+  // remove tags with empty string (disable for now)
+  // fileName = fileName.replace(/\@\w+/g, '')
+  fileName = fileName.slice(0, 100)
+  if (fileName.indexOf('{') !== -1) {
+    fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim()
+  }
+  if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') fileName = clearString(`${test.title}_${test.ctx.test.title}`)
+  // TODO: add suite title to file name
+  // if (test.parent && test.parent.title) {
+  //   fileName = `${clearString(test.parent.title)}_${fileName}`
+  // }
+  return fileName
+}
+
 module.exports = {
   createTest,
+  testToFileName,
   enhanceMochaTest,
-  repackTestForWorkersTransport,
+  serializeTest,
+  deserializeTest,
+  cloneTest,
 }

package/lib/mocha/types.d.ts

@@ -12,14 +12,19 @@ declare global {
         type: string
         text: string
       }>
+      state: string
+      err?: Error
       config: Record<string, any>
       artifacts: string[]
       inject: Record<string, any>
       opts: Record<string, any>
       throws?: Error | string | RegExp | Function
       totalTimeout?: number
+      relativeFile?: string
       addToSuite(suite: Mocha.Suite): void
       applyOptions(opts: Record<string, any>): void
+      simplify(): Record<string, any>
+      toFileName(): string
       addNote(type: string, note: string): void
       codeceptjs: boolean
     }

package/lib/output.js

@@ -115,7 +115,7 @@ module.exports = {
       }
     }
 
-    let stepLine = step.toCliStyled()
+    let stepLine = step.toCliStyled ? step.toCliStyled() : step.toString()
     if (step.metaStep && outputLevel >= 1) {
       // this.stepShift += 2;
       stepLine = colors.dim(truncate(stepLine, this.spaceShift))
@@ -136,6 +136,7 @@ module.exports = {
     started: suite => {
       if (!suite.title) return
       print(`${colors.bold(suite.title)} --`)
+      if (suite.file && outputLevel >= 1) print(colors.underline.grey(suite.file))
       if (suite.comment) print(suite.comment)
     },
   },