codeceptjs 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/mocha/cli.js

@@ -0,0 +1,341 @@
+import mocha from 'mocha'
+const { reporters: { Base } } = mocha
+import ms from 'ms'
+import figures from 'figures'
+import { readFileSync } from 'fs'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import event from '../event.js'
+import AssertionFailedError from '../assert/error.js'
+import output from '../output.js'
+import test, { cloneTest } from './test.js'
+
+// Get version from package.json to avoid circular dependency
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const packagePath = join(__dirname, '../../package.json')
+const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'))
+const codeceptVersion = packageJson.version
+const cursor = Base.cursor
+let currentMetaStep = []
+let codeceptjsEventDispatchersRegistered = false
+
+// Lazy container loading to avoid circular dependencies
+let containerPromise = null
+const getContainer = () => {
+  if (!containerPromise) {
+    containerPromise = import('../container.js').then(module => module.default || module)
+  }
+  return containerPromise
+}
+
+class Cli extends Base {
+  constructor(runner, opts) {
+    super(runner)
+    let level = 0
+    this.loadedTests = []
+    opts = opts.reporterOptions || opts
+    if (opts.steps) level = 1
+    if (opts.debug) level = 2
+    if (opts.verbose) level = 3
+    output.level(level)
+    output.print(`CodeceptJS v${codeceptVersion} ${output.standWithUkraine()}`)
+    output.print(`Using test root "${global.codecept_dir}"`)
+
+    const showSteps = level >= 1
+
+    if (level >= 2) {
+      // Load container asynchronously to avoid circular dependency
+      getContainer().then(Container => {
+        output.print(output.styles.debug(`Helpers: ${Object.keys(Container.helpers()).join(', ')}`))
+        output.print(output.styles.debug(`Plugins: ${Object.keys(Container.plugins()).join(', ')}`))
+      }).catch(() => {
+        // Silently fail if container can't be loaded
+        output.print(output.styles.debug('Helpers: [loading...]'))
+        output.print(output.styles.debug('Plugins: [loading...]'))
+      })
+    }
+
+    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()
+    })
+
+    runner.on('suite', suite => {
+      output.suite.started(suite)
+    })
+
+    runner.on('fail', test => {
+      if (test.ctx.currentTest) {
+        this.loadedTests.push(test.ctx.currentTest.uid)
+      }
+      if (showSteps && test.steps) {
+        return output.scenario.failed(test)
+      }
+      cursor.CR()
+      output.test.failed(test)
+    })
+
+    runner.on('pending', test => {
+      if (test.parent && test.parent.pending) {
+        const suite = test.parent
+        const skipInfo = suite.opts.skipInfo || {}
+        skipTestConfig(test, skipInfo.message)
+      } else {
+        skipTestConfig(test, null)
+      }
+      this.loadedTests.push(test.uid)
+      cursor.CR()
+      output.test.skipped(test)
+    })
+
+    runner.on('pass', test => {
+      if (showSteps && test.steps) {
+        return output.scenario.passed(test)
+      }
+      cursor.CR()
+      output.test.passed(test)
+    })
+
+    if (showSteps) {
+      runner.on('test', test => {
+        currentMetaStep = []
+        if (test.steps) {
+          output.test.started(test)
+        }
+      })
+
+      if (!codeceptjsEventDispatchersRegistered) {
+        codeceptjsEventDispatchersRegistered = true
+
+        event.dispatcher.on(event.bddStep.started, step => {
+          output.stepShift = 2
+          output.step(step)
+        })
+
+        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
+
+          for (let i = 0; i < Math.max(currentMetaStep.length, metaSteps.length); i++) {
+            if (currentMetaStep[i] !== metaSteps[i]) {
+              output.stepShift = 3 + 2 * i
+              if (!metaSteps[i]) continue
+              // bdd steps are handled by bddStep.started
+              if (metaSteps[i].isBDD()) continue
+              output.step(metaSteps[i])
+            }
+          }
+          currentMetaStep = metaSteps
+          if (isHidden) return
+          output.stepShift = 3 + 2 * shift
+          output.step(step)
+        })
+
+        event.dispatcher.on(event.step.finished, () => {
+          output.stepShift = 0
+        })
+      }
+    }
+
+    runner.on('suite end', suite => {
+      let skippedCount = 0
+      const grep = runner._grep
+      for (const test of suite.tests) {
+        if (!test.state && !this.loadedTests.includes(test.uid)) {
+          if (matchTest(grep, test.title)) {
+            if (!test.opts) {
+              test.opts = {}
+            }
+            if (!test.opts.skipInfo) {
+              test.opts.skipInfo = {}
+            }
+            skipTestConfig(test, "Skipped due to failure in 'before' hook")
+            output.test.skipped(test)
+            skippedCount += 1
+          }
+        }
+      }
+
+      getContainer().then(Container => {
+        Container.result().addStats({ pending: skippedCount, tests: skippedCount })
+      }).catch(() => {
+        // Silently fail if container can't be loaded
+      })
+    })
+
+    runner.on('end', this.result.bind(this))
+  }
+
+  async result() {
+    try {
+      const Container = await getContainer()
+      Container.result().addStats(this.stats)
+      Container.result().finish()
+
+      const stats = Container.result().stats
+    console.log()
+
+    // passes
+    if (stats.failures) {
+      output.print(output.styles.bold('-- FAILURES:'))
+    }
+
+    const failuresLog = []
+
+    // failures
+    if (stats.failures) {
+      // append step traces
+      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:')} file://${test.file}\n`
+        }
+
+        const steps = test.steps || (test.ctx && test.ctx.test.steps)
+
+        if (steps && steps.length) {
+          let scenarioTrace = ''
+          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.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
+          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)}`
+        } catch (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
+      Base.consoleLog = (...data) => {
+        failuresLog.push([...data])
+        originalLog(...data)
+      }
+      Base.list(this.failures)
+      Base.consoleLog = originalLog
+      console.log()
+    }
+
+      Container.result().addFailures(failuresLog)
+
+      output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration), stats.failedHooks)
+
+      if (stats.failures && output.level() < 3) {
+        output.print(output.styles.debug('Run with --verbose flag to see complete NodeJS stacktrace'))
+      }
+    } catch (error) {
+      // Fallback behavior if container can't be loaded
+      console.log('Error loading container:', error.message)
+      output.result(0, 1, 0, 0, 0)
+    }
+  }
+}
+
+function matchTest(grep, test) {
+  if (grep) {
+    return grep.test(test)
+  }
+  return true
+}
+
+function skipTestConfig(test, message) {
+  if (!test.opts) {
+    test.opts = {}
+  }
+  if (!test.opts.skipInfo) {
+    test.opts.skipInfo = {}
+  }
+  test.opts.skipInfo.message = test.opts.skipInfo.message || message
+  test.opts.skipInfo.isFastSkipped = true
+  event.emit(event.test.skipped, test)
+  test.state = 'skipped'
+}
+
+export default function (runner, opts) {
+  return new Cli(runner, opts)
+}

package/lib/mocha/factory.js

@@ -0,0 +1,163 @@
+import Mocha from 'mocha'
+import fsPath from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+import reporter from './cli.js'
+import gherkinParser, { loadTranslations } from './gherkin.js'
+import output from '../output.js'
+import scenarioUiFunction from './ui.js'
+import { initMochaGlobals } from '../globals.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = fsPath.dirname(__filename)
+
+let mocha
+
+class MochaFactory {
+  static create(config, opts) {
+    mocha = new Mocha(Object.assign(config, opts))
+    output.process(opts.child)
+    mocha.ui(scenarioUiFunction)
+
+    // Manually trigger UI setup for globals to be available in ESM context
+    // This ensures Feature, Scenario, Before, etc. are available immediately
+    if (mocha.suite && mocha.suite.emit) {
+      const context = {}
+      mocha.suite.emit('pre-require', context, '', mocha)
+      // Also set globals immediately so they're available when ESM modules load
+      initMochaGlobals(context)
+    }
+
+    Mocha.Runner.prototype.uncaught = function (err) {
+      if (err) {
+        if (err.toString().indexOf('ECONNREFUSED') >= 0) {
+          // Handle ECONNREFUSED without dynamic import for now
+          err = new Error('Connection refused: ' + err.toString())
+        }
+        output.error(err)
+        output.print(err.stack)
+        process.exit(1)
+      }
+      output.error('Uncaught undefined exception')
+      process.exit(1)
+    }
+
+    // Override loadFiles to handle feature files
+    const originalLoadFiles = Mocha.prototype.loadFiles
+    mocha.loadFiles = function (fn) {
+      // load features
+      const featureFiles = this.files.filter(file => file.match(/\.feature$/))
+      if (featureFiles.length > 0) {
+        // Load translations for Gherkin features
+        loadTranslations().catch(() => {
+          // Ignore if translations can't be loaded
+        })
+
+        for (const file of featureFiles) {
+          const suite = gherkinParser(fs.readFileSync(file, 'utf8'), file)
+          this.suite.addSuite(suite)
+        }
+
+        // remove feature files
+        const jsFiles = this.files.filter(file => !file.match(/\.feature$/))
+        this.files = this.files.filter(file => !file.match(/\.feature$/))
+
+        // Load JavaScript test files using ESM imports
+        if (jsFiles.length > 0) {
+          try {
+            // Try original loadFiles first for compatibility
+            originalLoadFiles.call(this, fn)
+          } catch (e) {
+            // If original loadFiles fails, load ESM files manually
+            if (e.message.includes('not in cache') || e.message.includes('ESM') || e.message.includes('getStatus')) {
+              // Load ESM files by importing them synchronously using top-level await workaround
+              for (const file of jsFiles) {
+                try {
+                  // Convert file path to file:// URL for dynamic import
+                  const fileUrl = `file://${file}`
+                  // Use import() but don't await it - let it load in the background
+                  import(fileUrl).catch(importErr => {
+                    // If dynamic import fails, the file may have syntax errors or other issues
+                    console.error(`Failed to load test file ${file}:`, importErr.message)
+                  })
+                  if (fn) fn()
+                } catch (fileErr) {
+                  console.error(`Error processing test file ${file}:`, fileErr.message)
+                  if (fn) fn(fileErr)
+                }
+              }
+            } else {
+              throw e
+            }
+          }
+        }
+
+        // add ids for each test and check uniqueness
+        const dupes = []
+        let missingFeatureInFile = []
+        const seenTests = []
+        this.suite.eachTest(test => {
+          if (!test) {
+            return // Skip undefined tests
+          }
+          const name = test.fullTitle()
+          if (seenTests.includes(test.uid)) {
+            dupes.push(name)
+          }
+          seenTests.push(test.uid)
+
+          if (name.slice(0, name.indexOf(':')) === '') {
+            missingFeatureInFile.push(test.file)
+          }
+        })
+        if (dupes.length) {
+          // ideally this should be no-op and throw (breaking change)...
+          output.error(`Duplicate test names detected - Feature + Scenario name should be unique:\n${dupes.join('\n')}`)
+        }
+
+        if (missingFeatureInFile.length) {
+          missingFeatureInFile = [...new Set(missingFeatureInFile)]
+          output.error(`Missing Feature section in:\n${missingFeatureInFile.join('\n')}`)
+        }
+      } else {
+        // Use original for non-feature files
+        originalLoadFiles.call(this, fn)
+      }
+    }
+
+    const presetReporter = opts.reporter || config.reporter
+    // use standard reporter
+    if (!presetReporter) {
+      mocha.reporter(reporter, opts)
+      return mocha
+    }
+
+    // load custom reporter with options
+    const reporterOptions = Object.assign(config.reporterOptions || {})
+
+    if (opts.reporterOptions !== undefined) {
+      opts.reporterOptions.split(',').forEach(opt => {
+        const L = opt.split('=')
+        if (L.length > 2 || L.length === 0) {
+          throw new Error(`invalid reporter option '${opt}'`)
+        } else if (L.length === 2) {
+          reporterOptions[L[0]] = L[1]
+        } else {
+          reporterOptions[L[0]] = true
+        }
+      })
+    }
+
+    const attributes = Object.getOwnPropertyDescriptor(reporterOptions, 'codeceptjs-cli-reporter')
+    if (reporterOptions['codeceptjs-cli-reporter'] && attributes) {
+      Object.defineProperty(reporterOptions, 'codeceptjs/lib/mocha/cli', attributes)
+      delete reporterOptions['codeceptjs-cli-reporter']
+    }
+
+    // custom reporters
+    mocha.reporter(presetReporter, reporterOptions)
+    return mocha
+  }
+}
+
+export default MochaFactory

