codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

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

@@ -1,12 +1,12 @@
-const event = require('../event')
-const output = require('../output')
-const Config = require('../config')
-const { isNotSet } = require('../utils')
+import event from '../event.js'
+import output from '../output.js'
+import Config from '../config.js'
+import { isNotSet } from '../utils.js'
 
 const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
-module.exports = function () {
-  event.dispatcher.on(event.suite.before, (suite) => {
+export default function () {
+  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,166 @@
+import event from '../event.js'
+import output from '../output.js'
+import recorder from '../recorder.js'
+import Config from '../config.js'
+import store from '../store.js'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:timeout')
+import { TIMEOUT_ORDER, TimeoutError, TestTimeoutError, StepTimeoutError } from '../timeout.js'
+import { BeforeSuiteHook, AfterSuiteHook } from '../mocha/hooks.js'
+
+export default 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

@@ -1,18 +1,17 @@
-const path = require('path')
-const event = require('../event')
-const container = require('../container')
-const recorder = require('../recorder')
-const store = require('../store')
-const { error } = require('../output')
+import path from 'path'
+import event from '../event.js'
+import recorder from '../recorder.js'
+import store from '../store.js'
+import output from '../output.js'
 /**
  * Enable Helpers to listen to test events
  */
-module.exports = function () {
-  const helpers = container.helpers()
+export default function () {
+  const helpers = global.container.helpers()
 
   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,59 +20,79 @@ 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 => output.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 => output.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 => output.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 => output.error(e))
   })
 
   event.dispatcher.on(event.test.after, () => {
     runAsyncHelpersHook('_after', {}, true)
-    recorder.catchWithoutStop((e) => error(e))
+    recorder.catchWithoutStop(e => output.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)
   })
 
   event.dispatcher.on(event.all.result, () => {
-    runAsyncHelpersHook('_finishTest', {}, true)
+    // Skip _finishTest for all helpers if any browser helper restarts to avoid double cleanup
+    const hasBrowserRestart = Object.values(helpers).some(helper => (helper.config && helper.config.restart) || (helper.options && helper.options.restart === 'context'))
+
+    Object.keys(helpers).forEach(key => {
+      const helper = helpers[key]
+      if (helper._finishTest && !hasBrowserRestart) {
+        recorder.add(`hook ${key}._finishTest()`, () => helper._finishTest(), true, false)
+      }
+    })
+  })
+
+  event.dispatcher.on(event.all.after, () => {
+    // Skip _cleanup for all helpers if any browser helper restarts to avoid double cleanup
+    const hasBrowserRestart = Object.values(helpers).some(helper => (helper.config && helper.config.restart) || (helper.options && helper.options.restart === 'context'))
+
+    Object.keys(helpers).forEach(key => {
+      const helper = helpers[key]
+      if (helper._cleanup && !hasBrowserRestart) {
+        recorder.add(`hook ${key}._cleanup()`, () => helper._cleanup(), true, false)
+      }
+    })
   })
 }

package/lib/listener/mocha.js

@@ -1,14 +1,13 @@
-const event = require('../event')
-const container = require('../container')
+import event from '../event.js'
 
-module.exports = function () {
+export default function () {
   let mocha
 
   event.dispatcher.on(event.all.before, () => {
-    mocha = container.mocha()
+    mocha = global.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,11 @@
+import event from '../event.js'
+
+export default function () {
+  event.dispatcher.on(event.hook.failed, err => {
+    global.container.result().addStats({ failedHooks: 1 })
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    global.container.result().addTest(test)
+  })
+}

package/lib/listener/steps.js

@@ -1,7 +1,9 @@
-const debug = require('debug')('codeceptjs:steps')
-const event = require('../event')
-const store = require('../store')
-const output = require('../output')
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:steps')
+import event from '../event.js'
+import store from '../store.js'
+import output from '../output.js'
+import { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } from '../mocha/hooks.js'
 
 let currentTest
 let currentHook
@@ -9,40 +11,43 @@ let currentHook
 /**
  * Register steps inside tests
  */
-module.exports = function () {
-  event.dispatcher.on(event.test.before, (test) => {
+export default function () {
+  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,9 +70,8 @@ module.exports = function () {
     currentTest.state = 'passed'
   })
 
-  event.dispatcher.on(event.step.started, (step) => {
-    step.startedAt = +new Date()
-    step.test = currentTest
+  event.dispatcher.on(event.step.started, step => {
+    store.currentStep = step
     if (currentHook && Array.isArray(currentHook.steps)) {
       return currentHook.steps.push(step)
     }
@@ -75,9 +79,8 @@ module.exports = function () {
     currentTest.steps.push(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`)
+  event.dispatcher.on(event.step.finished, step => {
+    store.currentStep = null
+    store.stepOptions = null
   })
 }

package/lib/listener/store.js

@@ -0,0 +1,20 @@
+import event from '../event.js'
+import store from '../store.js'
+
+export default function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    store.currentSuite = suite
+  })
+
+  event.dispatcher.on(event.suite.after, () => {
+    store.currentSuite = null
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    store.currentTest = test
+  })
+
+  event.dispatcher.on(event.test.finished, () => {
+    store.currentTest = null
+  })
+}