codeceptjs 4.0.0-beta.3 → 4.0.0-beta.5

package/lib/mocha/cli.js

@@ -0,0 +1,308 @@
+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
+
+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${require('../codecept').version()} ${output.standWithUkraine()}`)
+    output.print(`Using test root "${global.codecept_dir}"`)
+
+    const showSteps = level >= 1
+
+    if (level >= 2) {
+      const Containter = require('../container')
+      output.print(output.styles.debug(`Helpers: ${Object.keys(Containter.helpers()).join(', ')}`))
+      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()
+    })
+
+    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
+          }
+        }
+      }
+
+      const container = require('../container')
+      container.result().addStats({ pending: skippedCount, tests: skippedCount })
+    })
+
+    runner.on('end', this.result.bind(this))
+  }
+
+  result() {
+    const container = require('../container')
+    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'))
+    }
+  }
+}
+
+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'
+}
+
+module.exports = function (runner, opts) {
+  return new Cli(runner, opts)
+}

package/lib/mocha/factory.js

@@ -0,0 +1,104 @@
+const Mocha = require('mocha')
+const fsPath = require('path')
+const fs = require('fs')
+const reporter = require('./cli')
+const gherkinParser = require('./gherkin')
+const output = require('../output')
+const ConnectionRefused = require('../helper/errors/ConnectionRefused')
+
+const scenarioUi = fsPath.join(__dirname, './ui.js')
+
+let mocha
+
+class MochaFactory {
+  static create(config, opts) {
+    mocha = new Mocha(Object.assign(config, opts))
+    output.process(opts.child)
+    mocha.ui(scenarioUi)
+
+    Mocha.Runner.prototype.uncaught = function (err) {
+      if (err) {
+        if (err.toString().indexOf('ECONNREFUSED') >= 0) {
+          err = new ConnectionRefused(err)
+        }
+        output.error(err)
+        output.print(err.stack)
+        process.exit(1)
+      }
+      output.error('Uncaught undefined exception')
+      process.exit(1)
+    }
+
+    mocha.loadFiles = fn => {
+      // load features
+      if (mocha.suite.suites.length === 0) {
+        mocha.files.filter(file => file.match(/\.feature$/)).forEach(file => mocha.suite.addSuite(gherkinParser(fs.readFileSync(file, 'utf8'), file)))
+
+        // remove feature files
+        mocha.files = mocha.files.filter(file => !file.match(/\.feature$/))
+
+        Mocha.prototype.loadFiles.call(mocha, fn)
+
+        // add ids for each test and check uniqueness
+        const dupes = []
+        let missingFeatureInFile = []
+        const seenTests = []
+        mocha.suite.eachTest(test => {
+          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')}`)
+        }
+      }
+    }
+
+    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
+  }
+}
+
+module.exports = MochaFactory

package/lib/{interfaces → mocha}/featureConfig.js

