codeceptjs 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/plugin/pageInfo.js

@@ -0,0 +1,140 @@
+import path from 'path'
+import fs from 'fs'
+import Container from '../container.js'
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
+import recorder from '../recorder.js'
+import event from '../event.js'
+import { scanForErrorMessages } from '../html.js'
+import { output } from '../index.js'
+import { humanizeString, ucfirst } from '../utils.js'
+import { testToFileName } from '../mocha/test.js'
+const defaultConfig = {
+  errorClasses: ['error', 'warning', 'alert', 'danger'],
+  browserLogs: ['error'],
+}
+
+/**
+ * Collects information from web page after each failed test and adds it to the test as an artifact.
+ * It is suggested to enable this plugin if you run tests on CI and you need to debug failed tests.
+ * This plugin can be paired with `analyze` plugin to provide more context.
+ *
+ * It collects URL, HTML errors (by classes), and browser logs.
+ *
+ * Enable this plugin in config:
+ *
+ * ```js
+ * plugins: {
+ *  pageInfo: {
+ *   enabled: true,
+ * }
+ * ```
+ *
+ * Additional config options:
+ *
+ * * `errorClasses` - list of classes to search for errors (default: `['error', 'warning', 'alert', 'danger']`)
+ * * `browserLogs` - list of types of errors to search for in browser logs (default: `['error']`)
+ *
+ */
+export default function (config = {}) {
+  const helpers = Container.helpers()
+  let helper
+
+  config = Object.assign(defaultConfig, config)
+
+  for (const helperName of supportedHelpers) {
+    if (Object.keys(helpers).indexOf(helperName) > -1) {
+      helper = helpers[helperName]
+    }
+  }
+
+  if (!helper) return // no helpers for screenshot
+
+  event.dispatcher.on(event.test.failed, test => {
+    const pageState = {}
+
+    recorder.add('URL of failed test', async () => {
+      try {
+        const url = await helper.grabCurrentUrl()
+        pageState.url = url
+      } catch (err) {
+        // not really needed
+      }
+    })
+    recorder.add('HTML snapshot failed test', async () => {
+      try {
+        const html = await helper.grabHTMLFrom('body')
+
+        if (!html) return
+
+        const errors = scanForErrorMessages(html, config.errorClasses)
+        if (errors.length) {
+          output.debug('Detected errors in HTML code')
+          errors.forEach(error => output.debug(error))
+          pageState.htmlErrors = errors
+        }
+      } catch (err) {
+        // not really needed
+      }
+    })
+
+    recorder.add('Browser logs for failed test', async () => {
+      try {
+        const logs = await helper.grabBrowserLogs()
+
+        if (!logs) return
+
+        pageState.browserErrors = getBrowserErrors(logs, config.browserLogs)
+      } catch (err) {
+        // not really needed
+      }
+    })
+
+    recorder.add('Save page info', () => {
+      test.addNote('pageInfo', pageStateToMarkdown(pageState))
+
+      const pageStateFileName = path.join(global.output_dir, `${testToFileName(test)}.pageInfo.md`)
+      fs.writeFileSync(pageStateFileName, pageStateToMarkdown(pageState))
+      test.artifacts.pageInfo = pageStateFileName
+      return pageState
+    })
+  })
+}
+
+function pageStateToMarkdown(pageState) {
+  let markdown = ''
+
+  for (const [key, value] of Object.entries(pageState)) {
+    if (!value) continue
+    let result = ''
+
+    if (Array.isArray(value)) {
+      result = value.map(v => `- ${JSON.stringify(v, null, 2)}`).join('\n')
+    } else if (typeof value === 'string') {
+      result = `${value}`
+    } else {
+      result = JSON.stringify(value, null, 2)
+    }
+
+    if (!result.trim()) continue
+
+    markdown += `### ${ucfirst(humanizeString(key))}\n\n`
+    markdown += result
+    markdown += '\n\n'
+  }
+
+  return markdown
+}
+
+function getBrowserErrors(logs, type = ['error']) {
+  // Playwright & WebDriver console messages
+  let errors = logs
+    .map(log => {
+      if (typeof log === 'string') return log
+      if (!log.type) return null
+      return { type: log.type(), text: log.text() }
+    })
+    .filter(l => l && (typeof l === 'string' || type.includes(l.type)))
+    .map(l => (typeof l === 'string' ? l : l.text))
+
+  return errors
+}

