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

package/lib/mocha/gherkin.js

@@ -0,0 +1,231 @@
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from '@cucumber/gherkin'
+import { IdGenerator } from '@cucumber/messages'
+import { Context, Suite } from 'mocha'
+import debug from 'debug'
+const debugBdd = debug('codeceptjs:bdd')
+
+import event from '../event.js'
+import { injected, setup, teardown, suiteSetup, suiteTeardown } from './asyncWrapper.js'
+import step from '../step/base.js'
+import MetaStep from '../step/meta.js'
+import DataTableArgument from '../data/dataTableArgument.js'
+import transform from '../transform.js'
+import { enhanceMochaSuite } from './suite.js'
+import { createTest } from './test.js'
+import { matchStep } from './bdd.js'
+
+const uuidFn = IdGenerator.uuid()
+const builder = new AstBuilder(uuidFn)
+const matcher = new GherkinClassicTokenMatcher()
+const parser = new Parser(builder, matcher)
+parser.stopAtFirstError = false
+
+const gherkinParser = (text, file) => {
+  const ast = parser.parse(text)
+  let currentLanguage
+
+  if (ast.feature) {
+    // Ensure translations are loaded before trying to access them
+    currentLanguage = getTranslation(ast.feature.language)
+  }
+
+  if (!ast.feature) {
+    throw new Error(`No 'Features' available in Gherkin '${file}' provided!`)
+  }
+  const suite = new Suite(ast.feature.name, new Context())
+  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
+  suite.feature = ast.feature
+  suite.file = file
+  suite.timeout(0)
+
+  suite.beforeEach('codeceptjs.before', function () {
+    // In Mocha, 'this' refers to the current test in beforeEach/afterEach hooks
+    setup(this)(() => {})
+  })
+  suite.afterEach('codeceptjs.after', function () {
+    // In Mocha, 'this' refers to the current test in beforeEach/afterEach hooks
+    teardown(this)(() => {})
+  })
+  suite.beforeAll('codeceptjs.beforeSuite', suiteSetup(suite))
+  suite.afterAll('codeceptjs.afterSuite', suiteTeardown(suite))
+
+  const runSteps = async steps => {
+    for (const step of steps) {
+      const metaStep = new MetaStep(null, step.text)
+      metaStep.actor = step.keyword.trim()
+      let helperStep
+      const setMetaStep = step => {
+        helperStep = step
+        if (step.metaStep) {
+          if (step.metaStep === metaStep) {
+            return
+          }
+          setMetaStep(step.metaStep)
+          return
+        }
+        step.metaStep = metaStep
+      }
+      const fn = matchStep(step.text)
+
+      if (step.dataTable) {
+        fn.params.push({
+          ...step.dataTable,
+          parse: () => new DataTableArgument(step.dataTable),
+        })
+        metaStep.comment = `\n${transformTable(step.dataTable)}`
+      }
+
+      if (step.docString) {
+        fn.params.push(step.docString)
+        metaStep.comment = `\n"""\n${step.docString.content}\n"""`
+      }
+
+      step.startTime = Date.now()
+      step.match = fn.line
+      event.emit(event.bddStep.before, step)
+      event.emit(event.bddStep.started, metaStep)
+      event.dispatcher.prependListener(event.step.before, setMetaStep)
+      try {
+        debug(`Step '${step.text}' started...`)
+        await fn(...fn.params)
+        debug('Step passed')
+        step.status = 'passed'
+      } catch (err) {
+        debug(`Step failed: ${err?.message}`)
+        step.status = 'failed'
+        step.err = err
+        throw err
+      } finally {
+        step.endTime = Date.now()
+        event.dispatcher.removeListener(event.step.before, setMetaStep)
+      }
+      event.emit(event.bddStep.finished, metaStep)
+      event.emit(event.bddStep.after, step)
+    }
+  }
+
+  for (const child of ast.feature.children) {
+    if (child.background) {
+      suite.beforeEach(
+        'Before',
+        injected(async () => runSteps(child.background.steps), suite, 'before'),
+      )
+      continue
+    }
+    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)
+        for (const example of examples.tableBody) {
+          let exampleSteps = [...child.scenario.steps]
+          const current = {}
+          for (const index in example.cells) {
+            const placeholder = fields[index]
+            const value = transform('gherkin.examples', example.cells[index].value)
+            example.cells[index].value = value
+            current[placeholder] = value
+            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))
+          let title = `${child.scenario.name} ${JSON.stringify(current)} ${tags.join(' ')}`.trim()
+
+          for (const [key, value] of Object.entries(current)) {
+            if (title.includes(`<${key}>`)) {
+              title = title.replace(JSON.stringify(current), '').replace(`<${key}>`, value)
+            }
+          }
+
+          const test = createTest(title, async () => runSteps(addExampleInTable(exampleSteps, current)))
+          test.addToSuite(suite)
+          test.tags = suite.tags.concat(tags)
+          test.file = file
+        }
+      }
+      continue
+    }
+
+    if (child.scenario) {
+      const tags = child.scenario.tags.map(t => t.name)
+      const title = `${child.scenario.name} ${tags.join(' ')}`.trim()
+      const test = createTest(title, async () => runSteps(child.scenario.steps))
+      test.addToSuite(suite)
+      test.tags = suite.tags.concat(tags)
+      test.file = file
+    }
+  }
+
+  return suite
+}
+
+function transformTable(table) {
+  let str = ''
+  for (const id in table.rows) {
+    const cells = table.rows[id].cells
+    str += cells
+      .map(c => c.value)
+      .map(c => c.padEnd(15))
+      .join(' | ')
+    str += '\n'
+  }
+  return str
+}
+function addExampleInTable(exampleSteps, placeholders) {
+  const steps = JSON.parse(JSON.stringify(exampleSteps))
+  for (const placeholder in placeholders) {
+    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])))
+        }
+      }
+      return step
+    })
+  }
+  return steps
+}
+
+// Import translations at module level to avoid async in parser
+let translations = null
+async function loadTranslations() {
+  if (!translations) {
+    // Import container to ensure it's initialized
+    const Container = await import('../container.js')
+    await Container.default.started()
+
+    // Now load translations
+    const translationsModule = await import('../../translations/index.js')
+    translations = translationsModule.default || translationsModule
+  }
+  return translations
+}
+
+function getTranslation(language) {
+  if (!translations) {
+    // Translations not loaded yet, return null (will use default)
+    return null
+  }
+
+  const translationKeys = Object.keys(translations)
+  for (const availableTranslation of translationKeys) {
+    if (!language) {
+      break
+    }
+
+    if (availableTranslation.includes(language)) {
+      return translations[availableTranslation]
+    }
+  }
+  return null
+}
+
+export { loadTranslations }
+export default gherkinParser

