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

package/lib/helper/extras/PlaywrightPropEngine.js

@@ -2,7 +2,7 @@ module.exports.createValueEngine = () => {
   return {
     // Creates a selector that matches given target when queried at the root.
     // Can return undefined if unable to create one.
-    // eslint-disable-next-line no-unused-vars
+
     create(root, target) {
       return null;
     },
@@ -29,7 +29,7 @@ module.exports.createDisabledEngine = () => {
   return {
     // Creates a selector that matches given target when queried at the root.
     // Can return undefined if unable to create one.
-    // eslint-disable-next-line no-unused-vars
+
     create(root, target) {
       return null;
     },

package/lib/helper/extras/Popup.js

@@ -2,66 +2,66 @@
  * Class to handle the interaction with the Dialog (Popup) Class from Puppeteer
  */
 class Popup {
-  constructor(popup, defaultAction) {
-    this._popup = popup || null;
-    this._actionType = '';
-    this._defaultAction = defaultAction || '';
+  constructor(popup = null, defaultAction = '') {
+    this._popup = popup
+    this._actionType = ''
+    this._defaultAction = defaultAction
   }
 
   _assertValidActionType(action) {
     if (['accept', 'cancel'].indexOf(action) === -1) {
-      throw new Error('Invalid Popup action type. Only "accept" or "cancel" actions are accepted');
+      throw new Error('Invalid Popup action type. Only "accept" or "cancel" actions are accepted')
     }
   }
 
   set defaultAction(action) {
-    this._assertValidActionType(action);
-    this._defaultAction = action;
+    this._assertValidActionType(action)
+    this._defaultAction = action
   }
 
   get defaultAction() {
-    return this._defaultAction;
+    return this._defaultAction
   }
 
   get popup() {
-    return this._popup;
+    return this._popup
   }
 
   set popup(popup) {
     if (this._popup) {
-      console.error('Popup already exists and was not closed. Popups must always be closed by calling either I.acceptPopup() or I.cancelPopup()');
+      return
     }
-    this._popup = popup;
+    this._popup = popup
   }
 
   get actionType() {
-    return this._actionType;
+    return this._actionType
   }
 
   set actionType(action) {
-    this._assertValidActionType(action);
-    this._actionType = action;
+    this._assertValidActionType(action)
+    this._actionType = action
   }
 
   clear() {
-    this._popup = null;
-    this._actionType = '';
+    this._popup = null
+    this._actionType = ''
   }
 
   assertPopupVisible() {
     if (!this._popup) {
-      throw new Error('There is no Popup visible');
+      throw new Error('There is no Popup visible')
     }
   }
 
   assertPopupActionType(type) {
-    this.assertPopupVisible();
-    const expectedAction = this._actionType || this._defaultAction;
+    this.assertPopupVisible()
+    const expectedAction = this._actionType || this._defaultAction
     if (expectedAction !== type) {
-      throw new Error(`Popup action does not fit the expected action type. Expected popup action to be '${expectedAction}' not '${type}`);
+      throw new Error(`Popup action does not fit the expected action type. Expected popup action to be '${expectedAction}' not '${type}`)
     }
-    this.clear();
+    this.clear()
   }
 }
 
-module.exports = Popup;
+module.exports = Popup

package/lib/helper/network/utils.js

@@ -34,7 +34,7 @@ const extractQueryObjects = (queryString) => {
   queryParameters.forEach((queryParameter) => {
     const keyValue = queryParameter.split('=');
     const queryObject = {};
-    // eslint-disable-next-line prefer-destructuring
+
     queryObject.name = keyValue[0];
     queryObject.value = decodeURIComponent(keyValue[1]);
     queryObjects.push(queryObject);

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);
-    // eslint-disable-next-line no-new-func
-    // eslint-disable-next-line no-eval
-    return eval(`() => ${fnStr}`);
+    fnStr = fnStr.slice(arrowIndex + 2)
+
+    return eval(`() => ${fnStr}`)
   }
   // TODO: support general functions
 }
@@ -59,4 +58,4 @@ module.exports = {
   createTestFile,
   mapError,
   createClientFunction,
-};
+}

package/lib/listener/emptyRun.js

@@ -0,0 +1,55 @@
+const figures = require('figures')
+const Container = require('../container')
+const event = require('../event')
+const output = require('../output')
+const { searchWithFusejs } = require('../utils')
+
+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) {
+        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 results = searchWithFusejs(allTests, mocha.options.grep.toString(), {
+          includeScore: true,
+          threshold: 0.6,
+          caseSensitive: false,
+        })
+
+        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

@@ -1,24 +1,21 @@
 const event = require('../event')
+const debug = require('debug')('codeceptjs:exit')
 
 module.exports = function () {
   let failedTests = []
 
-  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'
+  event.dispatcher.on(event.test.failed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
     failedTests.push(id)
   })
 
   // if test was successful after retries
-  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)
+  event.dispatcher.on(event.test.passed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
+    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/globalTimeout.js

@@ -0,0 +1,165 @@
+const event = require('../event')
+const output = require('../output')
+const recorder = require('../recorder')
+const Config = require('../config')
+const store = require('../store')
+const debug = require('debug')('codeceptjs:timeout')
+const { TIMEOUT_ORDER, TimeoutError, TestTimeoutError, StepTimeoutError } = require('../timeout')
+const { BeforeSuiteHook, AfterSuiteHook } = require('../mocha/hooks')
+
+module.exports = function () {
+  let timeout
+  let suiteTimeout = []
+  let currentTest
+  let currentTimeout
+
+  if (!store.timeouts) {
+    console.log('Timeouts were disabled')
+    return
+  }
+
+  // disable timeout for BeforeSuite/AfterSuite hooks
+  // add separate configs to them?
+  event.dispatcher.on(event.hook.started, hook => {
+    if (hook instanceof BeforeSuiteHook) {
+      timeout = null
+      suiteTimeout = []
+    }
+    if (hook instanceof AfterSuiteHook) {
+      timeout = null
+      suiteTimeout = []
+    }
+  })
+
+  event.dispatcher.on(event.suite.before, suite => {
+    suiteTimeout = []
+    let timeoutConfig = Config.get('timeout')
+
+    if (timeoutConfig) {
+      debug('config:', timeoutConfig)
+      if (!Number.isNaN(+timeoutConfig)) {
+        checkForSeconds(timeoutConfig)
+        suiteTimeout.push(timeoutConfig)
+      }
+
+      if (!Array.isArray(timeoutConfig)) {
+        timeoutConfig = [timeoutConfig]
+      }
+
+      for (const config of timeoutConfig.filter(c => !!c.Feature)) {
+        if (config.grep) {
+          if (!suite.title.includes(config.grep)) continue
+        }
+        suiteTimeout.push(config.Feature)
+      }
+    }
+
+    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout)
+    output.log(`Timeouts: ${suiteTimeout}`)
+
+    if (suiteTimeout.length > 0) debug(suite.title, 'timeout', suiteTimeout)
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    currentTest = test
+    let testTimeout = null
+
+    let timeoutConfig = Config.get('timeout')
+
+    if (typeof timeoutConfig === 'object' || Array.isArray(timeoutConfig)) {
+      if (!Array.isArray(timeoutConfig)) {
+        timeoutConfig = [timeoutConfig]
+      }
+
+      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
+        }
+        testTimeout = config.Scenario
+      }
+    }
+
+    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1]
+    if (!timeout) return
+
+    debug(test.title, 'timeout', {
+      'config from file': testTimeout,
+      'suite timeout': suiteTimeout,
+      'dynamic config': test.totalTimeout,
+    })
+
+    currentTimeout = timeout
+    output.debug(`Test Timeout: ${timeout}s`)
+    timeout *= 1000
+  })
+
+  event.dispatcher.on(event.test.passed, test => {
+    currentTest = null
+  })
+
+  event.dispatcher.on(event.test.failed, test => {
+    currentTest = null
+  })
+
+  event.dispatcher.on(event.step.before, step => {
+    if (typeof timeout !== 'number') return
+
+    if (!store.timeouts) {
+      debug('step', step.toCode().trim(), 'timeout disabled')
+      return
+    }
+
+    if (timeout < 0) {
+      debug('Previous steps timed out, setting timeout to 0.01s')
+      step.setTimeout(0.01, TIMEOUT_ORDER.testOrSuite)
+    } else {
+      debug(`Setting timeout ${timeout}ms for step ${step.toCode().trim()}`)
+      step.setTimeout(timeout, TIMEOUT_ORDER.testOrSuite)
+    }
+  })
+
+  event.dispatcher.on(event.step.after, step => {
+    if (typeof timeout !== 'number') return
+    if (!store.timeouts) return
+
+    recorder.catchWithoutStop(err => {
+      // we wrap timeout errors in a StepTimeoutError
+      // but only if global timeout is set
+      // should we wrap all timeout errors?
+      if (err instanceof TimeoutError) {
+        const testTimeoutExceeded = timeout && +Date.now() - step.startTime >= timeout
+        debug('Step failed due to global test or suite timeout')
+        if (testTimeoutExceeded) {
+          debug('Test failed due to global test or suite timeout')
+          throw new TestTimeoutError(currentTimeout)
+        }
+        throw new StepTimeoutError(currentTimeout, step)
+      }
+      throw err
+    })
+  })
+
+  event.dispatcher.on(event.step.finished, step => {
+    if (!store.timeouts) {
+      debug('step', step.toCode().trim(), 'timeout disabled')
+      return
+    }
+
+    if (typeof timeout === 'number') debug('Timeout', timeout)
+
+    debug(`step ${step.toCode().trim()}:${step.status} duration`, step.duration)
+    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration
+
+    if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
+      debug(`step ${step.toCode().trim()} timed out`)
+      recorder.throw(new TestTimeoutError(currentTimeout))
+    }
+  })
+}
+
+function checkForSeconds(timeout) {
+  if (timeout >= 1000) {
+    console.log(`Warning: Timeout was set to ${timeout}secs.\nGlobal timeout should be specified in seconds.`)
+  }
+}

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/result.js

@@ -0,0 +1,12 @@
+const event = require('../event')
+const container = require('../container')
+
+module.exports = function () {
+  event.dispatcher.on(event.hook.failed, err => {
+    container.result().addStats({ failedHooks: 1 })
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    container.result().addTest(test)
+  })
+}