@@ -1,11 +1,30 @@
-/** @class */
+/**
+ * Configuration for a Feature.
+ * Can inject values and add custom configuration.
+ */
 class FeatureConfig {
+  /**
+   * @param {CodeceptJS.Suite} suite
+   */
   constructor(suite) {
     this.suite = suite
   }
 
   /**
-   * Retry this suite for x times
+   * 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}
@@ -16,24 +35,26 @@ class FeatureConfig {
   }
 
   /**
-   * Set timeout for this suite
+   * Set timeout for this test
    * @param {number} timeout
    * @returns {this}
-   * @deprecated
    */
   timeout(timeout) {
-    console.log(`Feature('${this.suite.title}').timeout(${timeout}) is deprecated!`)
-    console.log(`Please use Feature('${this.suite.title}', { timeout: ${timeout / 1000} }) instead`)
-    console.log('Timeout should be set in seconds')
     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, *>} helper
-   * @param {Object<string, *>} [obj]
+   * @param {string | Object<string, any> | FeatureConfigCallback} helper
+   * @param {Object<string, any>} [obj]
    * @returns {this}
    */
   config(helper, obj) {
@@ -57,9 +78,8 @@ class FeatureConfig {
    * @returns {this}
    */
   tag(tagName) {
-    if (tagName[0] !== '@') {
-      tagName = `@${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

package/lib/{interfaces → mocha}/gherkin.js

@@ -1,11 +1,13 @@
 const Gherkin = require('@cucumber/gherkin')
 const Messages = require('@cucumber/messages')
-const { Context, Suite, Test } = require('mocha')
+const { Context, Suite } = require('mocha')
 const debug = require('debug')('codeceptjs:bdd')
 
+const { enhanceMochaSuite } = require('./suite')
+const { createTest } = require('./test')
 const { matchStep } = require('./bdd')
 const event = require('../event')
-const scenario = require('../scenario')
+const { injected, setup, teardown, suiteSetup, suiteTeardown } = require('./asyncWrapper')
 const Step = require('../step')
 const DataTableArgument = require('../data/dataTableArgument')
 const transform = require('../transform')
@@ -28,7 +30,8 @@ module.exports = (text, file) => {
     throw new Error(`No 'Features' available in Gherkin '${file}' provided!`)
   }
   const suite = new Suite(ast.feature.name, new Context())
-  const tags = ast.feature.tags.map((t) => t.name)
+  enhanceMochaSuite(suite)
+  const tags = ast.feature.tags.map(t => t.name)
   suite.title = `${suite.title} ${tags.join(' ')}`.trim()
   suite.tags = tags || []
   suite.comment = ast.feature.description
@@ -36,17 +39,17 @@ module.exports = (text, file) => {
   suite.file = file
   suite.timeout(0)
 
-  suite.beforeEach('codeceptjs.before', () => scenario.setup(suite))
-  suite.afterEach('codeceptjs.after', () => scenario.teardown(suite))
-  suite.beforeAll('codeceptjs.beforeSuite', () => scenario.suiteSetup(suite))
-  suite.afterAll('codeceptjs.afterSuite', () => scenario.suiteTeardown(suite))
+  suite.beforeEach('codeceptjs.before', () => setup(suite))
+  suite.afterEach('codeceptjs.after', () => teardown(suite))
+  suite.beforeAll('codeceptjs.beforeSuite', () => suiteSetup(suite))
+  suite.afterAll('codeceptjs.afterSuite', () => suiteTeardown(suite))
 
-  const runSteps = async (steps) => {
+  const runSteps = async steps => {
     for (const step of steps) {
       const metaStep = new Step.MetaStep(null, step.text)
       metaStep.actor = step.keyword.trim()
       let helperStep
-      const setMetaStep = (step) => {
+      const setMetaStep = step => {
         helperStep = step
         if (step.metaStep) {
           if (step.metaStep === metaStep) {
@@ -100,18 +103,13 @@ module.exports = (text, file) => {
     if (child.background) {
       suite.beforeEach(
         'Before',
-        scenario.injected(async () => runSteps(child.background.steps), suite, 'before'),
+        injected(async () => runSteps(child.background.steps), suite, 'before'),
       )
       continue
     }
-    if (
-      child.scenario &&
-      (currentLanguage
-        ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline
-        : child.scenario.keyword === 'Scenario Outline')
-    ) {
+    if (child.scenario && (currentLanguage ? currentLanguage.contexts.ScenarioOutline === child.scenario.keyword : child.scenario.keyword === 'Scenario Outline')) {
       for (const examples of child.scenario.examples) {
-        const fields = examples.tableHeader.cells.map((c) => c.value)
+        const fields = examples.tableHeader.cells.map(c => c.value)
         for (const example of examples.tableBody) {
           let exampleSteps = [...child.scenario.steps]
           const current = {}
@@ -120,13 +118,13 @@ module.exports = (text, file) => {
             const value = transform('gherkin.examples', example.cells[index].value)
             example.cells[index].value = value
             current[placeholder] = value
-            exampleSteps = exampleSteps.map((step) => {
+            exampleSteps = exampleSteps.map(step => {
               step = { ...step }
               step.text = step.text.split(`<${placeholder}>`).join(value)
               return step
             })
           }
-          const tags = child.scenario.tags.map((t) => t.name).concat(examples.tags.map((t) => t.name))
+          const tags = child.scenario.tags.map(t => t.name).concat(examples.tags.map(t => t.name))
           let title = `${child.scenario.name} ${JSON.stringify(current)} ${tags.join(' ')}`.trim()
 
           for (const [key, value] of Object.entries(current)) {
@@ -135,22 +133,22 @@ module.exports = (text, file) => {
             }
           }
 
-          const test = new Test(title, async () => runSteps(addExampleInTable(exampleSteps, current)))
+          const test = createTest(title, async () => runSteps(addExampleInTable(exampleSteps, current)))
+          test.addToSuite(suite)
           test.tags = suite.tags.concat(tags)
           test.file = file
-          suite.addTest(scenario.test(test))
         }
       }
       continue
     }
 
     if (child.scenario) {
-      const tags = child.scenario.tags.map((t) => t.name)
+      const tags = child.scenario.tags.map(t => t.name)
       const title = `${child.scenario.name} ${tags.join(' ')}`.trim()
-      const test = new Test(title, async () => runSteps(child.scenario.steps))
+      const test = createTest(title, async () => runSteps(child.scenario.steps))
+      test.addToSuite(suite)
       test.tags = suite.tags.concat(tags)
       test.file = file
-      suite.addTest(scenario.test(test))
     }
   }
 
@@ -162,8 +160,8 @@ function transformTable(table) {
   for (const id in table.rows) {
     const cells = table.rows[id].cells
     str += cells
-      .map((c) => c.value)
-      .map((c) => c.padEnd(15))
+      .map(c => c.value)
+      .map(c => c.padEnd(15))
       .join(' | ')
     str += '\n'
   }
@@ -172,12 +170,12 @@ function transformTable(table) {
 function addExampleInTable(exampleSteps, placeholders) {
   const steps = JSON.parse(JSON.stringify(exampleSteps))
   for (const placeholder in placeholders) {
-    steps.map((step) => {
+    steps.map(step => {
       step = { ...step }
       if (step.dataTable) {
         for (const id in step.dataTable.rows) {
           const cells = step.dataTable.rows[id].cells
-          cells.map((c) => (c.value = c.value.replace(`<${placeholder}>`, placeholders[placeholder])))
+          cells.map(c => (c.value = c.value.replace(`<${placeholder}>`, placeholders[placeholder])))
         }
       }
       return step