codeceptjs 3.7.0-beta.6 → 3.7.0-beta.8

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,8 +185,18 @@ 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
 
         const steps = test.steps || (test.ctx && test.ctx.test.steps)
 
@@ -204,25 +229,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 +265,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

@@ -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)
     },
   },

package/lib/pause.js

@@ -84,12 +84,10 @@ function pauseSession(passedObject = {}) {
   })
   return new Promise(resolve => {
     finish = resolve
-    // eslint-disable-next-line
     return askForStep()
   })
 }
 
-/* eslint-disable */
 async function parseInput(cmd) {
   rl.pause()
   next = false
@@ -198,7 +196,6 @@ async function parseInput(cmd) {
   recorder.add('ask for next step', askForStep)
   nextStep()
 }
-/* eslint-enable */
 
 function askForStep() {
   return new Promise(resolve => {