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

package/lib/recorder.js

@@ -1,9 +1,10 @@
-const debug = require('debug')('codeceptjs:recorder')
-const promiseRetry = require('promise-retry')
-const chalk = require('chalk')
-const { printObjectProperties } = require('./utils')
-const { log } = require('./output')
-const { TimeoutError } = require('./timeout')
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:recorder')
+import promiseRetry from 'promise-retry'
+import chalk from 'chalk'
+import { printObjectProperties } from './utils.js'
+import output from './output.js'
+import { TimeoutError } from './timeout.js'
 const MAX_TASKS = 100
 
 let promise
@@ -28,7 +29,7 @@ const defaultRetryOptions = {
  * @alias recorder
  * @interface
  */
-module.exports = {
+export default {
   /**
    * @type {Array<Object<string, *>>}
    * @inner
@@ -90,7 +91,7 @@ module.exports = {
     queueId++
     sessionId = null
     asyncErr = null
-    log(`${currentQueue()} Starting recording promises`)
+    output.log(`${currentQueue()} Starting recording promises`)
     promise = Promise.resolve()
     oldPromises = []
     tasks = []
@@ -201,7 +202,7 @@ module.exports = {
 
       const retryRules = this.retries.slice().reverse()
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
-        if (number > 1) log(`${currentQueue()}Retrying... Attempt #${number}`)
+        if (number > 1) output.log(`${currentQueue()}Retrying... Attempt #${number}`)
         const [promise, timer] = getTimeoutPromise(timeout, taskName)
         return Promise.race([promise, Promise.resolve(res).then(fn)])
           .finally(() => clearTimeout(timer))
@@ -231,7 +232,9 @@ module.exports = {
     if (Number.isInteger(opts)) {
       opts = { retries: opts }
     }
-    return this.add(() => this.retries.push(opts))
+    // Push retry options immediately so first step can see them
+    this.retries.push(opts)
+    return Promise.resolve()
   },
 
   /**
@@ -246,8 +249,9 @@ module.exports = {
       .replace(/\n/g, ' ')
       ?.slice(0, 50)
     debug(chalk.gray(`${currentQueue()} Queued | catch with error handler ${fnDescription || ''}`))
+    if (!promise) promise = Promise.resolve()
     return (promise = promise.catch(err => {
-      log(`${currentQueue()}Error | ${err} ${fnDescription}...`)
+      output.log(`${currentQueue()}Error | ${err} ${fnDescription}...`)
       if (!(err instanceof Error)) {
         // strange things may happen
         err = new Error(`[Wrapped Error] ${printObjectProperties(err)}`) // we should be prepared for them
@@ -272,15 +276,30 @@ module.exports = {
       ?.replace(/\s{2,}/g, ' ')
       .replace(/\n/g, ' ')
       ?.slice(0, 50)
+    if (!promise) promise = Promise.resolve()
     return (promise = promise.catch(err => {
       if (ignoredErrs.includes(err)) return // already caught
-      log(`${currentQueue()} Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`)
+
+      // Handle terminal errors - don't continue, re-throw immediately
+      if (err && (err.isTerminal || (err.message && (err.message.includes('ERR_ABORTED') || err.message.includes('frame was detached') || err.message.includes('Target page, context or browser has been closed'))))) {
+        output.log(`${currentQueue()} Terminal Error | ${err} | ${fnDescription || ''}...`)
+        throw err // Re-throw terminal errors immediately
+      }
+
+      output.log(`${currentQueue()} Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`)
       if (!(err instanceof Error)) {
         // strange things may happen
         err = new Error(`[Wrapped Error] ${JSON.stringify(err)}`) // we should be prepared for them
       }
       if (customErrFn) {
-        return customErrFn(err)
+        try {
+          const result = customErrFn(err)
+          // If customErrFn returns a value (not throwing), treat it as handled
+          return result
+        } catch (thrownErr) {
+          // If customErrFn throws an error, propagate it up
+          throw thrownErr
+        }
       }
     }))
   },
@@ -338,7 +357,7 @@ module.exports = {
    */
   stop() {
     debug(this.toString())
-    log(`${currentQueue()} Stopping recording promises`)
+    output.log(`${currentQueue()} Stopping recording promises`)
     running = false
   },
 
@@ -379,15 +398,6 @@ module.exports = {
   toString() {
     return `Queue: ${currentQueue()}\n\nTasks: ${this.scheduled()}`
   },
-
-  /**
-   * Get current session ID
-   * @return {string|null}
-   * @inner
-   */
-  getCurrentSessionId() {
-    return sessionId
-  },
 }
 
 function getTimeoutPromise(timeoutMs, taskName) {

package/lib/rerun.js

@@ -1,34 +1,77 @@
-const fsPath = require('path')
-const container = require('./container')
-const event = require('./event')
-const BaseCodecept = require('./codecept')
-const output = require('./output')
+import fsPath from 'path'
+import container from './container.js'
+import event from './event.js'
+import BaseCodecept from './codecept.js'
+import output from './output.js'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
 
 class CodeceptRerunner extends BaseCodecept {
-  runOnce(test) {
-    return new Promise((resolve, reject) => {
-      // @ts-ignore
-      container.createMocha()
-      const mocha = container.mocha()
-      this.testFiles.forEach(file => {
-        delete require.cache[file]
-      })
-      mocha.files = this.testFiles
-      if (test) {
-        if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test)
-        }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test)
-      }
+  async runOnce(test) {
+    await container.started()
+
+    // Ensure translations are loaded for Gherkin features
+    try {
+      const { loadTranslations } = await import('./mocha/gherkin.js')
+      await loadTranslations()
+    } catch (e) {
+      // Ignore if gherkin module not available
+    }
+
+    return new Promise(async (resolve, reject) => {
       try {
-        mocha.run(failures => {
-          if (failures === 0) {
-            resolve()
+        // Create a fresh Mocha instance for each run
+        // @ts-ignore
+        container.createMocha()
+        const mocha = container.mocha()
+
+        let filesToRun = this.testFiles
+        if (test) {
+          if (!fsPath.isAbsolute(test)) {
+            test = fsPath.join(global.codecept_dir, test)
+          }
+          filesToRun = this.testFiles.filter(t => fsPath.basename(t, '.js') === test || t === test)
+        }
+
+        // Clear any existing tests/suites
+        mocha.suite.suites = []
+        mocha.suite.tests = []
+
+        // Manually load each test file by importing it
+        for (const file of filesToRun) {
+          try {
+            // Clear CommonJS cache if available (for mixed environments)
+            try {
+              delete require.cache[file]
+            } catch (e) {
+              // ESM modules don't have require.cache, ignore
+            }
+
+            // Force reload the module by using a cache-busting query parameter
+            const fileUrl = `${fsPath.resolve(file)}?t=${Date.now()}`
+            await import(fileUrl)
+          } catch (e) {
+            console.error(`Error loading test file ${file}:`, e)
+          }
+        }
+
+        const done = () => {
+          event.emit(event.all.result, container.result())
+          event.emit(event.all.after, this)
+
+          // Check if there were any failures
+          if (container.result().hasFailed) {
+            reject(new Error('Test run failed'))
           } else {
-            reject(new Error(`${failures} tests fail`))
+            resolve(undefined)
           }
-        })
+        }
+
+        event.emit(event.all.before, this)
+        mocha.run(() => done())
       } catch (e) {
+        output.error(e.stack)
         reject(e)
       }
     })
@@ -79,4 +122,4 @@ class CodeceptRerunner extends BaseCodecept {
   }
 }
 
-module.exports = CodeceptRerunner
+export default CodeceptRerunner

package/lib/result.js

@@ -1,6 +1,6 @@
-const fs = require('fs')
-const path = require('path')
-const { serializeTest } = require('./mocha/test')
+import fs from 'fs'
+import path from 'path'
+import { serializeTest } from './mocha/test.js'
 
 /**
  * Result of the test run
@@ -158,4 +158,4 @@ class Result {
   }
 }
 
-module.exports = Result
+export default Result

package/lib/secret.js

@@ -1,20 +1,20 @@
-const { deepClone } = require('./utils');
+import { deepClone } from './utils.js'
 
-const maskedString = '*****';
+const maskedString = '*****'
 
 /** @param {string} secret */
 class Secret {
   constructor(secret) {
-    this._secret = secret;
+    this._secret = secret
   }
 
   /** @returns {string} */
   toString() {
-    return this._secret;
+    return this._secret
   }
 
   getMasked() {
-    return maskedString;
+    return maskedString
   }
 
   /**
@@ -23,11 +23,11 @@ class Secret {
    */
   static secret(secret) {
     if (typeof secret === 'object') {
-      const fields = Array.from(arguments);
-      fields.shift();
-      return secretObject(secret, fields);
+      const fields = Array.from(arguments)
+      fields.shift()
+      return secretObject(secret, fields)
     }
-    return new Secret(secret);
+    return new Secret(secret)
   }
 }
 
@@ -36,16 +36,17 @@ function secretObject(obj, fieldsToHide = []) {
     get(obj, prop) {
       if (prop === 'toString') {
         return function () {
-          const maskedObject = deepClone(obj);
-          fieldsToHide.forEach(f => (maskedObject[f] = maskedString));
-          return JSON.stringify(maskedObject);
-        };
+          const maskedObject = deepClone(obj)
+          fieldsToHide.forEach(f => (maskedObject[f] = maskedString))
+          return JSON.stringify(maskedObject)
+        }
       }
-      return fieldsToHide.includes(prop) ? new Secret(obj[prop]) : obj[prop];
+      return fieldsToHide.includes(prop) ? new Secret(obj[prop]) : obj[prop]
     },
-  };
+  }
 
-  return new Proxy(obj, handler);
+  return new Proxy(obj, handler)
 }
 
-module.exports = Secret;
+export default Secret
+export const secret = Secret.secret

package/lib/session.js

@@ -1,19 +1,13 @@
-const recorder = require('./recorder');
-const container = require('./container');
-const event = require('./event');
-const output = require('./output');
-const store = require('./store');
-const { isAsyncFunction } = require('./utils');
-
-const sessionColors = [
-  'cyan',
-  'blue',
-  'red',
-  'magenta',
-  'yellow',
-];
-
-const savedSessions = {};
+import recorder from './recorder.js'
+import container from './container.js'
+import event from './event.js'
+import output from './output.js'
+import store from './store.js'
+import { isAsyncFunction } from './utils.js'
+
+const sessionColors = ['cyan', 'blue', 'red', 'magenta', 'yellow']
+
+const savedSessions = {}
 
 /**
  * @param {CodeceptJS.LocatorOrString}  sessionName
@@ -24,109 +18,121 @@ const savedSessions = {};
 function session(sessionName, config, fn) {
   if (typeof config === 'function') {
     if (typeof fn === 'function') {
-      config = config();
+      config = config()
     } else {
       // no config but with function
-      fn = config;
-      config = {};
+      fn = config
+      config = {}
     }
   }
   // session helpers won't use beforeSuite and afterSuite hooks...
   // restart: false options are not allowed as well
   // but those helpers should be already started so inside listener/helpers.js the `_init` method should already be called
 
-  const helpers = container.helpers();
+  const helpers = container.helpers()
 
   if (!savedSessions[sessionName]) {
     for (const helper in helpers) {
-      if (!helpers[helper]._session) continue;
+      if (!helpers[helper]._session) continue
       savedSessions[sessionName] = {
         start: () => null,
         stop: () => null,
         loadVars: () => null,
         restoreVars: () => null,
         ...(store.dryRun ? {} : helpers[helper]._session()),
-      };
-      break;
+      }
+      break
     }
 
     const closeBrowsers = () => {
-      const session = savedSessions[sessionName];
-      if (!session) return;
-      session.stop(session.vars);
-      delete savedSessions[sessionName];
-    };
+      const session = savedSessions[sessionName]
+      if (!session) return
+      session.stop(session.vars)
+      delete savedSessions[sessionName]
+    }
 
     event.dispatcher.once(event.test.after, () => {
-      recorder.add('close session browsers', closeBrowsers);
-    });
+      recorder.add('close session browsers', closeBrowsers)
+    })
 
     if (!savedSessions[sessionName]) {
-      throw new Error('Configured helpers do not support starting sessions. Please use a helper with session support.');
+      throw new Error('Configured helpers do not support starting sessions. Please use a helper with session support.')
     }
 
     recorder.add('save vars', async () => {
-      savedSessions[sessionName].vars = await savedSessions[sessionName].start(sessionName, config);
-    });
+      savedSessions[sessionName].vars = await savedSessions[sessionName].start(sessionName, config)
+    })
   }
 
   // pick random color
-  const color = sessionColors[Object.keys(savedSessions).indexOf(sessionName) % sessionColors.length];
-
-  const addContextToStep = (step) => {
-    step.actor = `${output.colors[color](sessionName)}: I`;
-  };
-
-  if (!fn) return; // no current session steps
-
-  return recorder.add('register session wrapper', async () => {
-    const session = savedSessions[sessionName];
-    recorder.session.start(`session:${sessionName}`);
-    event.dispatcher.on(event.step.after, addContextToStep);
-    recorder.add('switch to browser', () => {
-      const session = savedSessions[sessionName];
-      return session.loadVars(session.vars);
-    });
-
-    const finalize = () => {
-      recorder.add('Finalize session', async () => {
-        output.stepShift = 0;
-        event.dispatcher.removeListener(event.step.after, addContextToStep);
-        await session.restoreVars();
-        recorder.session.restore(`session:${sessionName}`);
-      });
-    };
-
-    // Indicate when executing this function that we are in a session
-    if (isAsyncFunction(fn)) {
-      return fn.apply(null).then((res) => {
-        finalize();
-        return recorder.promise().then(() => res);
-      }).catch((e) => {
-        output.stepShift = 0;
-        session.restoreVars(sessionName);
-        event.dispatcher.removeListener(event.step.after, addContextToStep);
-        recorder.throw(e);
-        return recorder.promise();
-      });
-    }
+  const color = sessionColors[Object.keys(savedSessions).indexOf(sessionName) % sessionColors.length]
 
-    let res;
-    try {
-      res = fn.apply(null);
-    } catch (err) {
-      recorder.throw(err);
-    } finally {
-      recorder.catch((e) => {
-        session.restoreVars(sessionName);
-        output.stepShift = 0;
-        event.dispatcher.removeListener(event.step.after, addContextToStep);
-        throw e;
-      });
-    }
-    finalize();
-    return recorder.promise().then(() => res);
-  }, false, false);
+  const addContextToStep = step => {
+    step.actor = `${output.colors[color](sessionName)}: I`
+  }
+
+  if (!fn) return // no current session steps
+
+  return recorder.add(
+    'register session wrapper',
+    async () => {
+      const session = savedSessions[sessionName]
+      if (!session) {
+        throw new Error(`Session "${sessionName}" not found. It may have been closed already.`)
+      }
+      recorder.session.start(`session:${sessionName}`)
+      event.dispatcher.on(event.step.after, addContextToStep)
+      recorder.add('switch to browser', () => {
+        const session = savedSessions[sessionName]
+        return session.loadVars(session.vars)
+      })
+
+      const finalize = () => {
+        recorder.add('Finalize session', async () => {
+          output.stepShift = 0
+          event.dispatcher.removeListener(event.step.after, addContextToStep)
+          await session.restoreVars()
+          recorder.session.restore(`session:${sessionName}`)
+        })
+      }
+
+      // Indicate when executing this function that we are in a session
+      if (isAsyncFunction(fn)) {
+        return fn
+          .apply(null)
+          .then(async res => {
+            finalize()
+            await recorder.promise()
+            return res
+          })
+          .catch(e => {
+            output.stepShift = 0
+            session.restoreVars(sessionName)
+            event.dispatcher.removeListener(event.step.after, addContextToStep)
+            recorder.throw(e)
+            return recorder.promise()
+          })
+      }
+
+      let res
+      try {
+        res = fn.apply(null)
+      } catch (err) {
+        recorder.throw(err)
+      } finally {
+        recorder.catch(e => {
+          session.restoreVars(sessionName)
+          output.stepShift = 0
+          event.dispatcher.removeListener(event.step.after, addContextToStep)
+          throw e
+        })
+      }
+      finalize()
+      return recorder.promise().then(() => res)
+    },
+    false,
+    false,
+  )
 }
 
-module.exports = session;
+export default session

package/lib/step/base.js

@@ -1,8 +1,8 @@
-const color = require('chalk')
-const Secret = require('../secret')
-const { getCurrentTimeout } = require('../timeout')
-const { ucfirst, humanizeString, serializeError } = require('../utils')
-const recordStep = require('./record')
+import color from 'chalk'
+import Secret from '../secret.js'
+import { getCurrentTimeout } from '../timeout.js'
+import { ucfirst, humanizeString, serializeError } from '../utils.js'
+import recordStep from './record.js'
 
 const STACK_LINE = 5
 
@@ -236,4 +236,4 @@ class Step {
   }
 }
 
-module.exports = Step
+export default Step

package/lib/step/config.js

@@ -47,4 +47,4 @@ class StepConfig {
   }
 }
 
-module.exports = StepConfig
+export default StepConfig

package/lib/step/func.js

@@ -1,5 +1,5 @@
-const BaseStep = require('./base')
-const store = require('../store')
+import BaseStep from './base.js'
+import store from '../store.js'
 
 /**
  * Function executed as a step
@@ -43,4 +43,4 @@ class FuncStep extends BaseStep {
   }
 }
 
-module.exports = FuncStep
+export default FuncStep

package/lib/step/helper.js

@@ -1,5 +1,5 @@
-const Step = require('./base')
-const store = require('../store')
+import Step from './base.js'
+import store from '../store.js'
 
 class HelperStep extends Step {
   constructor(helper, name) {
@@ -38,7 +38,7 @@ class HelperStep extends Step {
   }
 }
 
-module.exports = HelperStep
+export default HelperStep
 
 function dryRunResolver() {
   return {

package/lib/step/meta.js

@@ -1,6 +1,6 @@
-const Step = require('./base')
-const event = require('../event')
-const { humanizeString } = require('../utils')
+import Step from './base.js'
+import event from '../event.js'
+import { humanizeString } from '../utils.js'
 
 class MetaStep extends Step {
   constructor(actor, method) {
@@ -96,4 +96,4 @@ class MetaStep extends Step {
   }
 }
 
-module.exports = MetaStep
+export default MetaStep

package/lib/step/record.js

@@ -1,10 +1,10 @@
-const event = require('../event')
-const recorder = require('../recorder')
-const StepConfig = require('./config')
-const { debug } = require('../output')
-const store = require('../store')
-const { TIMEOUT_ORDER } = require('../timeout')
-const retryStep = require('./retry')
+import event from '../event.js'
+import recorder from '../recorder.js'
+import StepConfig from './config.js'
+import output from '../output.js'
+import store from '../store.js'
+import { TIMEOUT_ORDER } from '../timeout.js'
+import retryStep from './retry.js'
 function recordStep(step, args) {
   step.status = 'queued'
 
@@ -15,12 +15,12 @@ function recordStep(step, args) {
     const { opts, timeout, retry } = stepConfig.getConfig()
 
     if (opts) {
-      debug(`Step ${step.name}: options applied ${JSON.stringify(opts)}`)
+      output.debug(`Step ${step.name}: options applied ${JSON.stringify(opts)}`)
       store.stepOptions = opts
       step.opts = opts
     }
     if (timeout) {
-      debug(`Step ${step.name} timeout ${timeout}s`)
+      output.debug(`Step ${step.name} timeout ${timeout}s`)
       step.setTimeout(timeout * 1000, TIMEOUT_ORDER.codeLimitTime)
     }
     if (retry) retryStep(retry)
@@ -57,7 +57,7 @@ function recordStep(step, args) {
     event.emit(event.step.finished, step)
   })
 
-  recorder.catchWithoutStop(err => {
+  recorder.catch(err => {
     step.status = 'failed'
     step.endTime = +Date.now()
     event.emit(event.step.failed, step, err)
@@ -71,4 +71,4 @@ function recordStep(step, args) {
   return recorder.promise()
 }
 
-module.exports = recordStep
+export default recordStep