codeceptjs 3.7.0-beta.1 → 3.7.0-beta.10

package/lib/mocha/cli.js

@@ -2,10 +2,11 @@ const {
   reporters: { Base },
 } = require('mocha')
 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
@@ -31,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()
     })
@@ -90,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
 
@@ -106,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, () => {
@@ -137,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
@@ -159,53 +174,93 @@ 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 = ''
+        let originalMessage = err.message
 
         if (err instanceof AssertionFailedError) {
           err.message = err.inspect()
         }
 
+        // 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 line = `- ${step.toCode()} ${step.line()}`
-            // if (step.status === 'failed') line = '' + line;
-            scenarioTrace += `\n${line}`
-          })
-          log += `${output.styles.bold('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
         if (test?.artifacts && Object.keys(test.artifacts).length) {
-          log += `\n${output.styles.bold('Artifacts:')}`
+          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('Artifacts:')}`
           for (const artifact of Object.keys(test.artifacts)) {
             log += `\n- ${artifact}: ${test.artifacts[artifact]}`
           }
         }
 
+        // display metadata
+        if (test.meta && Object.keys(test.meta).length) {
+          log += `\n\n${output.styles.basic(figures.circle)} ${output.styles.section('Metadata:')}`
+          for (const [key, value] of Object.entries(test.meta)) {
+            log += `\n- ${key}: ${value}`
+          }
+        }
+
         try {
-          let stack = err.stack ? err.stack.split('\n') : []
+          let stack = err.stack
+          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
@@ -218,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/featureConfig.js

@@ -7,6 +7,19 @@ class FeatureConfig {
     this.suite = suite
   }
 
+  /**
+   * Set metadata for this suite
+   * @param {string} key
+   * @param {string} value
+   * @returns {this}
+   */
+  meta(key, value) {
+    this.suite.tests.forEach(test => {
+      test.meta[key] = value
+    })
+    return this
+  }
+
   /**
    * Retry this test for number of times
    *

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/inject.js

@@ -5,6 +5,7 @@ const getInjectedArguments = (fn, test) => {
   const testArgs = {}
   const params = parser.getParams(fn) || []
   const objects = container.support()
+
   for (const key of params) {
     testArgs[key] = {}
     if (test && test.inject && test.inject[key]) {
@@ -18,6 +19,10 @@ const getInjectedArguments = (fn, test) => {
     testArgs[key] = container.support(key)
   }
 
+  if (test) {
+    testArgs.suite = test?.parent
+    testArgs.test = test
+  }
   return testArgs
 }
 

package/lib/mocha/scenarioConfig.js

@@ -42,6 +42,17 @@ class ScenarioConfig {
     return this
   }
 
+  /**
+   * Set metadata for this test
+   * @param {string} key
+   * @param {string} value
+   * @returns {this}
+   */
+  meta(key, value) {
+    this.test.meta[key] = value
+    return this
+  }
+
   /**
    * Set timeout for this test
    * @param {number} timeout

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,8 +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
@@ -31,6 +32,12 @@ function enhanceMochaTest(test) {
   test.artifacts = []
   test.inject = {}
   test.opts = {}
+  test.meta = {}
+
+  test.notes = []
+  test.addNote = (type, note) => {
+    test.notes.push({ type, text: note })
+  }
 
   // Add new methods
   /**
@@ -39,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)
@@ -47,14 +55,105 @@ function enhanceMochaTest(test) {
   test.applyOptions = function (opts) {
     if (!opts) opts = {}
     test.opts = opts
+    test.meta = opts.meta || {}
     test.totalTimeout = opts.timeout
     if (opts.retries) this.retries(opts.retries)
   }
 
+  test.simplify = function () {
+    return serializeTest(this)
+  }
+
+  return test
+}
+
+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,
+  serializeTest,
+  deserializeTest,
+  cloneTest,
 }

package/lib/mocha/types.d.ts

@@ -7,14 +7,25 @@ declare global {
       title: string
       tags: string[]
       steps: string[]
+      meta: Record<string, any>
+      notes: Array<{
+        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
     }