codeceptjs 3.6.10 → 3.7.0-beta.10

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

@@ -1,11 +1,27 @@
-/** @class */
+/**
+ * Configuration for a Feature.
+ * Can inject values and add custom configuration.
+ */
 class FeatureConfig {
   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,15 +32,11 @@ 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
   }
@@ -32,8 +44,9 @@ class FeatureConfig {
   /**
    * 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|number} helper
+   * @param {*} obj
    * @returns {this}
    */
   config(helper, obj) {
@@ -57,9 +70,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 ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline : 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

package/lib/mocha/hooks.js

@@ -0,0 +1,112 @@
+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.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
+  }
+
+  toCode() {
+    return this.toString() + '()'
+  }
+
+  retry(n) {
+    this.suite.opts[`retry${this.hookName}`] = n
+  }
+
+  get title() {
+    return this.ctx?.test?.title || this.name
+  }
+
+  get name() {
+    return this.constructor.name
+  }
+}
+
+class BeforeHook extends Hook {}
+
+class AfterHook extends Hook {}
+
+class BeforeSuiteHook extends Hook {}
+
+class AfterSuiteHook extends Hook {}
+
+function fireHook(eventType, suite, error) {
+  const hook = suite.ctx?.test?.title?.match(/"([^"]*)"/)[1]
+  switch (hook) {
+    case 'before each':
+      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, error))
+      break
+    case 'after all':
+      event.emit(eventType, new AfterSuiteHook(suite, error))
+      break
+    default:
+      event.emit(eventType, suite, error)
+  }
+}
+
+class HookConfig {
+  constructor(hook) {
+    this.hook = hook
+  }
+
+  retry(n) {
+    this.hook.retry(n)
+    return this
+  }
+}
+
+module.exports = {
+  BeforeHook,
+  AfterHook,
+  BeforeSuiteHook,
+  AfterSuiteHook,
+  fireHook,
+  HookConfig,
+}

package/lib/mocha/index.js

@@ -0,0 +1,12 @@
+const Suite = require('mocha/lib/suite')
+const Test = require('mocha/lib/test')
+const { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } = require('./hooks')
+
+module.exports = {
+  Suite,
+  Test,
+  BeforeHook,
+  AfterHook,
+  BeforeSuiteHook,
+  AfterSuiteHook,
+}

package/lib/mocha/inject.js

@@ -0,0 +1,29 @@
+const parser = require('../parser')
+
+const getInjectedArguments = (fn, test) => {
+  const container = require('../container')
+  const testArgs = {}
+  const params = parser.getParams(fn) || []
+  const objects = container.support()
+
+  for (const key of params) {
+    testArgs[key] = {}
+    if (test && test.inject && test.inject[key]) {
+      // @FIX: need fix got inject
+      testArgs[key] = test.inject[key]
+      continue
+    }
+    if (!objects[key]) {
+      throw new Error(`Object of type ${key} is not defined in container`)
+    }
+    testArgs[key] = container.support(key)
+  }
+
+  if (test) {
+    testArgs.suite = test?.parent
+    testArgs.test = test
+  }
+  return testArgs
+}
+
+module.exports.getInjectedArguments = getInjectedArguments

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