package/lib/mocha/hooks.js

@@ -0,0 +1,121 @@
+import event from '../event.js'
+import { serializeError } from '../utils.js'
+// 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
+  }
+}
+
+export {
+  BeforeHook,
+  AfterHook,
+  BeforeSuiteHook,
+  AfterSuiteHook,
+  fireHook,
+  HookConfig,
+}
+
+export default {
+  BeforeHook,
+  AfterHook,
+  BeforeSuiteHook,
+  AfterSuiteHook,
+  fireHook,
+  HookConfig,
+}

package/lib/mocha/index.js

@@ -0,0 +1,21 @@
+import Suite from 'mocha/lib/suite.js'
+import Test from 'mocha/lib/test.js'
+import { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } from './hooks.js'
+
+export {
+  Suite,
+  Test,
+  BeforeHook,
+  AfterHook,
+  BeforeSuiteHook,
+  AfterSuiteHook,
+}
+
+export default {
+  Suite,
+  Test,
+  BeforeHook,
+  AfterHook,
+  BeforeSuiteHook,
+  AfterSuiteHook,
+}

package/lib/mocha/inject.js

@@ -0,0 +1,46 @@
+import { getParams } from '../parser.js'
+
+const getInjectedArguments = async (fn, test, suite) => {
+  const containerModule = await import('../container.js')
+  const container = containerModule.default || containerModule
+
+  const testArgs = {}
+  const params = getParams(fn) || []
+  const objects = container.support()
+
+  for (const key of params) {
+    testArgs[key] = {}
+
+    // Handle special built-in objects first
+    if (key === 'suite') {
+      if (test) {
+        testArgs[key] = test.parent || test
+      } else if (suite) {
+        testArgs[key] = suite
+      }
+      continue
+    }
+    if (key === 'test') {
+      testArgs[key] = test
+      continue
+    }
+
+    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
+}
+
+export { getInjectedArguments }

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

@@ -1,7 +1,12 @@
+import { isAsyncFunction } from '../utils.js'
+
 /** @class */
 class ScenarioConfig {
+  /**
+   * @param {CodeceptJS.Test} test
+   */
   constructor(test) {
-    this.test = test;
+    this.test = test
   }
 
   /**
@@ -12,8 +17,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   throws(err) {
-    this.test.throws = err;
-    return this;
+    this.test.throws = err
+    return this
   }
 
   /**
@@ -24,8 +29,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   fails() {
-    this.test.throws = new Error();
-    return this;
+    this.test.throws = new Error()
+    return this
   }
 
   /**
@@ -35,9 +40,20 @@ class ScenarioConfig {
    * @returns {this}
    */
   retry(retries) {
-    if (process.env.SCENARIO_ONLY) retries = -retries;
-    this.test.retries(retries);
-    return this;
+    if (process.env.SCENARIO_ONLY) retries = -retries
+    this.test.retries(retries)
+    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
   }
 
   /**
@@ -46,12 +62,12 @@ class ScenarioConfig {
    * @returns {this}
    */
   timeout(timeout) {
-    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`);
-    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`);
-    console.log('Timeout should be set in seconds');
+    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`)
+    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`)
+    console.log('Timeout should be set in seconds')
 
-    this.test.timeout(timeout);
-    return this;
+    this.test.timeout(timeout)
+    return this
   }
 
   /**
@@ -60,30 +76,38 @@ class ScenarioConfig {
    * @returns {this}
    */
   inject(obj) {
-    this.test.inject = obj;
-    return this;
+    this.test.inject = obj
+    return this
   }
 
