codeceptjs 4.0.0-beta.1 → 4.0.0-beta.11.esm-aria

package/lib/listener/enhancedGlobalRetry.js

@@ -0,0 +1,110 @@
+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']
+
+/**
+ * Priority levels for retry mechanisms (higher number = higher priority)
+ * This ensures consistent behavior when multiple retry mechanisms are active
+ */
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50, // retryFailedStep plugin
+  SCENARIO_CONFIG: 30, // Global scenario retry config
+  FEATURE_CONFIG: 20, // Global feature retry config
+  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+}
+
+/**
+ * Enhanced global retry mechanism that coordinates with other retry types
+ */
+export default function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // is number - apply as feature-level retry
+      const retryNum = +retryConfig
+      output.log(`[Global Retry] Feature retries: ${retryNum}`)
+
+      // Only set if not already set by higher priority mechanism
+      if (isNotSet(suite.retries())) {
+        suite.retries(retryNum)
+        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!suite.title.includes(config.grep)) continue
+      }
+
+      // Handle hook retries with priority awareness
+      hooks
+        .filter(hook => !!config[hook])
+        .forEach(hook => {
+          const retryKey = `retry${hook}`
+          if (isNotSet(suite.opts[retryKey])) {
+            suite.opts[retryKey] = config[hook]
+            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
+          }
+        })
+
+      // Handle feature-level retries
+      if (config.Feature) {
+        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+          suite.retries(config.Feature)
+          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
+        }
+      }
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // Only set if not already set by higher priority mechanism
+      if (test.retries() === -1) {
+        test.retries(retryConfig)
+        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    retryConfig = retryConfig.filter(config => !!config.Scenario)
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!test.fullTitle().includes(config.grep)) continue
+      }
+
+      if (config.Scenario) {
+        // Respect priority system
+        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
+          test.retries(config.Scenario)
+          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+          output.log(`[Global Retry] Scenario retries: ${config.Scenario}`)
+        }
+      }
+    }
+  })
+}
+
+// Export priority constants for use by other retry mechanisms
+export { RETRY_PRIORITIES }

package/lib/listener/exit.js

@@ -1,30 +1,28 @@
-import * as event from '../event.js';
+import event from '../event.js'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:exit')
 
 export default function () {
-  let failedTests = [];
+  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';
-    failedTests.push(id);
-  });
+  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;
+      code = 1
     }
 
     if (code) {
-      process.exit(code);
+      process.exit(code)
     }
-  });
+  })
 }

package/lib/listener/globalRetry.js

@@ -0,0 +1,70 @@
+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']
+
+export default function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // is number
+      const retryNum = +retryConfig
+      output.log(`Retries: ${retryNum}`)
+      suite.retries(retryNum)
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!suite.title.includes(config.grep)) continue
+      }
+
+      hooks
+        .filter(hook => !!config[hook])
+        .forEach(hook => {
+          if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook]
+        })
+
+      if (config.Feature) {
+        if (isNotSet(suite.retries())) suite.retries(config.Feature)
+      }
+
+      output.log(`Retries: ${JSON.stringify(config)}`)
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      if (test.retries() === -1) test.retries(retryConfig)
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    retryConfig = retryConfig.filter(config => !!config.Scenario)
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!test.fullTitle().includes(config.grep)) continue
+      }
+
+      if (config.Scenario) {
+        if (test.retries() === -1) test.retries(config.Scenario)
+        output.log(`Retries: ${config.Scenario}`)
+      }
+    }
+  })
+}

package/lib/listener/globalTimeout.js

