codeceptjs 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/recorder.js

@@ -1,28 +1,29 @@
-import debug from 'debug';
-import promiseRetry from 'promise-retry';
-import chalk from 'chalk';
-import { printObjectProperties } from './utils.js';
-import * as output from './output.js';
-
-debug('codeceptjs:recorder');
-const MAX_TASKS = 100;
-
-let promise;
-let running = false;
-let errFn;
-let queueId = 0;
-let sessionId = null;
-let asyncErr = null;
-let ignoredErrs = [];
-
-let tasks = [];
-let oldPromises = [];
+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
+let running = false
+let errFn
+let queueId = 0
+let sessionId = null
+let sessionStack = [] // Stack to support nested sessions
+let asyncErr = null
+let ignoredErrs = []
+
+let tasks = []
+let oldPromises = []
 
 const defaultRetryOptions = {
   retries: 0,
   minTimeout: 150,
   maxTimeout: 10000,
-};
+}
 
 /**
  * Singleton object to record all test steps as promises and run them in chain.
@@ -30,7 +31,6 @@ const defaultRetryOptions = {
  * @interface
  */
 export default {
-
   /**
    * @type {Array<Object<string, *>>}
    * @inner
@@ -44,12 +44,11 @@ export default {
    * @inner
    */
   start() {
-    debug('Starting recording promises');
-    running = true;
-    asyncErr = null;
-    errFn = null;
-    // @ts-ignore
-    this.reset();
+    debug('Starting recording promises')
+    running = true
+    asyncErr = null
+    errFn = null
+    this.reset()
   },
 
   /**
@@ -57,7 +56,7 @@ export default {
    * @inner
    */
   isRunning() {
-    return running;
+    return running
   },
 
   /**
@@ -66,7 +65,7 @@ export default {
    */
   startUnlessRunning() {
     if (!this.isRunning()) {
-      this.start();
+      this.start()
     }
   },
 
@@ -78,7 +77,7 @@ export default {
    * @inner
    */
   errHandler(fn) {
-    errFn = fn;
+    errFn = fn
   },
 
   /**
@@ -89,16 +88,17 @@ export default {
    * @inner
    */
   reset() {
-    if (promise && running) this.catch();
-    queueId++;
-    sessionId = null;
-    asyncErr = null;
-    output.output.log(`${currentQueue()} Starting recording promises`);
-    promise = Promise.resolve();
-    oldPromises = [];
-    tasks = [];
-    ignoredErrs = [];
-    this.session.running = false;
+    if (promise && running) this.catch()
+    queueId++
+    sessionId = null
+    sessionStack = [] // Clear the session stack
+    asyncErr = null
+    output.log(`${currentQueue()} Starting recording promises`)
+    promise = Promise.resolve()
+    oldPromises = []
+    tasks = []
+    ignoredErrs = []
+    this.session.running = false
     // reset this retries makes the retryFailedStep plugin won't work if there is Before/BeforeSuit block due to retries is undefined on Scenario
     // this.retries = [];
   },
@@ -125,12 +125,21 @@ export default {
      * @inner
      */
     start(name) {
-      debug(`${currentQueue()}Starting <${name}> session`);
-      tasks.push('--->');
-      oldPromises.push(promise);
-      this.running = true;
-      sessionId = name;
-      promise = Promise.resolve();
+      if (sessionId) {
+        debug(`${currentQueue()}Session already started as ${sessionId}, nesting session ${name}`)
+        // Push current session to stack instead of restoring it
+        sessionStack.push({
+          id: sessionId,
+          promise: promise,
+          running: this.running,
+        })
+      }
+      debug(`${currentQueue()}Starting <${name}> session`)
+      tasks.push('--->')
+      oldPromises.push(promise)
+      this.running = true
+      sessionId = name
+      promise = Promise.resolve()
     },
 
     /**
@@ -138,12 +147,21 @@ export default {
      * @inner
      */
     restore(name) {
-      tasks.push('<---');
-      debug(`${currentQueue()}Finalize <${name}> session`);
-      this.running = false;
-      sessionId = null;
-      this.catch(errFn);
-      promise = promise.then(() => oldPromises.pop());
+      tasks.push('<---')
+      debug(`${currentQueue()}Finalize <${name}> session`)
+      this.running = false
+      this.catch(errFn)
+      promise = promise.then(() => oldPromises.pop())
+
+      // Restore parent session from stack if available
+      if (sessionStack.length > 0) {
+        const parentSession = sessionStack.pop()
+        sessionId = parentSession.id
+        this.running = parentSession.running
+        debug(`${currentQueue()}Restored parent session <${sessionId}>`)
+      } else {
+        sessionId = null
+      }
     },
 
     /**
@@ -151,9 +169,8 @@ export default {
      * @inner
      */
     catch(fn) {
-      promise = promise.catch(fn);
+      promise = promise.catch(fn)
     },
-
   },
 
   /**
@@ -165,50 +182,56 @@ export default {
    * @param {boolean} [force=false]
    * @param {boolean} [retry]
    *     undefined: `add(fn)` -> `false` and `add('step',fn)` -> `true`
-   *     true: it will retry if `retryOpts` set.
+   *     true: it will retries if `retryOpts` set.
    *     false: ignore `retryOpts` and won't retry.
    * @param {number} [timeout]
-   * @return {Promise<*>|undefined}
+   * @return {Promise<*>}
    * @inner
    */
   add(taskName, fn = undefined, force = false, retry = undefined, timeout = undefined) {
     if (typeof taskName === 'function') {
-      fn = taskName;
-      taskName = fn.toString();
-      if (retry === undefined) retry = false;
+      fn = taskName
+      taskName = fn.toString()
+      if (retry === undefined) retry = false
     }
-    if (retry === undefined) retry = true;
+    if (retry === undefined) retry = true
     if (!running && !force) {
-      return;
+      return Promise.resolve()
     }
-    tasks.push(taskName);
-    debug(chalk.gray(`${currentQueue()} Queued | ${taskName}`));
+    tasks.push(taskName)
+    debug(chalk.gray(`${currentQueue()} Queued | ${taskName}`))
 
-    return promise = Promise.resolve(promise).then((res) => {
+    return (promise = Promise.resolve(promise).then(res => {
       // prefer options for non-conditional retries
-      const retryOpts = this.retries.sort((r1, r2) => r1.when && !r2.when).slice(-1).pop();
+      const retryOpts = this.retries
+        .sort((r1, r2) => r1.when && !r2.when)
+        .slice(-1)
+        .pop()
       // no retries or unnamed tasks
+      debug(`${currentQueue()} Running | ${taskName} | Timeout: ${timeout || 'None'}`)
+      if (retryOpts) debug(`${currentQueue()} Retry opts`, JSON.stringify(retryOpts))
+
       if (!retryOpts || !taskName || !retry) {
-        const [promise, timer] = getTimeoutPromise(timeout, taskName);
-        return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer));
+        const [promise, timer] = getTimeoutPromise(timeout, taskName)
+        return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer))
       }
 
-      debug(`${currentQueue()} Running | ${taskName}`);
-
-      const retryRules = this.retries.slice().reverse();
+      const retryRules = this.retries.slice().reverse()
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
-        if (number > 1) output.output.log(`${currentQueue()}Retrying... Attempt #${number}`);
-        const [promise, timer] = getTimeoutPromise(timeout, taskName);
-        return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer)).catch((err) => {
-          if (ignoredErrs.includes(err)) return;
-          for (const retryObj of retryRules) {
-            if (!retryObj.when) return retry(err);
-            if (retryObj.when && retryObj.when(err)) return retry(err);
-          }
-          throw err;
-        });
-      });
-    });
+        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))
+          .catch(err => {
+            if (ignoredErrs.includes(err)) return
+            for (const retryObj of retryRules) {
+              if (!retryObj.when) return retry(err)
+              if (retryObj.when && retryObj.when(err)) return retry(err)
+            }
+            throw err
+          })
+      })
+    }))
   },
 
   /**
@@ -217,15 +240,17 @@ export default {
    * @inner
    */
   retry(opts) {
-    if (!promise) return;
+    if (!promise) return
 
     if (opts === null) {
-      opts = {};
+      opts = {}
     }
     if (Number.isInteger(opts)) {
-      opts = { retries: 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()
   },
 
   /**
@@ -234,20 +259,26 @@ export default {
    * @inner
    */
   catch(customErrFn) {
-    const fnDescription = customErrFn?.toString()?.replace(/\s{2,}/g, ' ').replace(/\n/g, ' ')?.slice(0, 50);
-    debug(chalk.gray(`${currentQueue()} Queued | catch with error handler ${fnDescription || ''}`));
-    return promise = promise.catch((err) => {
-      output.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
+    const fnDescription = customErrFn
+      ?.toString()
+      ?.replace(/\s{2,}/g, ' ')
+      .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 => {
+      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
       }
       if (customErrFn) {
-        customErrFn(err);
+        customErrFn(err)
       } else if (errFn) {
-        errFn(err);
+        errFn(err)
       }
-      this.stop();
-    });
+      this.stop()
+    }))
   },
 
   /**
@@ -256,17 +287,37 @@ export default {
    * @inner
    */
   catchWithoutStop(customErrFn) {
-    const fnDescription = customErrFn?.toString()?.replace(/\s{2,}/g, ' ').replace(/\n/g, ' ')?.slice(0, 50);
-    return promise = promise.catch((err) => {
-      if (ignoredErrs.includes(err)) return; // already caught
-      output.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
+    const fnDescription = customErrFn
+      ?.toString()
+      ?.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
+
+      // 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
+        }
       }
-    });
+    }))
   },
 
   /**
@@ -278,15 +329,15 @@ export default {
    */
 
   throw(err) {
-    if (ignoredErrs.includes(err)) return promise; // already caught
+    if (ignoredErrs.includes(err)) return promise // already caught
     return this.add(`throw error: ${err.message}`, () => {
-      if (ignoredErrs.includes(err)) return; // already caught
-      throw err;
-    });
+      if (ignoredErrs.includes(err)) return // already caught
+      throw err
+    })
   },
 
   ignoreErr(err) {
-    ignoredErrs.push(err);
+    ignoredErrs.push(err)
   },
 
   /**
@@ -295,7 +346,7 @@ export default {
    */
   saveFirstAsyncError(err) {
     if (asyncErr === null) {
-      asyncErr = err;
+      asyncErr = err
     }
   },
 