+  /**
+   * @callback ScenarioConfigCallback
+   * @param {CodeceptJS.Test} test
+   * @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>} helper
+   * @param {string | Object<string, any> | ScenarioConfigCallback} helper
    * @param {Object<string, any>} [obj]
    * @returns {this}
    */
-  async config(helper, obj) {
+  config(helper, obj) {
     if (!obj) {
-      obj = helper;
-      helper = 0;
+      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;
+
+    this.test.config[helper] = obj
+    return this
   }
 
   /**
@@ -92,10 +116,10 @@ class ScenarioConfig {
    * @returns {this}
    */
   tag(tagName) {
-    if (tagName[0] !== '@') tagName = `@${tagName}`;
-    this.test.tags.push(tagName);
-    this.test.title = `${this.test.title.trim()} ${tagName}`;
-    return this;
+    if (tagName[0] !== '@') tagName = `@${tagName}`
+    this.test.tags.push(tagName)
+    this.test.title = `${this.test.title.trim()} ${tagName}`
+    return this
   }
 
   /**
@@ -104,11 +128,11 @@ class ScenarioConfig {
    * @returns {this}
    */
   injectDependencies(dependencies) {
-    Object.keys(dependencies).forEach((key) => {
-      this.test.inject[key] = dependencies[key];
-    });
-    return this;
+    Object.keys(dependencies).forEach(key => {
+      this.test.inject[key] = dependencies[key]
+    })
+    return this
   }
 }
 
-export default ScenarioConfig;
+export default ScenarioConfig

package/lib/mocha/suite.js

@@ -0,0 +1,89 @@
+import MochaSuite from 'mocha/lib/suite.js'
+/**
+ * @typedef {import('mocha')} Mocha
+ */
+
+/**
+ * Enhances MochaSuite with CodeceptJS specific functionality using composition
+ */
+function enhanceMochaSuite(suite) {
+  if (!suite) suite = new MochaSuite('Suite', null, false)
+  // 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
+}
+
+export {
+  createSuite,
+  enhanceMochaSuite,
+  serializeSuite,
+  deserializeSuite,
+}
+
+export default {
+  createSuite,
+  enhanceMochaSuite,
+  serializeSuite,
+  deserializeSuite,
+}