@@ -0,0 +1,181 @@
+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?
+  // When a BeforeSuite/AfterSuite hook starts we want to disable the
+  // per-test timeout during that hook execution only. Previously the
+  // code cleared `suiteTimeout` permanently which caused the suite
+  // level timeout to be lost for subsequent tests. Save previous
+  // values and restore them when the hook finishes.
+  let __prevTimeout = undefined
+  let __prevSuiteTimeout = undefined
+
+  event.dispatcher.on(event.hook.started, hook => {
+    if (hook instanceof BeforeSuiteHook || hook instanceof AfterSuiteHook) {
+      __prevTimeout = timeout
+      // copy array to preserve original values
+      __prevSuiteTimeout = suiteTimeout.slice()
+      timeout = null
+      suiteTimeout = []
+    }
+  })
+
+  event.dispatcher.on(event.hook.finished, hook => {
+    if (hook instanceof BeforeSuiteHook || hook instanceof AfterSuiteHook) {
+      // restore previously stored values
+      timeout = __prevTimeout
+      suiteTimeout = __prevSuiteTimeout.slice()
+    }
+  })
+
+  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,79 +1,104 @@
-import * as event from '../event.js';
-import container from '../container.js';
-import recorder from '../recorder.js';
-import { store } from '../store.js';
-import * as output from '../output.js';
-
+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
  */
 export default function () {
-  const helpers = container.helpers();
+  const helpers = global.container.helpers()
 
   const runHelpersHook = (hook, param) => {
-    if (store.dryRun) return;
-    Object.values(helpers).forEach((helper) => {
+    if (store.dryRun) return
+    Object.values(helpers).forEach(helper => {
       if (helper[hook]) {
-        helper[hook](param);
+        helper[hook](param)
       }
-    });
-  };
+    })
+  }
 
   const runAsyncHelpersHook = (hook, param, force) => {
-    if (store.dryRun) return;
-    Object.keys(helpers).forEach((key) => {
-      if (!helpers[key][hook]) return;
-      recorder.add(`hook ${key}.${hook}()`, () => helpers[key][hook](param), force, false);
-    });
-  };
+    if (store.dryRun) return
+    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);
-  });
+    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);
-  });
+    runAsyncHelpersHook('_afterSuite', suite, true)
+  })
 
-  event.dispatcher.on(event.test.started, (test) => {
-    runHelpersHook('_test', test);
-    recorder.catch(e => output.output.error(e));
-  });
+  event.dispatcher.on(event.test.started, test => {
+    runHelpersHook('_test', test)
+    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 => output.output.error(e));
-  });
+    runAsyncHelpersHook('_before', test, true)
+    recorder.catchWithoutStop(e => output.error(e))
+  })
 
-  event.dispatcher.on(event.test.passed, (test) => {
-    runAsyncHelpersHook('_passed', test, true);
+  event.dispatcher.on(event.test.passed, test => {
+    runAsyncHelpersHook('_passed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop(e => output.output.error(e));
-  });
+    recorder.catchWithoutStop(e => output.error(e))
+  })
 
-  event.dispatcher.on(event.test.failed, (test) => {
-    runAsyncHelpersHook('_failed', test, true);
+  event.dispatcher.on(event.test.failed, test => {
+    runAsyncHelpersHook('_failed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop(e => output.output.error(e));
-  });
+    recorder.catchWithoutStop(e => output.error(e))
+  })
 
   event.dispatcher.on(event.test.after, () => {
-    runAsyncHelpersHook('_after', {}, true);
-    recorder.catchWithoutStop(e => output.output.error(e));
-  });
+    runAsyncHelpersHook('_after', {}, true)
+    recorder.catchWithoutStop(e => output.error(e))
+  })
 
-  event.dispatcher.on(event.step.before, (step) => {
-    runAsyncHelpersHook('_beforeStep', step);
-  });
+  event.dispatcher.on(event.step.before, step => {
+    runAsyncHelpersHook('_beforeStep', step)
+  })
 
-  event.dispatcher.on(event.step.after, (step) => {
-    runAsyncHelpersHook('_afterStep', 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 === 'browser' || helper.config.restart === 'context' || helper.config.restart === true)) || 
+      (helper.options && (helper.options.restart === 'browser' || helper.options.restart === 'context' || helper.options.restart === true))
+    )
+
+    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 === 'browser' || helper.config.restart === 'context' || helper.config.restart === true)) || 
+      (helper.options && (helper.options.restart === 'browser' || helper.options.restart === 'context' || helper.options.restart === true))
+    )
+
+    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,19 +1,18 @@
-import * as event from '../event.js';
-import container from '../container.js';
+import event from '../event.js'
 
 export default function () {
-  let mocha;
+  let mocha
 
   event.dispatcher.on(event.all.before, () => {
-    mocha = container.mocha();
-  });
+    mocha = global.container.mocha()
+  })
 
-  event.dispatcher.on(event.test.passed, (test) => {
-    mocha.Runner.emit('pass', test);
-  });
+  event.dispatcher.on(event.test.passed, test => {
+    mocha.Runner.emit('pass', test)
+  })
 
   event.dispatcher.on(event.test.failed, (test, err) => {
-    test.state = 'failed';
-    mocha.Runner.emit('fail', test, err);
-  });
+    test.state = 'failed'
+    mocha.Runner.emit('fail', test, err)
+  })
 }

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