codeceptjs 3.6.10 → 3.7.0-beta.2

package/lib/helper/testcafe/testcafe-utils.js

@@ -1,15 +1,15 @@
-const { ClientFunction } = require('testcafe');
+const { ClientFunction } = require('testcafe')
 
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const { getParamNames } = require('../../utils');
+const assert = require('assert')
+const fs = require('fs')
+const path = require('path')
+const { getParamNames } = require('../../utils')
 
 const createTestFile = () => {
-  assert(global.output_dir, 'global.output_dir must be set');
+  assert(global.output_dir, 'global.output_dir must be set')
 
-  const testFile = path.join(global.output_dir, `${Date.now()}_test.js`);
-  const testControllerHolderDir = __dirname.replace(/\\/g, '/');
+  const testFile = path.join(global.output_dir, `${Date.now()}_test.js`)
+  const testControllerHolderDir = __dirname.replace(/\\/g, '/')
 
   fs.writeFileSync(
     testFile,
@@ -17,40 +17,39 @@ const createTestFile = () => {
     fixture("fixture")\n
     test\n
     ("test", testControllerHolder.capture)`,
-  );
+  )
 
-  return testFile;
-};
+  return testFile
+}
 
 // TODO Better error mapping (actual, expected)
-const mapError = (testcafeError) => {
+const mapError = testcafeError => {
   // console.log('TODO map error better', JSON.stringify(testcafeError, null, 2));
   if (testcafeError.errMsg) {
-    throw new Error(testcafeError.errMsg);
+    throw new Error(testcafeError.errMsg)
   }
-  const errorInfo = `${testcafeError.callsite ? JSON.stringify(testcafeError.callsite) : ''} ${testcafeError.apiFnChain || JSON.stringify(testcafeError)}`;
-  throw new Error(`TestCafe Error: ${errorInfo}`);
-};
+  const errorInfo = `${testcafeError.callsite ? JSON.stringify(testcafeError.callsite) : ''} ${testcafeError.apiFnChain || JSON.stringify(testcafeError)}`
+  throw new Error(`TestCafe Error: ${errorInfo}`)
+}
 
 function createClientFunction(func, args) {
   if (!args || !args.length) {
-    return ClientFunction(func);
+    return ClientFunction(func)
   }
-  const paramNames = getParamNames(func);
-  const dependencies = {};
-  paramNames.forEach((param, i) => dependencies[param] = args[i]);
+  const paramNames = getParamNames(func)
+  const dependencies = {}
+  paramNames.forEach((param, i) => (dependencies[param] = args[i]))
 
-  return ClientFunction(getFuncBody(func), { dependencies });
+  return ClientFunction(getFuncBody(func), { dependencies })
 }
 
 function getFuncBody(func) {
-  let fnStr = func.toString();
-  const arrowIndex = fnStr.indexOf('=>');
+  let fnStr = func.toString()
+  const arrowIndex = fnStr.indexOf('=>')
   if (arrowIndex >= 0) {
-    fnStr = fnStr.slice(arrowIndex + 2);
+    fnStr = fnStr.slice(arrowIndex + 2)
 
-    // eslint-disable-next-line no-eval
-    return eval(`() => ${fnStr}`);
+    return eval(`() => ${fnStr}`)
   }
   // TODO: support general functions
 }
@@ -59,4 +58,4 @@ module.exports = {
   createTestFile,
   mapError,
   createClientFunction,
-};
+}

package/lib/listener/artifacts.js

@@ -5,11 +5,11 @@ const recorder = require('../recorder')
  * Create and clean up empty artifacts
  */
 module.exports = function () {
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     test.artifacts = {}
   })
 
-  event.dispatcher.on(event.test.after, (test) => {
+  event.dispatcher.on(event.test.after, test => {
     recorder.add('clean up empty artifacts', () => {
       for (const key in test.artifacts || {}) {
         if (!test.artifacts[key]) delete test.artifacts[key]

package/lib/listener/emptyRun.js

@@ -0,0 +1,58 @@
+const figures = require('figures')
+const Container = require('../container')
+const event = require('../event')
+const output = require('../output')
+
+module.exports = function () {
+  let isEmptyRun = true
+
+  event.dispatcher.on(event.test.before, test => {
+    isEmptyRun = false
+  })
+
+  event.dispatcher.on(event.all.result, () => {
+    if (isEmptyRun) {
+      const mocha = Container.mocha()
+
+      if (mocha.options.grep) {
+        const Fuse = require('fuse.js')
+
+        output.print()
+        output.print('No tests found by pattern: ' + mocha.options.grep)
+
+        const allTests = []
+        mocha.suite.suites.forEach(suite => {
+          suite.tests.forEach(test => {
+            allTests.push(test.fullTitle())
+          })
+        })
+
+        const fuse = new Fuse(allTests, {
+          includeScore: true,
+          threshold: 0.6,
+          caseSensitive: false,
+        })
+
+        const results = fuse.search(mocha.options.grep.toString())
+
+        if (results.length > 0) {
+          output.print()
+          output.print('Maybe you wanted to run one of these tests?')
+          results.forEach(result => {
+            output.print(figures.checkboxOff, output.styles.log(result.item))
+          })
+
+          output.print()
+          output.print(output.styles.debug('To run the first test use the following command:'))
+          output.print(output.styles.bold('npx codeceptjs run --debug --grep "' + results[0].item + '"'))
+        }
+      }
+      if (process.env.CI && !process.env.DONT_FAIL_ON_EMPTY_RUN) {
+        output.print()
+        output.error('No tests were executed. Failing on CI to avoid false positives')
+        output.error('To disable this check, set `DONT_FAIL_ON_EMPTY_RUN` environment variable to true in CI config')
+        process.exitCode = 1
+      }
+    }
+  })
+}

package/lib/listener/exit.js

@@ -3,7 +3,7 @@ const event = require('../event')
 module.exports = function () {
   let failedTests = []
 
-  event.dispatcher.on(event.test.failed, (testOrSuite) => {
+  event.dispatcher.on(event.test.failed, testOrSuite => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
     const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
@@ -11,14 +11,14 @@ module.exports = function () {
   })
 
   // if test was successful after retries
-  event.dispatcher.on(event.test.passed, (testOrSuite) => {
+  event.dispatcher.on(event.test.passed, testOrSuite => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
     const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
-    failedTests = failedTests.filter((failed) => id !== failed)
+    failedTests = failedTests.filter(failed => id !== failed)
   })
 
-  process.on('beforeExit', (code) => {
+  process.on('beforeExit', code => {
     if (failedTests.length) {
       code = 1
     }

package/lib/listener/{retry.js → globalRetry.js}

@@ -6,7 +6,7 @@ const { isNotSet } = require('../utils')
 const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
 module.exports = function () {
-  event.dispatcher.on(event.suite.before, (suite) => {
+  event.dispatcher.on(event.suite.before, suite => {
     let retryConfig = Config.get('retry')
     if (!retryConfig) return
 
@@ -28,8 +28,8 @@ module.exports = function () {
       }
 
       hooks
-        .filter((hook) => !!config[hook])
-        .forEach((hook) => {
+        .filter(hook => !!config[hook])
+        .forEach(hook => {
           if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook]
         })
 
@@ -41,7 +41,7 @@ module.exports = function () {
     }
   })
 
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     let retryConfig = Config.get('retry')
     if (!retryConfig) return
 
@@ -54,7 +54,7 @@ module.exports = function () {
       retryConfig = [retryConfig]
     }
 
-    retryConfig = retryConfig.filter((config) => !!config.Scenario)
+    retryConfig = retryConfig.filter(config => !!config.Scenario)
 
     for (const config of retryConfig) {
       if (config.grep) {

package/lib/listener/{timeout.js → globalTimeout.js}

@@ -16,7 +16,8 @@ module.exports = function () {
     return
   }
 
-  event.dispatcher.on(event.suite.before, (suite) => {
+  event.dispatcher.on(event.suite.before, suite => {
+    timeout = null;
     suiteTimeout = []
     let timeoutConfig = Config.get('timeout')
 
@@ -30,7 +31,7 @@ module.exports = function () {
         timeoutConfig = [timeoutConfig]
       }
 
-      for (const config of timeoutConfig.filter((c) => !!c.Feature)) {
+      for (const config of timeoutConfig.filter(c => !!c.Feature)) {
         if (config.grep) {
           if (!suite.title.includes(config.grep)) continue
         }
@@ -42,7 +43,7 @@ module.exports = function () {
     output.log(`Timeouts: ${suiteTimeout}`)
   })
 
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     currentTest = test
     let testTimeout = null
 
@@ -53,7 +54,7 @@ module.exports = function () {
         timeoutConfig = [timeoutConfig]
       }
 
-      for (const config of timeoutConfig.filter((c) => !!c.Scenario)) {
+      for (const config of timeoutConfig.filter(c => !!c.Scenario)) {
         console.log('Test Timeout', config, test.title.includes(config.grep))
         if (config.grep) {
           if (!test.title.includes(config.grep)) continue
@@ -69,15 +70,15 @@ module.exports = function () {
     timeout *= 1000
   })
 
-  event.dispatcher.on(event.test.passed, (test) => {
+  event.dispatcher.on(event.test.passed, test => {
     currentTest = null
   })
 
-  event.dispatcher.on(event.test.failed, (test) => {
+  event.dispatcher.on(event.test.failed, test => {
     currentTest = null
   })
 
-  event.dispatcher.on(event.step.before, (step) => {
+  event.dispatcher.on(event.step.before, step => {
     if (typeof timeout !== 'number') return
 
     if (timeout < 0) {
@@ -87,7 +88,7 @@ module.exports = function () {
     }
   })
 
-  event.dispatcher.on(event.step.finished, (step) => {
+  event.dispatcher.on(event.step.finished, step => {
     if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration
 
     if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {

package/lib/listener/helpers.js

@@ -12,7 +12,7 @@ module.exports = function () {
 
   const runHelpersHook = (hook, param) => {
     if (store.dryRun) return
-    Object.values(helpers).forEach((helper) => {
+    Object.values(helpers).forEach(helper => {
       if (helper[hook]) {
         helper[hook](param)
       }
@@ -21,55 +21,55 @@ module.exports = function () {
 
   const runAsyncHelpersHook = (hook, param, force) => {
     if (store.dryRun) return
-    Object.keys(helpers).forEach((key) => {
+    Object.keys(helpers).forEach(key => {
       if (!helpers[key][hook]) return
       recorder.add(`hook ${key}.${hook}()`, () => helpers[key][hook](param), force, false)
     })
   }
 
-  event.dispatcher.on(event.suite.before, (suite) => {
+  event.dispatcher.on(event.suite.before, suite => {
     // if (suite.parent) return; // only for root suite
     runAsyncHelpersHook('_beforeSuite', suite, true)
   })
 
-  event.dispatcher.on(event.suite.after, (suite) => {
+  event.dispatcher.on(event.suite.after, suite => {
     // if (suite.parent) return; // only for root suite
     runAsyncHelpersHook('_afterSuite', suite, true)
   })
 
-  event.dispatcher.on(event.test.started, (test) => {
+  event.dispatcher.on(event.test.started, test => {
     runHelpersHook('_test', test)
-    recorder.catch((e) => error(e))
+    recorder.catch(e => error(e))
   })
 
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     // schedule config to revert changes
     runAsyncHelpersHook('_before', test, true)
-    recorder.catchWithoutStop((e) => error(e))
+    recorder.catchWithoutStop(e => error(e))
   })
 
-  event.dispatcher.on(event.test.passed, (test) => {
+  event.dispatcher.on(event.test.passed, test => {
     runAsyncHelpersHook('_passed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop((e) => error(e))
+    recorder.catchWithoutStop(e => error(e))
   })
 
-  event.dispatcher.on(event.test.failed, (test) => {
+  event.dispatcher.on(event.test.failed, test => {
     runAsyncHelpersHook('_failed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop((e) => error(e))
+    recorder.catchWithoutStop(e => error(e))
   })
 
   event.dispatcher.on(event.test.after, () => {
     runAsyncHelpersHook('_after', {}, true)
-    recorder.catchWithoutStop((e) => error(e))
+    recorder.catchWithoutStop(e => error(e))
   })
 
-  event.dispatcher.on(event.step.before, (step) => {
+  event.dispatcher.on(event.step.before, step => {
     runAsyncHelpersHook('_beforeStep', step)
   })
 
-  event.dispatcher.on(event.step.after, (step) => {
+  event.dispatcher.on(event.step.after, step => {
     runAsyncHelpersHook('_afterStep', step)
   })
 

package/lib/listener/mocha.js

@@ -8,7 +8,7 @@ module.exports = function () {
     mocha = container.mocha()
   })
 
-  event.dispatcher.on(event.test.passed, (test) => {
+  event.dispatcher.on(event.test.passed, test => {
     mocha.Runner.emit('pass', test)
   })
 

package/lib/listener/steps.js

@@ -2,6 +2,7 @@ const debug = require('debug')('codeceptjs:steps')
 const event = require('../event')
 const store = require('../store')
 const output = require('../output')
+const { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } = require('../mocha/hooks')
 
 let currentTest
 let currentHook
@@ -10,39 +11,43 @@ let currentHook
  * Register steps inside tests
  */
 module.exports = function () {
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     test.startedAt = +new Date()
     test.artifacts = {}
   })
 
-  event.dispatcher.on(event.test.started, (test) => {
+  event.dispatcher.on(event.test.started, test => {
     currentTest = test
     currentTest.steps = []
     if (!('retryNum' in currentTest)) currentTest.retryNum = 0
     else currentTest.retryNum += 1
+    output.scenario.started(test)
   })
 
-  event.dispatcher.on(event.test.after, (test) => {
+  event.dispatcher.on(event.test.after, test => {
     currentTest = null
   })
 
-  event.dispatcher.on(event.test.finished, (test) => {})
+  event.dispatcher.on(event.test.finished, test => {})
 
-  event.dispatcher.on(event.hook.started, (suite) => {
-    currentHook = suite.ctx.test
+  event.dispatcher.on(event.hook.started, hook => {
+    currentHook = hook.ctx.test
     currentHook.steps = []
 
-    if (suite.ctx && suite.ctx.test) output.log(`--- STARTED ${suite.ctx.test.title} ---`)
+    output.hook.started(hook)
+
+    if (hook.ctx && hook.ctx.test) debug(`--- STARTED ${hook.ctx.test.title} ---`)
   })
 
-  event.dispatcher.on(event.hook.passed, (suite) => {
+  event.dispatcher.on(event.hook.passed, hook => {
     currentHook = null
-    if (suite.ctx && suite.ctx.test) output.log(`--- ENDED ${suite.ctx.test.title} ---`)
+    output.hook.passed(hook)
+    if (hook.ctx && hook.ctx.test) debug(`--- ENDED ${hook.ctx.test.title} ---`)
   })
 
   event.dispatcher.on(event.test.failed, () => {
     const cutSteps = function (current) {
-      const failureIndex = current.steps.findIndex((el) => el.status === 'failed')
+      const failureIndex = current.steps.findIndex(el => el.status === 'failed')
       // To be sure that failed test will be failed in report
       current.state = 'failed'
       current.steps.length = failureIndex + 1
@@ -65,7 +70,7 @@ module.exports = function () {
     currentTest.state = 'passed'
   })
 
-  event.dispatcher.on(event.step.started, (step) => {
+  event.dispatcher.on(event.step.started, step => {
     step.startedAt = +new Date()
     step.test = currentTest
     if (currentHook && Array.isArray(currentHook.steps)) {
@@ -75,7 +80,7 @@ module.exports = function () {
     currentTest.steps.push(step)
   })
 
-  event.dispatcher.on(event.step.finished, (step) => {
+  event.dispatcher.on(event.step.finished, step => {
     step.finishedAt = +new Date()
     if (step.startedAt) step.duration = step.finishedAt - step.startedAt
     debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`)

package/lib/listener/store.js

@@ -0,0 +1,12 @@
+const event = require('../event')
+const store = require('../store')
+
+module.exports = function () {
+  event.dispatcher.on(event.test.before, test => {
+    store.currentTest = test
+  })
+
+  event.dispatcher.on(event.test.finished, test => {
+    store.currentTest = null
+  })
+}

package/lib/mocha/asyncWrapper.js

@@ -0,0 +1,204 @@
+const promiseRetry = require('promise-retry')
+const event = require('../event')
+const recorder = require('../recorder')
+const assertThrown = require('../assert/throws')
+const { ucfirst, isAsyncFunction } = require('../utils')
+const { getInjectedArguments } = require('./inject')
+const { fireHook } = require('./hooks')
+
+const injectHook = function (inject, suite) {
+  try {
+    inject()
+  } catch (err) {
+    recorder.throw(err)
+  }
+  recorder.catch(err => {
+    event.emit(event.test.failed, suite, err)
+    throw err
+  })
+  return recorder.promise()
+}
+
+function makeDoneCallableOnce(done) {
+  let called = false
+  return function (err) {
+    if (called) {
+      return
+    }
+    called = true
+    return done(err)
+  }
+}
+
+/**
+ * Wraps test function, injects support objects from container,
+ * starts promise chain with recorder, performs before/after hooks
+ * through event system.
+ */
+module.exports.test = test => {
+  const testFn = test.fn
+  if (!testFn) {
+    return test
+  }
+
+  test.timeout(0)
+  test.async = true
+
+  test.fn = function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    recorder.errHandler(err => {
+      recorder.session.start('teardown')
+      recorder.cleanAsyncErr()
+      if (test.throws) {
+        // check that test should actually fail
+        try {
+          assertThrown(err, test.throws)
+          event.emit(event.test.passed, test)
+          event.emit(event.test.finished, test)
+          recorder.add(doneFn)
+          return
+        } catch (newErr) {
+          err = newErr
+        }
+      }
+      event.emit(event.test.failed, test, err)
+      event.emit(event.test.finished, test)
+      recorder.add(() => doneFn(err))
+    })
+
+    if (isAsyncFunction(testFn)) {
+      event.emit(event.test.started, test)
+      testFn
+        .call(test, getInjectedArguments(testFn, test))
+        .then(() => {
+          recorder.add('fire test.passed', () => {
+            event.emit(event.test.passed, test)
+            event.emit(event.test.finished, test)
+          })
+          recorder.add('finish test', doneFn)
+        })
+        .catch(err => {
+          recorder.throw(err)
+        })
+        .finally(() => {
+          recorder.catch()
+        })
+      return
+    }
+
+    try {
+      event.emit(event.test.started, test)
+      testFn.call(test, getInjectedArguments(testFn, test))
+    } catch (err) {
+      recorder.throw(err)
+    } finally {
+      recorder.add('fire test.passed', () => {
+        event.emit(event.test.passed, test)
+        event.emit(event.test.finished, test)
+      })
+      recorder.add('finish test', doneFn)
+      recorder.catch()
+    }
+  }
+  return test
+}
+
+/**
+ * Injects arguments to function from controller
+ */
+module.exports.injected = function (fn, suite, hookName) {
+  return function (done) {
+    const doneFn = makeDoneCallableOnce(done)
+    const errHandler = err => {
+      recorder.session.start('teardown')
+      recorder.cleanAsyncErr()
+      event.emit(event.test.failed, suite, err)
+      if (hookName === 'after') event.emit(event.test.after, suite)
+      if (hookName === 'afterSuite') event.emit(event.suite.after, suite)
+      recorder.add(() => doneFn(err))
+    }
+
+    recorder.errHandler(err => {
+      errHandler(err)
+    })
+
+    if (!fn) throw new Error('fn is not defined')
+
+    fireHook(event.hook.started, suite)
+
+    this.test.body = fn.toString()
+
+    if (!recorder.isRunning()) {
+      recorder.errHandler(err => {
+        errHandler(err)
+      })
+    }
+
+    const opts = suite.opts || {}
+    const retries = opts[`retry${ucfirst(hookName)}`] || 0
+
+    promiseRetry(
+      async (retry, number) => {
+        try {
+          recorder.startUnlessRunning()
+          await fn.call(this, getInjectedArguments(fn))
+          await recorder.promise().catch(err => retry(err))
+        } catch (err) {
+          retry(err)
+        } finally {
+          if (number < retries) {
+            recorder.stop()
+            recorder.start()
+          }
+        }
+      },
+      { retries },
+    )
+      .then(() => {
+        recorder.add('fire hook.passed', () => fireHook(event.hook.passed, suite))
+        recorder.add(`finish ${hookName} hook`, doneFn)
+        recorder.catch()
+      })
+      .catch(e => {
+        recorder.throw(e)
+        recorder.catch(e => {
+          const err = recorder.getAsyncErr() === null ? e : recorder.getAsyncErr()
+          errHandler(err)
+        })
+        recorder.add('fire hook.failed', () => fireHook(event.hook.failed, suite, e))
+      })
+  }
+}
+
+/**
+ * Starts promise chain, so helpers could enqueue their hooks
+ */
+module.exports.setup = function (suite) {
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.test.before, suite && suite.ctx && suite.ctx.currentTest)
+  }, suite)
+}
+
+module.exports.teardown = function (suite) {
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.test.after, suite && suite.ctx && suite.ctx.currentTest)
+  }, suite)
+}
+
+module.exports.suiteSetup = function (suite) {
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.suite.before, suite)
+  }, suite)
+}
+
+module.exports.suiteTeardown = function (suite) {
+  return injectHook(() => {
+    recorder.startUnlessRunning()
+    event.emit(event.suite.after, suite)
+  }, suite)
+}
+
+module.exports.getInjectedArguments = getInjectedArguments