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

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,5 +1,10 @@
+const { isAsyncFunction } = require('../utils')
+
 /** @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,7 +128,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,82 @@
+const MochaSuite = require('mocha/lib/suite')
+/**
+ * @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
+}
+
+module.exports = {
+  createSuite,
+  enhanceMochaSuite,
+  serializeSuite,
+  deserializeSuite,
+}

package/lib/mocha/test.js

@@ -0,0 +1,181 @@
+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) {
+  // if no test, create a dummy one
+  if (!test) test = createTest('...', () => {})
+  // 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))
+
+  // Restore the custom fullTitle function to maintain consistency with original test
+  if (test.parent) {
+    test.fullTitle = () => `${test.parent.title}: ${test.title}`
+  }
+
+  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))
+}
+
+/**
+ * Get a filename from the test object
+ * @param {CodeceptJS.Test} test
+ * @param {Object}  options
+ * @param {string}  options.suffix Add a suffix to the filename
+ * @param {boolean} options.unique Add a unique suffix to the file
+ *
+ * @returns {string} the filename
+ */
+function testToFileName(test, { suffix = '', unique = false } = {}) {
+  let fileName = test.title
+
+  if (unique) fileName = `${fileName}_${test?.uid || Math.floor(new Date().getTime() / 1000)}`
+  if (suffix) fileName = `${fileName}_${suffix}`
+  // 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}`
+  // }
+  fileName = clearString(fileName).slice(0, 100)
+
+  return fileName
+}
+
+module.exports = {
+  createTest,
+  testToFileName,
+  enhanceMochaTest,
+  serializeTest,
+  deserializeTest,
+  cloneTest,
+}

package/lib/mocha/types.d.ts

@@ -0,0 +1,42 @@
+import { Test as MochaTest, Suite as MochaSuite } from 'mocha'
+
+declare global {
+  namespace CodeceptJS {
+    interface Test extends MochaTest {
+      uid: string
+      title: string
+      tags: string[]
+      steps: string[]
+      meta: Record<string, any>
+      notes: Array<{
+        type: string
+        text: string
+      }>
+      state: string
+      err?: Error
+      config: Record<string, any>
+      artifacts: string[]
+      inject: Record<string, any>
+      opts: Record<string, any>
+      throws?: Error | string | RegExp | Function
+      totalTimeout?: number
+      relativeFile?: string
+      addToSuite(suite: Mocha.Suite): void
+      applyOptions(opts: Record<string, any>): void
+      simplify(): Record<string, any>
+      toFileName(): string
+      addNote(type: string, note: string): void
+      codeceptjs: boolean
+    }
+
+    interface Suite extends MochaSuite {
+      title: string
+      tags: string[]
+      opts: Record<string, any>
+      totalTimeout?: number
+      addTest(test: Test): void
+      applyOptions(opts: Record<string, any>): void
+      codeceptjs: boolean
+    }
+  }
+}