package/lib/plugin/pauseOnFail.js

@@ -1,5 +1,6 @@
-import * as event from '../event.js';
-import pause from '../pause';
+import event from '../event.js'
+
+import pause from '../pause.js'
 
 /**
  * Automatically launches [interactive pause](/basics/#pause) when a test fails.
@@ -21,18 +22,18 @@ import pause from '../pause';
  * ```
  *
  */
-export default () => {
-  let failed = false;
+export default function() {
+  let failed = false
 
   event.dispatcher.on(event.test.started, () => {
-    failed = false;
-  });
+    failed = false
+  })
 
   event.dispatcher.on(event.step.failed, () => {
-    failed = true;
-  });
+    failed = true
+  })
 
   event.dispatcher.on(event.test.after, () => {
-    if (failed) pause();
-  });
-};
+    if (failed) pause()
+  })
+}

package/lib/plugin/retryFailedStep.js

@@ -1,22 +1,15 @@
-import * as event from '../event.js';
-import recorder from '../recorder.js';
-import * as output from '../output.js';
+import event from '../event.js'
 
-import { store } from '../store.js';
+import recorder from '../recorder.js'
+
+import store from '../store.js'
 
 const defaultConfig = {
   retries: 3,
-  defaultIgnoredSteps: [
-    'amOnPage',
-    'wait*',
-    'send*',
-    'execute*',
-    'run*',
-    'have*',
-  ],
+  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
   factor: 1.5,
   ignoredSteps: [],
-};
+}
 
 /**
  * Retries each failed step in a test.
@@ -78,51 +71,93 @@ const defaultConfig = {
  * Use scenario configuration to disable plugin for a test
  *
  * ```js
- * Scenario('scenario tite', () => {
+ * Scenario('scenario tite', { disableRetryFailedStep: true }, () => {
  *    // test goes here
- * }).config(test => test.disableRetryFailedStep = true)
+ * })
  * ```
  *
  */
