codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

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

@@ -1,26 +1,31 @@
-const Gherkin = require('@cucumber/gherkin')
-const Messages = require('@cucumber/messages')
-const { Context, Suite, Test } = require('mocha')
-const debug = require('debug')('codeceptjs:bdd')
-
-const { matchStep } = require('./bdd')
-const event = require('../event')
-const scenario = require('../scenario')
-const Step = require('../step')
-const DataTableArgument = require('../data/dataTableArgument')
-const transform = require('../transform')
-
-const uuidFn = Messages.IdGenerator.uuid()
+import Gherkin 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 Gherkin.AstBuilder(uuidFn)
 const matcher = new Gherkin.GherkinClassicTokenMatcher()
 const parser = new Gherkin.Parser(builder, matcher)
 parser.stopAtFirstError = false
 
-module.exports = (text, file) => {
+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)
   }
 
@@ -28,7 +33,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 +42,23 @@ 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))
-
-  const runSteps = async (steps) => {
+  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 Step.MetaStep(null, step.text)
+      const metaStep = new 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 +112,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.includes(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 +127,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 +142,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 +169,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 +179,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
@@ -186,16 +193,39 @@ function addExampleInTable(exampleSteps, placeholders) {
   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) {
-  const translations = Object.keys(require('../../translations'))
+  if (!translations) {
+    // Translations not loaded yet, return null (will use default)
+    return null
+  }
 
-  for (const availableTranslation of translations) {
+  const translationKeys = Object.keys(translations)
+  for (const availableTranslation of translationKeys) {
     if (!language) {
       break
     }
 
     if (availableTranslation.includes(language)) {
-      return require('../../translations')[availableTranslation]
+      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,5 +1,10 @@
+import { isAsyncFunction } from '../utils.js'
+
 /** @class */
 class ScenarioConfig {
+  /**
+   * @param {CodeceptJS.Test} test
+   */
   constructor(test) {
     this.test = test
   }
@@ -40,6 +45,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
@@ -64,24 +80,32 @@ class ScenarioConfig {
     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
     }
     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,11 +128,11 @@ class ScenarioConfig {
    * @returns {this}
    */
   injectDependencies(dependencies) {
-    Object.keys(dependencies).forEach((key) => {
+    Object.keys(dependencies).forEach(key => {
       this.test.inject[key] = dependencies[key]
     })
     return this
   }
 }
 
-module.exports = 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,
+}