@@ -1,3 +1,5 @@
+const { isAsyncFunction } = require('../utils')
+
 /** @class */
 class ScenarioConfig {
   constructor(test) {
@@ -40,6 +42,17 @@ class ScenarioConfig {
     return this
   }
 
+  /**
+   * Set metadata for this test
+   * @param {string} key
+   * @param {string} value
+   * @returns {this}
+   */
+  meta(key, value) {
+    this.test.meta[key] = value
+    return this
+  }
+
   /**
    * Set timeout for this test
    * @param {number} timeout
@@ -71,17 +84,19 @@ class ScenarioConfig {
    * @param {Object<string, any>} [obj]
    * @returns {this}
    */
-  async config(helper, obj) {
+  config(helper, obj) {
     if (!obj) {
       obj = helper
       helper = 0
     }
     if (typeof obj === 'function') {
-      obj = await obj(this.test)
-    }
-    if (!this.test.config) {
-      this.test.config = {}
+      if (isAsyncFunction(obj)) {
+        obj(this.test).then(res => (this.test.config[helper] = res))
+        return this
+      }
+      obj = obj(this.test)
     }
+
     this.test.config[helper] = obj
     return this
   }
@@ -104,7 +119,7 @@ class ScenarioConfig {
    * @returns {this}
    */
   injectDependencies(dependencies) {
-    Object.keys(dependencies).forEach((key) => {
+    Object.keys(dependencies).forEach(key => {
       this.test.inject[key] = dependencies[key]
     })
     return this

package/lib/mocha/suite.js

@@ -0,0 +1,81 @@
+const MochaSuite = require('mocha/lib/suite')
+/**
+ * @typedef {import('mocha')} Mocha
+ */
+
+/**
+ * Enhances MochaSuite with CodeceptJS specific functionality using composition
+ */
+function enhanceMochaSuite(suite) {
+  // already enhanced
+  if (suite.codeceptjs) return suite
+
+  suite.codeceptjs = true
+  // Add properties
+  suite.tags = suite.title.match(/(\@[a-zA-Z0-9-_]+)/g) || []
+  suite.opts = {}
+  // suite.totalTimeout = undefined
+
+  // Override fullTitle method
+  suite.fullTitle = () => `${suite.title}:`
+
+  // Add new methods
+  suite.applyOptions = function (opts) {
+    if (!opts) opts = {}
+    suite.opts = opts
+
+    if (opts.retries) suite.retries(opts.retries)
+    if (opts.timeout) suite.totalTimeout = opts.timeout
+
+    if (opts.skipInfo && opts.skipInfo.skipped) {
+      suite.pending = true
+      suite.opts = { ...this.opts, skipInfo: opts.skipInfo }
+    }
+  }
+
+  suite.simplify = function () {
+    return serializeSuite(this)
+  }
+
+  return suite
+}
+
+/**
+ * Factory function to create enhanced suites
+ * @param {Mocha.Suite} parent - Parent suite
+ * @param {string} title - Suite title
+ * @returns {CodeceptJS.Suite & Mocha.Suite} New enhanced suite instance
+ */
+function createSuite(parent, title) {
+  const suite = MochaSuite.create(parent, title)
+  suite.timeout(0)
+  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

@@ -0,0 +1,159 @@
+const Test = require('mocha/lib/test')
+const Suite = require('mocha/lib/suite')
+const { test: testWrapper } = require('./asyncWrapper')
+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
+ * @param {Function} fn - Test function
+ * @returns {CodeceptJS.Test & Mocha.Test} New enhanced test instance
+ */
+function createTest(title, fn) {
+  const test = new Test(title, fn)
+  return enhanceMochaTest(test)
+}
+
+/**
+ * Enhances Mocha Test with CodeceptJS specific functionality using composition
+ * @param {CodeceptJS.Test & Mocha.Test} test - Test instance to enhance
+ * @returns {CodeceptJS.Test & Mocha.Test} Enhanced test instance
+ */
+function enhanceMochaTest(test) {
+  // already enhanced
+  if (test.codeceptjs) return test
+
+  test.codeceptjs = true
+  // Add properties
+  test.tags = test.title.match(/(\@[a-zA-Z0-9-_]+)/g) || []
+  test.steps = []
+  test.config = {}
+  test.artifacts = []
+  test.inject = {}
+  test.opts = {}
+  test.meta = {}
+
+  test.notes = []
+  test.addNote = (type, note) => {
+    test.notes.push({ type, text: note })
+  }
+
+  // Add new methods
+  /**
+   * @param {Mocha.Suite} suite - The Mocha suite to add this test to
+   */
+  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)
+  }
+
+  test.applyOptions = function (opts) {
+    if (!opts) opts = {}
+    test.opts = opts
+    test.meta = opts.meta || {}
+    test.totalTimeout = opts.timeout
+    if (opts.retries) this.retries(opts.retries)
+  }
+
+  test.simplify = function () {
+    return serializeTest(this)
+  }
+
+  return test
+}
+
+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,
+  serializeTest,
+  deserializeTest,
+  cloneTest,
+}