package/lib/mocha/featureConfig.js

@@ -0,0 +1,89 @@
+/**
+ * Configuration for a Feature.
+ * Can inject values and add custom configuration.
+ */
+class FeatureConfig {
+  /**
+   * @param {CodeceptJS.Suite} suite
+   */
+  constructor(suite) {
+    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
+   *
+   * @param {number} retries
+   * @returns {this}
+   */
+  retry(retries) {
+    this.suite.retries(retries)
+    return this
+  }
+
+  /**
+   * Set timeout for this test
+   * @param {number} timeout
+   * @returns {this}
+   */
+  timeout(timeout) {
+    this.suite.timeout(timeout)
+    return this
+  }
+
+  /**
+   * @callback FeatureConfigCallback
+   * @param {CodeceptJS.Suite} suite
+   * @returns {Object<string, any>}
+   */
+
+  /**
+   * Configures a helper.
+   * Helper name can be omitted and values will be applied to first helper.
+   * @param {string | Object<string, any> | FeatureConfigCallback} helper
+   * @param {Object<string, any>} [obj]
+   * @returns {this}
+   */
+  config(helper, obj) {
+    if (!obj) {
+      obj = helper
+      helper = 0
+    }
+    if (typeof obj === 'function') {
+      obj = obj(this.suite)
+    }
+    if (!this.suite.config) {
+      this.suite.config = {}
+    }
+    this.suite.config[helper] = obj
+    return this
+  }
+
+  /**
+   * Append a tag name to scenario title
+   * @param {string} tagName
+   * @returns {this}
+   */
+  tag(tagName) {
+    if (tagName[0] !== '@') tagName = `@${tagName}`
+    if (!this.suite.tags) this.suite.tags = []
+    this.suite.tags.push(tagName)
+    this.suite.title = `${this.suite.title.trim()} ${tagName}`
+    return this
+  }
+}
+
+export default FeatureConfig