codeceptjs 3.6.10 → 3.7.0-beta.1

package/lib/mocha/inject.js

@@ -0,0 +1,24 @@
+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)
+  }
+
+  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) {
@@ -71,17 +73,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 +108,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,55 @@
+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 }
+    }
+  }
+
+  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)
+}
+
+module.exports = {
+  createSuite,
+  enhanceMochaSuite,
+}

package/lib/mocha/test.js

@@ -0,0 +1,60 @@
+const Test = require('mocha/lib/test')
+const { test: testWrapper } = require('./asyncWrapper')
+const { enhanceMochaSuite } = require('./suite')
+const { genTestId } = require('../utils')
+
+/**
+ * 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 = {}
+
+  // 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))
+    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.totalTimeout = opts.timeout
+    if (opts.retries) this.retries(opts.retries)
+  }
+
+  return test
+}
+
+module.exports = {
+  createTest,
+  enhanceMochaTest,
+}

package/lib/mocha/types.d.ts

@@ -0,0 +1,31 @@
+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[]
+      config: Record<string, any>
+      artifacts: string[]
+      inject: Record<string, any>
+      opts: Record<string, any>
+      throws?: Error | string | RegExp | Function
+      totalTimeout?: number
+      addToSuite(suite: Mocha.Suite): void
+      applyOptions(opts: Record<string, any>): 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,219 @@
+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)
+    }
+
+    /**
+     * 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
+    }
+  })
+}

package/lib/output.js

@@ -1,6 +1,6 @@
 const colors = require('chalk');
 const figures = require('figures');
-const { maskSensitiveData } = require('invisi-data')
+const { maskSensitiveData } = require('invisi-data');
 
 const styles = {
   error: colors.bgRed.white.bold,
@@ -48,7 +48,7 @@ module.exports = {
    * @returns {string}
    */
   process(process) {
-    if (process === null) return outputProcess = '';
+    if (process === null) return (outputProcess = '');
     if (process) outputProcess = String(process).length === 1 ? `[0${process}]` : `[${process}]`;
     return outputProcess;
   },
@@ -58,7 +58,7 @@ module.exports = {
    * @param {string} msg
    */
   debug(msg) {
-    const _msg = isMaskedData() ? maskSensitiveData(msg) : msg
+    const _msg = isMaskedData() ? maskSensitiveData(msg) : msg;
     if (outputLevel >= 2) {
       print(' '.repeat(this.stepShift), styles.debug(`${figures.pointerSmall} ${_msg}`));
     }
@@ -69,7 +69,7 @@ module.exports = {
    * @param {string} msg
    */
   log(msg) {
-    const _msg = isMaskedData() ? maskSensitiveData(msg) : msg
+    const _msg = isMaskedData() ? maskSensitiveData(msg) : msg;
     if (outputLevel >= 3) {
       print(' '.repeat(this.stepShift), styles.log(truncate(`   ${_msg}`, this.spaceShift)));
     }
@@ -114,16 +114,16 @@ module.exports = {
       }
     }
 
-    let stepLine = step.toString();
+    let stepLine = step.toCliStyled();
     if (step.metaStep && outputLevel >= 1) {
       // this.stepShift += 2;
-      stepLine = colors.green(truncate(stepLine, this.spaceShift));
+      stepLine = colors.dim(truncate(stepLine, this.spaceShift));
     }
     if (step.comment) {
       stepLine += colors.grey(step.comment.split('\n').join('\n' + ' '.repeat(4)));
     }
 
-    const _stepLine = isMaskedData() ? maskSensitiveData(stepLine) : stepLine
+    const _stepLine = isMaskedData() ? maskSensitiveData(stepLine) : stepLine;
     print(' '.repeat(this.stepShift), truncate(_stepLine, this.spaceShift));
   },
 
@@ -132,7 +132,7 @@ module.exports = {
     /**
      * @param {Mocha.Suite} suite
      */
-    started: (suite) => {
+    started: suite => {
       if (!suite.title) return;
       print(`${colors.bold(suite.title)} --`);
       if (suite.comment) print(suite.comment);
@@ -173,7 +173,10 @@ module.exports = {
      * @param {Mocha.Test} test
      */
 
-    started(test) {},
+    started(test) {
+      if (outputLevel < 1) return;
+      print(`  ${colors.dim.bold('Scenario()')}`);
+    },
 
     /**
      * @param {Mocha.Test} test
@@ -191,6 +194,21 @@ module.exports = {
     },
   },
 
+  hook: {
+    started(hook) {
+      if (outputLevel < 1) return;
+      print(`  ${colors.dim.bold(hook.toCode())}`);
+    },
+    passed(hook) {
+      if (outputLevel < 1) return;
+      print();
+    },
+    failed(hook) {
+      if (outputLevel < 1) return;
+      print(`  ${colors.red.bold(hook.toCode())}`);
+    },
+  },
+
   /**
    *
    * Print a text in console log
@@ -260,5 +278,5 @@ function truncate(msg, gap = 0) {
 }
 
 function isMaskedData() {
-  return global.maskSensitiveData === true || false
+  return global.maskSensitiveData === true || false;
 }