codeceptjs 4.0.0-beta.4 → 4.0.0-beta.5

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
+    }
+  }
+}

package/lib/mocha/ui.js

@@ -0,0 +1,232 @@
+const escapeRe = require('escape-string-regexp')
+const { test, setup, teardown, suiteSetup, suiteTeardown, injected } = require('./asyncWrapper')
+const ScenarioConfig = require('./scenarioConfig')
+const FeatureConfig = require('./featureConfig')
+const addDataContext = require('../data/context')
+const { createTest } = require('./test')
+const { createSuite } = require('./suite')
+const { HookConfig, AfterSuiteHook, AfterHook, BeforeSuiteHook, BeforeHook } = require('./hooks')
+
+const setContextTranslation = context => {
+  const container = require('../container')
+  const contexts = container.translation().value('contexts')
+
+  if (contexts) {
+    for (const key of Object.keys(contexts)) {
+      if (context[key]) {
+        context[contexts[key]] = context[key]
+      }
+    }
+  }
+}
+
+/**
+ * Codecept-style interface:
+ *
+ * Feature('login');
+ *
+ * Scenario('login as regular user', ({I}) {
+ *   I.fillField();
+ *   I.click();
+ *   I.see('Hello, '+data.login);
+ * });
+ *
+ * @param {Mocha.Suite} suite Root suite.
+ * @ignore
+ */
+module.exports = function (suite) {
+  const suites = [suite]
+  suite.timeout(0)
+  let afterAllHooks
+  let afterEachHooks
+  let afterAllHooksAreLoaded
+  let afterEachHooksAreLoaded
+
+  suite.on('pre-require', (context, file, mocha) => {
+    const common = require('mocha/lib/interfaces/common')(suites, context, mocha)
+
+    const addScenario = function (title, opts = {}, fn) {
+      const suite = suites[0]
+
+      if (typeof opts === 'function' && !fn) {
+        fn = opts
+        opts = {}
+      }
+      if (suite.pending) {
+        fn = null
+      }
+      const test = createTest(title, fn)
+      test.file = file
+      test.addToSuite(suite)
+      test.applyOptions(opts)
+
+      return new ScenarioConfig(test)
+    }
+
+    // create dispatcher
+
+    context.BeforeAll = common.before
+    context.AfterAll = common.after
+
+    context.run = mocha.options.delay && common.runWithSuite(suite)
+    /**
+     * Describe a "suite" with the given `title`
+     * and callback `fn` containing nested suites
+     * and/or tests.
+     * @global
+     * @param {string} title
+     * @param {Object<string, *>} [opts]
+     * @returns {FeatureConfig}
+     */
+
+    context.Feature = function (title, opts) {
+      if (suites.length > 1) {
+        suites.shift()
+      }
+
+      afterAllHooks = []
+      afterEachHooks = []
+      afterAllHooksAreLoaded = false
+      afterEachHooksAreLoaded = false
+
+      const suite = createSuite(suites[0], title)
+      suite.applyOptions(opts)
+
+      suite.file = file
+      suites.unshift(suite)
+      suite.beforeEach('codeceptjs.before', () => setup(suite))
+      afterEachHooks.push(['finalize codeceptjs', () => teardown(suite)])
+
+      suite.beforeAll('codeceptjs.beforeSuite', () => suiteSetup(suite))
+      afterAllHooks.push(['codeceptjs.afterSuite', () => suiteTeardown(suite)])
+
+      return new FeatureConfig(suite)
+    }
+
+    /**
+     * Exclusive test suite - runs only this feature.
+     * @global
+     * @kind constant
+     * @type {CodeceptJS.IFeature}
+     */
+    context.Feature.only = function (title, opts) {
+      const reString = `^${escapeRe(`${title}:`)}`
+      mocha.grep(new RegExp(reString))
+      process.env.FEATURE_ONLY = true
+      return context.Feature(title, opts)
+    }
+
+    /**
+     * Pending test suite.
+     * @global
+     * @kind constant
+     * @type {CodeceptJS.IFeature}
+     */
+    context.xFeature = context.Feature.skip = function (title, opts) {
+      const skipInfo = {
+        skipped: true,
+        message: 'Skipped due to "skip" on Feature.',
+      }
+      return context.Feature(title, { ...opts, skipInfo })
+    }
+
+    context.BeforeSuite = function (fn) {
+      suites[0].beforeAll('BeforeSuite', injected(fn, suites[0], 'beforeSuite'))
+      return new HookConfig(new BeforeSuiteHook({ suite: suites[0] }))
+    }
+
+    context.AfterSuite = function (fn) {
+      afterAllHooks.unshift(['AfterSuite', injected(fn, suites[0], 'afterSuite')])
+      return new HookConfig(new AfterSuiteHook({ suite: suites[0] }))
+    }
+
+    context.Background = context.Before = function (fn) {
+      suites[0].beforeEach('Before', injected(fn, suites[0], 'before'))
+      return new HookConfig(new BeforeHook({ suite: suites[0] }))
+    }
+
+    context.After = function (fn) {
+      afterEachHooks.unshift(['After', injected(fn, suites[0], 'after')])
+      return new HookConfig(new AfterHook({ suite: suites[0] }))
+    }
+
+    /**
+     * Describe a specification or test-case
+     * with the given `title` and callback `fn`
+     * acting as a thunk.
+     * @ignore
+     */
+    context.Scenario = addScenario
+    /**
+     * Exclusive test-case.
+     * @ignore
+     */
+    context.Scenario.only = function (title, opts, fn) {
+      const reString = `^${escapeRe(`${suites[0].title}: ${title}`.replace(/( \| {.+})?$/g, ''))}`
+      mocha.grep(new RegExp(reString))
+      process.env.SCENARIO_ONLY = true
+      return addScenario(title, opts, fn)
+    }
+
+    /**
+     * Pending test case.
+     * @global
+     * @kind constant
+     * @type {CodeceptJS.IScenario}
+     */
+    context.xScenario = context.Scenario.skip = function (title, opts = {}, fn) {
+      if (typeof opts === 'function' && !fn) {
+        opts = {}
+      }
+
+      return context.Scenario(title, opts)
+    }
+
+    /**
+     * Pending test case with message: 'Test not implemented!'.
+     * @global
+     * @kind constant
+     * @type {CodeceptJS.IScenario}
+     */
+    context.Scenario.todo = function (title, opts = {}, fn) {
+      if (typeof opts === 'function' && !fn) {
+        fn = opts
+        opts = {}
+      }
+
+      const skipInfo = {
+        message: 'Test not implemented!',
+        description: fn ? fn.toString() : '',
+      }
+
+      return context.Scenario(title, { ...opts, skipInfo })
+    }
+
+    /**
+     * For translation
+     */
+
+    setContextTranslation(context)
+
+    addDataContext(context)
+  })
+
+  suite.on('post-require', () => {
+    /**
+     * load hooks from arrays to suite to prevent reordering
+     */
+    if (!afterEachHooksAreLoaded && Array.isArray(afterEachHooks)) {
+      afterEachHooks.forEach(hook => {
+        suites[0].afterEach(hook[0], hook[1])
+      })
+      afterEachHooksAreLoaded = true
+    }
+
+    if (!afterAllHooksAreLoaded && Array.isArray(afterAllHooks)) {
+      afterAllHooks.forEach(hook => {
+        suites[0].afterAll(hook[0], hook[1])
+      })
+      afterAllHooksAreLoaded = true
+    }
+  })
+}