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

package/lib/listener/retryEnhancer.js

@@ -0,0 +1,85 @@
+const event = require('../event')
+const { enhanceMochaTest } = require('../mocha/test')
+
+/**
+ * Enhance retried tests by copying CodeceptJS-specific properties from the original test
+ * This fixes the issue where Mocha's shallow clone during retries loses CodeceptJS properties
+ */
+module.exports = function () {
+  event.dispatcher.on(event.test.before, test => {
+    // Check if this test is a retry (has a reference to the original test)
+    const originalTest = test.retriedTest && test.retriedTest()
+
+    if (originalTest) {
+      // This is a retried test - copy CodeceptJS-specific properties from the original
+      copyCodeceptJSProperties(originalTest, test)
+
+      // Ensure the test is enhanced with CodeceptJS functionality
+      enhanceMochaTest(test)
+    }
+  })
+}
+
+/**
+ * Copy CodeceptJS-specific properties from the original test to the retried test
+ * @param {CodeceptJS.Test} originalTest - The original test object
+ * @param {CodeceptJS.Test} retriedTest - The retried test object
+ */
+function copyCodeceptJSProperties(originalTest, retriedTest) {
+  // Copy CodeceptJS-specific properties
+  if (originalTest.opts !== undefined) {
+    retriedTest.opts = originalTest.opts ? { ...originalTest.opts } : {}
+  }
+
+  if (originalTest.tags !== undefined) {
+    retriedTest.tags = originalTest.tags ? [...originalTest.tags] : []
+  }
+
+  if (originalTest.notes !== undefined) {
+    retriedTest.notes = originalTest.notes ? [...originalTest.notes] : []
+  }
+
+  if (originalTest.meta !== undefined) {
+    retriedTest.meta = originalTest.meta ? { ...originalTest.meta } : {}
+  }
+
+  if (originalTest.artifacts !== undefined) {
+    retriedTest.artifacts = originalTest.artifacts ? [...originalTest.artifacts] : []
+  }
+
+  if (originalTest.steps !== undefined) {
+    retriedTest.steps = originalTest.steps ? [...originalTest.steps] : []
+  }
+
+  if (originalTest.config !== undefined) {
+    retriedTest.config = originalTest.config ? { ...originalTest.config } : {}
+  }
+
+  if (originalTest.inject !== undefined) {
+    retriedTest.inject = originalTest.inject ? { ...originalTest.inject } : {}
+  }
+
+  // Copy methods that might be missing
+  if (originalTest.addNote && !retriedTest.addNote) {
+    retriedTest.addNote = function (type, note) {
+      this.notes = this.notes || []
+      this.notes.push({ type, text: note })
+    }
+  }
+
+  if (originalTest.applyOptions && !retriedTest.applyOptions) {
+    retriedTest.applyOptions = originalTest.applyOptions.bind(retriedTest)
+  }
+
+  if (originalTest.simplify && !retriedTest.simplify) {
+    retriedTest.simplify = originalTest.simplify.bind(retriedTest)
+  }
+
+  // Preserve the uid if it exists
+  if (originalTest.uid !== undefined) {
+    retriedTest.uid = originalTest.uid
+  }
+
+  // Mark as enhanced
+  retriedTest.codeceptjs = true
+}

package/lib/listener/steps.js

@@ -2,47 +2,55 @@ const debug = require('debug')('codeceptjs:steps')
 const event = require('../event')
 const store = require('../store')
 const output = require('../output')
+const { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } = require('../mocha/hooks')
+const recorder = require('../recorder')
 
 let currentTest
 let currentHook
 
+// Session names that should not contribute steps to the main test trace
+const EXCLUDED_SESSIONS = ['tryTo', 'hopeThat']
+
 /**
  * Register steps inside tests
  */
 module.exports = function () {
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     test.startedAt = +new Date()
-    test.artifacts = {}
   })
 