-export default (config) => {
-  config = Object.assign(defaultConfig, config);
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps);
-  const customWhen = config.when;
+export default function (config) {
+  config = Object.assign(defaultConfig, config)
+  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
+  const customWhen = config.when
 
-  let enableRetry = false;
+  let enableRetry = false
 
-  const when = (err) => {
-    if (!enableRetry) return;
-    if (store.debugMode) return false;
-    if (customWhen) return customWhen(err);
-    return true;
-  };
-  config.when = when;
+  const when = err => {
+    if (!enableRetry) return
+    if (store.debugMode) return false
+    if (!store.autoRetries) return false
+    // Don't retry terminal errors (e.g., frame detachment errors)
+    if (err && err.isTerminal) return false
+    // Don't retry navigation errors that are known to be terminal
+    if (err && err.message && (err.message.includes('ERR_ABORTED') || err.message.includes('frame was detached') || err.message.includes('Target page, context or browser has been closed'))) return false
+    if (customWhen) return customWhen(err)
+    return true
+  }
+  config.when = when
 
-  event.dispatcher.on(event.step.started, (step) => {
-    if (process.env.TRY_TO === 'true') {
-      output.output.log('Info: RetryFailedStep plugin is disabled inside tryTo block');
-      return;
-    }
+  // Ensure retry options are available before any steps run
+  if (!recorder.retries.find(r => r === config)) {
+    recorder.retries.push(config)
+  }
 
+  event.dispatcher.on(event.step.started, step => {
     // if a step is ignored - return
     for (const ignored of config.ignoredSteps) {
-      if (step.name === ignored) return;
+      if (step.name === ignored) return
       if (ignored instanceof RegExp) {
-        if (step.name.match(ignored)) return;
-      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return;
+        if (step.name.match(ignored)) return
+      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
+    }
+    enableRetry = true // enable retry for a step
+  })
+
+  // Disable retry only after a successful step; keep it enabled for failure so retry logic can act
+  event.dispatcher.on(event.step.passed, () => {
+    enableRetry = false
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    // pass disableRetryFailedStep is a preferred way to disable retries
+    // test.disableRetryFailedStep is used for backward compatibility
+    if (!test.opts) test.opts = {}
+    if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
+      store.autoRetries = false
+      return // disable retry when a test is not active
     }
-    enableRetry = true; // enable retry for a step
-  });
 
-  event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false;
-  });
+    // Don't apply plugin retry logic if there are already manual retries configured
+    // Check if any retry configs exist that aren't from this plugin
+    const hasManualRetries = recorder.retries.some(retry => retry !== config)
+    if (hasManualRetries) {
+      store.autoRetries = false
+      return
+    }
 
-  event.dispatcher.on(event.test.before, (test) => {
-    if (test && test.disableRetryFailedStep) return; // disable retry when a test is not active
-    // this env var is used to set the retries inside _before() block of helpers
-    process.env.FAILED_STEP_RETRIES = config.retries;
-    recorder.retry(config);
-  });
-};
+    // this option is used to set the retries inside _before() block of helpers
+    store.autoRetries = true
+    test.opts.conditionalRetries = config.retries
+    // debug: record applied retries value for tests
+    if (process.env.DEBUG_RETRY_PLUGIN) {
+      // eslint-disable-next-line no-console
+      console.log('[retryFailedStep] applying retries =', config.retries, 'for test', test.title)
+    }
+    recorder.retry(config)
+  })
+
+  // Fallback for environments where event.test.before wasn't emitted (runner scenarios)
+  event.dispatcher.on(event.test.started, test => {
+    if (test.opts?.disableRetryFailedStep || test.disableRetryFailedStep) return
+
+    // Don't apply plugin retry logic if there are already manual retries configured
+    // Check if any retry configs exist that aren't from this plugin
+    const hasManualRetries = recorder.retries.some(retry => retry !== config)
+    if (hasManualRetries) return
+
+    if (!store.autoRetries) {
+      store.autoRetries = true
+      test.opts.conditionalRetries = test.opts.conditionalRetries || config.retries
+    }
+  })
+}

package/lib/plugin/screenshotOnFail.js

@@ -1,19 +1,25 @@
-import fs from 'fs';
-import path from 'path';
-import Container from '../container.js';
-import recorder from '../recorder.js';
-import * as event from '../event.js';
-import * as output from '../output.js';
-import { fileExists, clearString } from '../utils.js';
-import * as Codeceptjs from '../index.js';
+import fs from 'fs'
+import path from 'path'
 
-import supportedHelpers from './standardActingHelpers.js';
+import Container from '../container.js'
+
+import recorder from '../recorder.js'
+
+import event from '../event.js'
+
+import output from '../output.js'
+
+import { fileExists } from '../utils.js'
+import Codeceptjs from '../index.js'
+import { testToFileName } from '../mocha/test.js'
 
 const defaultConfig = {
   uniqueScreenshotNames: false,
   disableScreenshots: false,
   fullPageScreenshots: false,
-};
+}
+
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 
 /**
  * Creates screenshot on failure. Screenshot is saved into `output` directory.
@@ -42,118 +48,131 @@ const defaultConfig = {
  *
  */
 export default function (config) {
-  const helpers = Container.helpers();
-  let helper;
+  const helpers = Container.helpers()
+  let helper
 
   for (const helperName of supportedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName];
+      helper = helpers[helperName]
     }
   }
 
-  if (!helper) return; // no helpers for screenshot
+  if (!helper) return // no helpers for screenshot
 
