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

package/lib/mocha/asyncWrapper.js

@@ -0,0 +1,274 @@
+import promiseRetry from 'promise-retry'
+import event from '../event.js'
+import recorder from '../recorder.js'
+import assertThrown from '../assert/throws.js'
+import { ucfirst, isAsyncFunction } from '../utils.js'
+import { getInjectedArguments } from './inject.js'
+import { fireHook } from './hooks.js'
+
+const injectHook = function (inject, suite) {
+  try {
+    inject()
+  } catch (err) {
+    recorder.throw(err)
+  }
+  recorder.catch(err => {
+    suiteTestFailedHookError(suite, err)
+    throw err
+  })
+  return recorder.promise()
+}
+
+function suiteTestFailedHookError(suite, err, hookName) {
+  suite.eachTest(test => {
+    test.err = err
+    if (hookName) hookName = ucfirst(hookName)
+    event.emit(event.test.failed, test, err, hookName)
+  })
+}
+
+function makeDoneCallableOnce(done) {
+  let called = false
+  return function (err) {
+    if (called) {
+      return
+    }
+    called = true
+    return done(err)
+  }
+}
+
+/**
+ * Wraps test function, injects support objects from container,
+ * starts promise chain with recorder, performs before/after hooks
+ * through event system.
+ */
+export function test(test) {
+  const testFn = test.fn
+  if (!testFn) {
+    return test
+  }
+
+  test.timeout(0)
+  test.async = true
+
+  test.fn = function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    recorder.errHandler(err => {
+      recorder.session.start('teardown')
+      recorder.cleanAsyncErr()
+      if (test.throws) {
+        // check that test should actually fail
+        try {
+          assertThrown(err, test.throws)
+          event.emit(event.test.passed, test)
+          event.emit(event.test.finished, test)
+          recorder.add(doneFn)
+          return
+        } catch (newErr) {
+          err = newErr
+        }
+      }
+      test.err = err
+      event.emit(event.test.failed, test, err)
+      event.emit(event.test.finished, test)
+      recorder.add(() => doneFn(err))
+    })
+
+    event.emit(event.test.started, test)
+
+    getInjectedArguments(testFn, test)
+      .then(args => {
+        // Start recorder to ensure any steps added within test function are executed
+        recorder.startUnlessRunning()
+
+        // Execute test function
+        const result = testFn.call(test, args)
+
+        // Wait for all recorder steps to complete
+        if (result && result.then) {
+          return result.then(() => recorder.promise())
+        }
+        return recorder.promise()
+      })
+      .then(() => {
+        recorder.add('fire test.passed', () => {
+          event.emit(event.test.passed, test)
+          event.emit(event.test.finished, test)
+        })
+        recorder.add('finish test', doneFn)
+      })
+      .catch(err => {
+        recorder.throw(err)
+      })
+      .finally(() => {
+        recorder.catch()
+      })
+  }
+  return test
+}
+
+/**
+ * Injects arguments to function from controller
+ */
+export function injected(fn, suite, hookName) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    const errHandler = err => {
+      recorder.session.start('teardown')
+      recorder.cleanAsyncErr()
+      if (['before', 'beforeSuite'].includes(hookName)) {
+        suiteTestFailedHookError(suite, err, hookName)
+      }
+      if (hookName === 'after') {
+        suiteTestFailedHookError(suite, err, hookName)
+        suite.eachTest(test => {
+          event.emit(event.test.after, test)
+        })
+      }
+      if (hookName === 'afterSuite') {
+        suiteTestFailedHookError(suite, err, hookName)
+        event.emit(event.suite.after, suite)
+      }
+      recorder.add(() => doneFn(err))
+    }
+
+    recorder.errHandler(err => {
+      errHandler(err)
+    })
+
+    if (!fn) throw new Error('fn is not defined')
+
+    fireHook(event.hook.started, suite)
+
+    this.test.body = fn.toString()
+
+    if (!recorder.isRunning()) {
+      recorder.errHandler(err => {
+        errHandler(err)
+      })
+    }
+
+    const opts = suite.opts || {}
+    const retries = opts[`retry${ucfirst(hookName)}`] || 0
+
+    const currentTest = hookName === 'before' || hookName === 'after' ? suite?.ctx?.currentTest : null
+
+    promiseRetry(
+      async (retry, number) => {
+        try {
+          recorder.startUnlessRunning()
+          const injectedArgs = await getInjectedArguments(fn, null, suite)
+          await fn.call(this, { ...injectedArgs, suite, test: currentTest })
+          await recorder.promise().catch(err => retry(err))
+        } catch (err) {
+          retry(err)
+        } finally {
+          if (number < retries) {
+            recorder.stop()
+            recorder.start()
+          }
+        }
+      },
+      { retries },
+    )
+      .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()
+      })
+      .catch(e => {
+        recorder.throw(e)
+        recorder.catch(e => {
+          const err = recorder.getAsyncErr() === null ? e : recorder.getAsyncErr()
+          errHandler(err)
+        })
+        recorder.add('fire hook.failed', () => fireHook(event.hook.failed, suite, e))
+        recorder.add('fire hook.finished', () => fireHook(event.hook.finished, suite))
+      })
+  }
+}
+
+/**
+ * Starts promise chain, so helpers could enqueue their hooks
+ */
+export function setup(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    recorder.startUnlessRunning()
+    import('./test.js').then(testModule => {
+      const { enhanceMochaTest } = testModule.default || testModule
+      event.emit(event.test.before, enhanceMochaTest(suite?.ctx?.currentTest))
+      recorder.add(() => doneFn())
+    })
+  }
+}
+
+export function teardown(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    recorder.startUnlessRunning()
+    import('./test.js').then(testModule => {
+      const { enhanceMochaTest } = testModule.default || testModule
+      event.emit(event.test.after, enhanceMochaTest(suite?.ctx?.currentTest))
+      recorder.add(() => doneFn())
+    })
+  }
+}
+
+export function suiteSetup(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    recorder.startUnlessRunning()
+
+    // Set up error handler for suite setup
+    recorder.errHandler(err => {
+      doneFn(err)
+    })
+
+    import('./suite.js')
+      .then(suiteModule => {
+        const { enhanceMochaSuite } = suiteModule.default || suiteModule
+        event.emit(event.suite.before, enhanceMochaSuite(suite))
+        recorder.add(() => doneFn())
+      })
+      .catch(err => {
+        doneFn(err)
+      })
+  }
+}
+
+export function suiteTeardown(suite) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    recorder.startUnlessRunning()
+
+    // Set up error handler for suite teardown
+    recorder.errHandler(err => {
+      doneFn(err)
+    })
+
+    import('./suite.js')
+      .then(suiteModule => {
+        const { enhanceMochaSuite } = suiteModule.default || suiteModule
+        event.emit(event.suite.after, enhanceMochaSuite(suite))
+        recorder.add(() => doneFn())
+      })
+      .catch(err => {
+        doneFn(err)
+      })
+  }
+}
+
+export { getInjectedArguments }
+
+export default {
+  test,
+  injected,
+  setup,
+  teardown,
+  suiteSetup,
+  suiteTeardown,
+  getInjectedArguments,
+}