-  event.dispatcher.on(event.test.started, (test) => {
+  event.dispatcher.on(event.test.started, test => {
     currentTest = test
     currentTest.steps = []
     if (!('retryNum' in currentTest)) currentTest.retryNum = 0
     else currentTest.retryNum += 1
+    output.scenario.started(test)
   })
 
-  event.dispatcher.on(event.test.after, (test) => {
+  event.dispatcher.on(event.test.after, test => {
     currentTest = null
   })
 
-  event.dispatcher.on(event.test.finished, (test) => {})
+  event.dispatcher.on(event.test.finished, test => {})
 
-  event.dispatcher.on(event.hook.started, (suite) => {
-    currentHook = suite.ctx.test
+  event.dispatcher.on(event.hook.started, hook => {
+    currentHook = hook.ctx.test
     currentHook.steps = []
 
-    if (suite.ctx && suite.ctx.test) output.log(`--- STARTED ${suite.ctx.test.title} ---`)
+    output.hook.started(hook)
+
+    if (hook.ctx && hook.ctx.test) debug(`--- STARTED ${hook.ctx.test.title} ---`)
   })
 
-  event.dispatcher.on(event.hook.passed, (suite) => {
+  event.dispatcher.on(event.hook.passed, hook => {
     currentHook = null
-    if (suite.ctx && suite.ctx.test) output.log(`--- ENDED ${suite.ctx.test.title} ---`)
+    output.hook.passed(hook)
+    if (hook.ctx && hook.ctx.test) debug(`--- ENDED ${hook.ctx.test.title} ---`)
   })
 
   event.dispatcher.on(event.test.failed, () => {
     const cutSteps = function (current) {
-      const failureIndex = current.steps.findIndex((el) => el.status === 'failed')
+      const failureIndex = current.steps.findIndex(el => el.status === 'failed')
       // To be sure that failed test will be failed in report
       current.state = 'failed'
       current.steps.length = failureIndex + 1
@@ -65,19 +73,25 @@ module.exports = function () {
     currentTest.state = 'passed'
   })
 
-  event.dispatcher.on(event.step.started, (step) => {
-    step.startedAt = +new Date()
-    step.test = currentTest
+  event.dispatcher.on(event.step.started, step => {
+    store.currentStep = step
     if (currentHook && Array.isArray(currentHook.steps)) {
       return currentHook.steps.push(step)
     }
     if (!currentTest || !currentTest.steps) return
+    
+    // Check if we're in a session that should be excluded from main test steps
+    const currentSessionId = recorder.getCurrentSessionId()
+    if (currentSessionId && EXCLUDED_SESSIONS.includes(currentSessionId)) {
+      // Skip adding this step to the main test steps
+      return
+    }
+    
     currentTest.steps.push(step)
   })
 
-  event.dispatcher.on(event.step.finished, (step) => {
-    step.finishedAt = +new Date()
-    if (step.startedAt) step.duration = step.finishedAt - step.startedAt
-    debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`)
+  event.dispatcher.on(event.step.finished, step => {
+    store.currentStep = null
+    store.stepOptions = null
   })
 }

package/lib/listener/store.js

@@ -0,0 +1,20 @@
+const event = require('../event')
+const store = require('../store')
+
+module.exports = function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    store.currentSuite = suite
+  })
+
+  event.dispatcher.on(event.suite.after, () => {
+    store.currentSuite = null
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    store.currentTest = test
+  })
+
+  event.dispatcher.on(event.test.finished, () => {
+    store.currentTest = null
+  })
+}

package/lib/locator.js

@@ -389,7 +389,7 @@ class Locator {
 }
 
 /**
- * @param {CodeceptJS.LocatorOrString} locator
+ * @param {CodeceptJS.LocatorOrString} [locator]
  * @returns {Locator}
  */
 Locator.build = (locator) => {

package/lib/mocha/asyncWrapper.js

@@ -0,0 +1,231 @@
+const promiseRetry = require('promise-retry')
+const event = require('../event')
+const recorder = require('../recorder')
+const assertThrown = require('../assert/throws')
+const { ucfirst, isAsyncFunction } = require('../utils')
+const { getInjectedArguments } = require('./inject')
+const { fireHook } = require('./hooks')
+
+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.
+ */
+module.exports.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))
+    })
+
+    if (isAsyncFunction(testFn)) {
+      event.emit(event.test.started, test)
+      testFn
+        .call(test, getInjectedArguments(testFn, test))
+        .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
+    }
+
+    try {
+      event.emit(event.test.started, test)
+      testFn.call(test, getInjectedArguments(testFn, test))
+    } catch (err) {
+      recorder.throw(err)
+    } finally {
+      recorder.add('fire test.passed', () => {
+        event.emit(event.test.passed, test)
+        event.emit(event.test.finished, test)
+      })
+      recorder.add('finish test', doneFn)
+      recorder.catch()
+    }
+  }
+  return test
+}
+
+/**
+ * Injects arguments to function from controller
+ */
+module.exports.injected = function (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()
+          await fn.call(this, { ...getInjectedArguments(fn), 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
+ */
+module.exports.setup = function (suite) {
+  const { enhanceMochaTest } = require('./test')
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.test.before, enhanceMochaTest(suite?.ctx?.currentTest))
+  }, suite)
+}
+
+module.exports.teardown = function (suite) {
+  const { enhanceMochaTest } = require('./test')
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.test.after, enhanceMochaTest(suite?.ctx?.currentTest))
+  }, suite)
+}
+
+module.exports.suiteSetup = function (suite) {
+  const { enhanceMochaSuite } = require('./suite')
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.suite.before, enhanceMochaSuite(suite))
+  }, suite)
+}
+
+module.exports.suiteTeardown = function (suite) {
+  const { enhanceMochaSuite } = require('./suite')
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.suite.after, enhanceMochaSuite(suite))
+  }, suite)
+}
+
+module.exports.getInjectedArguments = getInjectedArguments

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

@@ -27,7 +27,7 @@ const addStep = (step, fn) => {
 
 const parameterTypeRegistry = new ParameterTypeRegistry()
 
-const matchStep = (step) => {
+const matchStep = step => {
   for (const stepName in steps) {
     if (stepName.indexOf('/') === 0) {
       const regExpArr = stepName.match(/^\/(.*?)\/([gimy]*)$/) || []
@@ -43,7 +43,7 @@ const matchStep = (step) => {
     const res = expression.match(step)
     if (res) {
       const fn = steps[stepName]
-      fn.params = res.map((arg) => arg.getValue())
+      fn.params = res.map(arg => arg.getValue())
       return fn
     }
   }
@@ -58,7 +58,7 @@ const getSteps = () => {
   return steps
 }
 
-const defineParameterType = (options) => {
+const defineParameterType = options => {
   const parameterType = buildParameterType(options)
   parameterTypeRegistry.defineParameterType(parameterType)
 }