-  const options = Object.assign(defaultConfig, helper.options, config);
+  const options = Object.assign(defaultConfig, helper.options, config)
 
   if (helpers.Mochawesome) {
     if (helpers.Mochawesome.config) {
-      options.uniqueScreenshotNames = helpers.Mochawesome.config.uniqueScreenshotNames;
+      options.uniqueScreenshotNames = helpers.Mochawesome.config.uniqueScreenshotNames
     }
   }
 
-  if (Codeceptjs.container.mocha) {
-    options.reportDir = Codeceptjs.container.mocha.options.reporterOptions
-      && Codeceptjs.container.mocha.options.reporterOptions.reportDir;
+  if (Codeceptjs.container.mocha()) {
+    options.reportDir = Codeceptjs.container.mocha()?.options?.reporterOptions && Codeceptjs.container.mocha()?.options?.reporterOptions?.reportDir
   }
 
   if (options.disableScreenshots) {
     // old version of disabling screenshots
-    return;
+    return
   }
 
-  event.dispatcher.on(event.test.failed, (test) => {
-    if (test.ctx?._runnable.title.includes('hook: ')) {
-      output.output.plugin('screenshotOnFail', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.');
+  event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+    if (hookName === 'BeforeSuite' || hookName === 'AfterSuite') {
+      // no browser here
       return
     }
 
-    recorder.add('screenshot of failed test', async () => {
-      let fileName = clearString(test.title);
-      const dataType = 'image/png';
-      // This prevents data driven to be included in the failed screenshot file name
-      if (fileName.indexOf('{') !== -1) {
-        fileName = fileName.substr(0, (fileName.indexOf('{') - 3)).trim();
-      }
-      if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') fileName = clearString(`${test.title}_${test.ctx.test.title}`);
-      if (options.uniqueScreenshotNames && test) {
-        const uuid = _getUUID(test);
-        fileName = `${fileName.substring(0, 10)}_${uuid}.failed.png`;
-      } else {
-        fileName += '.failed.png';
-      }
-      output.output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot');
-
-      try {
-        if (options.reportDir) {
-          fileName = path.join(options.reportDir, fileName);
-          const mochaReportDir = path.resolve(process.cwd(), options.reportDir);
-          if (!fileExists(mochaReportDir)) {
-            fs.mkdirSync(mochaReportDir);
-          }
+    recorder.add(
+      'screenshot of failed test',
+      async () => {
+        const dataType = 'image/png'
+        // This prevents data driven to be included in the failed screenshot file name
+        let fileName
+
+        if (options.uniqueScreenshotNames && test) {
+          fileName = `${testToFileName(test, { suffix: '', unique: true })}.failed.png`
+        } else {
+          fileName = `${testToFileName(test, { suffix: '', unique: false })}.failed.png`
         }
-        await helper.saveScreenshot(fileName, options.fullPageScreenshots);
-
-        if (!test.artifacts) test.artifacts = {};
-        test.artifacts.screenshot = path.join(global.output_dir, fileName);
-        if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {
-          test.attachments = [path.join(global.output_dir, fileName)];
+        const quietMode = !('output_dir' in global) || !global.output_dir
+        if (!quietMode) {
+          output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot')
         }
 
-        const allureReporter = Container.plugins('allure');
-        if (allureReporter) {
-          allureReporter.addAttachment('Main session - Last Seen Screenshot', fs.readFileSync(path.join(global.output_dir, fileName)), dataType);
-
-          if (helper.activeSessionName) {
-            for (const sessionName in helper.sessionPages) {
-              const screenshotFileName = `${sessionName}_${fileName}`;
-              test.artifacts[`${sessionName.replace(/ /g, '_')}_screenshot`] = path.join(global.output_dir, screenshotFileName);
-              allureReporter.addAttachment(`${sessionName} - Last Seen Screenshot`, fs.readFileSync(path.join(global.output_dir, screenshotFileName)), dataType);
-            }
+        // Re-check helpers at runtime in case they weren't ready during plugin init
+        const runtimeHelpers = Container.helpers()
+        let runtimeHelper = null
+        for (const helperName of supportedHelpers) {
+          if (Object.keys(runtimeHelpers).indexOf(helperName) > -1) {
+            runtimeHelper = runtimeHelpers[helperName]
+            break
           }
         }
 
-        const cucumberReporter = Container.plugins('cucumberJsonReporter');
-        if (cucumberReporter) {
-          cucumberReporter.addScreenshot(test.artifacts.screenshot);
-        }
-      } catch (err) {
-        output.output.plugin(err);
-        if (
-          err
-          && err.type
-          && err.type === 'RuntimeError'
-          && err.message
-          && (
-            err.message.indexOf('was terminated due to') > -1
-            || err.message.indexOf('no such window: target window already closed') > -1
-          )
-        ) {
-          output.output.log(`Can't make screenshot, ${err}`);
-          helper.isRunning = false;
+        if (runtimeHelper && typeof runtimeHelper.saveScreenshot === 'function') {
+          helper = runtimeHelper
         }
-      }
-    }, true);
-  });
 
-  function _getUUID(test) {
-    if (test.uuid) {
-      return test.uuid;
-    }
+        try {
+          if (options.reportDir) {
+            fileName = path.join(options.reportDir, fileName)
+            const mochaReportDir = path.resolve(process.cwd(), options.reportDir)
+            if (!fileExists(mochaReportDir)) {
+              fs.mkdirSync(mochaReportDir)
+            }
+          }
 
-    if (test.ctx && test.ctx.test?.uuid) {
-      return test.ctx.test.uuid;
-    }
+          // Check if browser/page is still available before attempting screenshot
+          if (helper.page && helper.page.isClosed && helper.page.isClosed()) {
+            throw new Error('Browser page has been closed')
+          }
+          if (helper.browser && helper.browser.isConnected && !helper.browser.isConnected()) {
+            throw new Error('Browser has been disconnected')
+          }
 
-    return Math.floor(new Date().getTime() / 1000);
-  }
+          // Add timeout wrapper to prevent hanging with shorter timeout for ESM
+          const screenshotPromise = helper.saveScreenshot(fileName, options.fullPageScreenshots)
+          const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error('Screenshot timeout after 5 seconds')), 5000)
+          })
+
+          await Promise.race([screenshotPromise, timeoutPromise])
+
+          if (!test.artifacts) test.artifacts = {}
+          // Some unit tests may not define global.output_dir; avoid throwing when it is undefined
+          // Detect output directory safely (may not be initialized in narrow unit tests)
+          const baseOutputDir = 'output_dir' in global && typeof global.output_dir === 'string' && global.output_dir ? global.output_dir : null
+          if (baseOutputDir) {
+            test.artifacts.screenshot = path.join(baseOutputDir, fileName)
+            if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {
+              test.attachments = [path.join(baseOutputDir, fileName)]
+            }
+          } else {
+            // Fallback: just store the file name to keep tests stable without triggering path errors
+            test.artifacts.screenshot = fileName
+          }
+        } catch (err) {
+          if (!quietMode) {
+            output.plugin('screenshotOnFail', `Failed to save screenshot: ${err.message}`)
+          }
+          // Enhanced error handling for browser closed scenarios
+          if (
+            err &&
+            ((err.message &&
+              (err.message.includes('Target page, context or browser has been closed') ||
+                err.message.includes('Browser page has been closed') ||
+                err.message.includes('Browser has been disconnected') ||
+                err.message.includes('was terminated due to') ||
+                err.message.includes('no such window: target window already closed') ||
+                err.message.includes('Screenshot timeout after'))) ||
+              (err.type && err.type === 'RuntimeError'))
+          ) {
+            output.log(`Can't make screenshot, ${err.message}`)
+            helper.isRunning = false
+          }
+        }
+      },
+      true,
+    )
+  })
 }