@@ -304,7 +355,7 @@ export default {
    * @inner
    */
   getAsyncErr() {
-    return asyncErr;
+    return asyncErr
   },
 
   /**
@@ -312,7 +363,7 @@ export default {
    * @inner
    */
   cleanAsyncErr() {
-    asyncErr = null;
+    asyncErr = null
   },
 
   /**
@@ -321,11 +372,9 @@ export default {
    * @inner
    */
   stop() {
-    if (process.env.DEBUG) debug(this.toString());
-    output.output.log(`${currentQueue()}Stopping recording promises`);
-    debug(this.toString());
-
-    running = false;
+    debug(this.toString())
+    output.log(`${currentQueue()} Stopping recording promises`)
+    running = false
   },
 
   /**
@@ -336,7 +385,7 @@ export default {
    * @inner
    */
   promise() {
-    return promise;
+    return promise
   },
 
   /**
@@ -345,7 +394,7 @@ export default {
    * @inner
    */
   scheduled() {
-    return tasks.slice(-MAX_TASKS).join('\n');
+    return tasks.slice(-MAX_TASKS).join('\n')
   },
 
   /**
@@ -354,7 +403,7 @@ export default {
    * @inner
    */
   getQueueId() {
-    return queueId;
+    return queueId
   },
 
   /**
@@ -363,20 +412,34 @@ export default {
    * @inner
    */
   toString() {
-    return `Queue: ${currentQueue()}\n\nTasks: ${this.scheduled()}`;
+    return `Queue: ${currentQueue()}\n\nTasks: ${this.scheduled()}`
+  },
+
+  /**
+   * Get current session ID
+   * @return {string|null}
+   * @inner
+   */
+  getCurrentSessionId() {
+    return sessionId
   },
-};
+}
 
 function getTimeoutPromise(timeoutMs, taskName) {
-  let timer;
-  if (timeoutMs) debug(`Timing out in ${timeoutMs}ms`);
-  return [new Promise((done, reject) => {
-    timer = setTimeout(() => { reject(new Error(`Action ${taskName} was interrupted on step timeout ${timeoutMs}ms`)); }, timeoutMs || 2e9);
-  }), timer];
+  let timer
+  if (timeoutMs) debug(`Timing out in ${timeoutMs}ms`)
+  return [
+    new Promise((done, reject) => {
+      timer = setTimeout(() => {
+        reject(new TimeoutError(`Action ${taskName} was interrupted on timeout ${timeoutMs}ms`))
+      }, timeoutMs || 2e9)
+    }),
+    timer,
+  ]
 }
 
 function currentQueue() {
-  let session = '';
-  if (sessionId) session = `<${sessionId}> `;
-  return `[${queueId}] ${session}`;
+  let session = ''
+  if (sessionId) session = `<${sessionId}> `
+  return `[${queueId}] ${session}`
 }