package/lib/mocha/bdd.js

@@ -0,0 +1,167 @@
+import { CucumberExpression, ParameterTypeRegistry, ParameterType } from '@cucumber/cucumber-expressions'
+import event from '../event.js'
+
+let steps = {}
+let Config
+
+const STACK_POSITION = 2
+
+async function getConfig() {
+  if (!Config) {
+    const ConfigModule = await import('../config.js')
+    Config = ConfigModule.default || ConfigModule
+  }
+  return Config
+}
+
+/**
+ * @param {*} step
+ * @param {*} fn
+ */
+// Current file being loaded for step tracking
+let currentStepFile = null
+
+export function setCurrentStepFile(filePath) {
+  currentStepFile = filePath
+}
+
+export function clearCurrentStepFile() {
+  currentStepFile = null
+}
+
+const addStep = async (step, fn) => {
+  const config = await getConfig()
+  const avoidDuplicateSteps = config.get('gherkin', {}).avoidDuplicateSteps || false
+  if (avoidDuplicateSteps && steps[step]) {
+    throw new Error(`Step '${step}' is already defined`)
+  }
+  steps[step] = fn
+
+  // Use the current step file context if available (fallback for old usage)
+  if (currentStepFile) {
+    let relativePath = currentStepFile
+
+    // Remove any leading './' and keep step_definitions/ path
+    relativePath = relativePath.replace(/^\.\//, '').replace(/^.*\/(?=step_definitions)/, '')
+
+    fn.line = `${relativePath}:3:1`
+  } else {
+    fn.line = 'unknown_file:1:1'
+  }
+}
+
+const parameterTypeRegistry = new ParameterTypeRegistry()
+
+const matchStep = step => {
+  for (const stepName in steps) {
+    if (stepName.indexOf('/') === 0) {
+      const regExpArr = stepName.match(/^\/(.*?)\/([gimy]*)$/) || []
+      const res = step.match(new RegExp(regExpArr[1], regExpArr[2]))
+      if (res) {
+        const fn = steps[stepName]
+        fn.params = res.slice(1)
+        return fn
+      }
+      continue
+    }
+    const expression = new CucumberExpression(stepName, parameterTypeRegistry)
+    const res = expression.match(step)
+    if (res) {
+      const fn = steps[stepName]
+      fn.params = res.map(arg => arg.getValue(null))
+      return fn
+    }
+  }
+  throw new Error(`No steps matching "${step.toString()}"`)
+}
+
+const clearSteps = () => {
+  steps = {}
+}
+
+const getSteps = () => {
+  return steps
+}
+
+const defineParameterType = options => {
+  const parameterType = buildParameterType(options)
+  parameterTypeRegistry.defineParameterType(parameterType)
+}
+
+const buildParameterType = ({ name, regexp, transformer, useForSnippets, preferForRegexpMatch }) => {
+  if (typeof useForSnippets !== 'boolean') useForSnippets = true
+  if (typeof preferForRegexpMatch !== 'boolean') preferForRegexpMatch = false
+  return new ParameterType(name, regexp, null, transformer, useForSnippets, preferForRegexpMatch)
+}
+
+// Create wrapper functions that capture the call context
+const createStepFunction = stepType => {
+  return (step, fn) => {
+    // Capture the stack trace at the point where Given/When/Then is called
+    const callStack = new Error().stack
+
+    // Find the caller (step definition file) in the stack
+    let callerInfo = 'unknown_file:1:1'
+    if (callStack) {
+      const stackLines = callStack.split('\n')
+      for (let i = 1; i < stackLines.length; i++) {
+        const line = stackLines[i]
+        if (line.includes('step_definitions') && (line.includes('.js') || line.includes('.mjs'))) {
+          // Extract file path and use line 3:1 as consistent reference (import line)
+          const match = line.match(/file:\/\/.*\/(step_definitions\/[^:]+):(\d+):(\d+)/)
+          if (match) {
+            callerInfo = `${match[1]}:3:1` // Use line 3:1 consistently (import line)
+            break
+          }
+        }
+      }
+    }
+
+    // Instead of using global currentStepFile, pass the caller info directly to addStep
+    return addStepWithCaller(step, fn, callerInfo)
+  }
+}
+
+// New function that accepts caller info directly
+const addStepWithCaller = async (step, fn, callerInfo) => {
+  const config = await getConfig()
+  const avoidDuplicateSteps = config.get('gherkin', {}).avoidDuplicateSteps || false
+  if (avoidDuplicateSteps && steps[step]) {
+    throw new Error(`Step '${step}' is already defined`)
+  }
+  steps[step] = fn
+
+  // Use the caller info passed directly
+  fn.line = callerInfo
+}
+
+const Given = createStepFunction('Given')
+const When = createStepFunction('When')
+const Then = createStepFunction('Then')
+const And = createStepFunction('And')
+
+// Before/After hooks for BDD - these are global event listeners
+const Before = fn => {
+  event.dispatcher.on(event.test.started, fn)
+}
+
+const After = fn => {
+  event.dispatcher.on(event.test.finished, fn)
+}
+
+const Fail = fn => {
+  event.dispatcher.on(event.test.failed, fn)
+}
+
+export { Given, When, Then, And, Before, After, Fail, matchStep, getSteps, clearSteps, defineParameterType }
+
+export default {
+  Given: addStep,
+  When: addStep,
+  Then: addStep,
+  And: addStep,
+  matchStep,
+  getSteps,
+  clearSteps,
+  defineParameterType,
+}