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

package/lib/plugin/coverage.js

@@ -1,21 +1,25 @@
-import debug from 'debug';
-import { CoverageReport } from 'monocart-coverage-reports';
-import container from '../container.js';
-import recorder from '../recorder.js';
-import * as event from '../event.js';
-import * as output from '../output.js';
-import { deepMerge } from '../utils.js';
+import debugModule from 'debug'
+import { CoverageReport } from 'monocart-coverage-reports'
+import Container from '../container.js'
+
+import recorder from '../recorder.js'
+
+import event from '../event.js'
+
+import output from '../output.js'
+
+import { deepMerge } from '../utils.js'
 
 const defaultConfig = {
   name: 'CodeceptJS Coverage Report',
   outputDir: 'output/coverage',
-};
+}
 
-const supportedHelpers = ['Puppeteer', 'Playwright'];
+const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver']
 
 const v8CoverageHelpers = {
   Playwright: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -23,19 +27,16 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ]);
-      const coverageList = [...jsCoverage, ...cssCoverage];
-      await coverageReport.add(coverageList);
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
+      const coverageList = [...jsCoverage, ...cssCoverage]
+      await coverageReport.add(coverageList)
     },
   },
   Puppeteer: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -44,24 +45,51 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ]);
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
       // to raw V8 script coverage
-      const coverageList = [...jsCoverage.map((it) => {
-        return {
-          source: it.text,
-          ...it.rawScriptCoverage,
-        };
-      }), ...cssCoverage];
-      await coverageReport.add(coverageList);
+      const coverageList = [
+        ...jsCoverage.map(it => {
+          return {
+            source: it.text,
+            ...it.rawScriptCoverage,
+          }
+        }),
+        ...cssCoverage,
+      ]
+      await coverageReport.add(coverageList)
     },
   },
-};
+  WebDriver: {
+    startCoverage: async page => {
+      await Promise.all([
+        page.coverage.startJSCoverage({
+          resetOnNavigation: false,
+          includeRawScriptCoverage: true,
+        }),
+        page.coverage.startCSSCoverage({
+          resetOnNavigation: false,
+        }),
+      ])
+    },
+    takeCoverage: async (page, coverageReport) => {
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
+      // to raw V8 script coverage
+      const coverageList = [
+        ...jsCoverage.map(it => {
+          return {
+            source: it.text,
+            ...it.rawScriptCoverage,
+          }
+        }),
+        ...cssCoverage,
+      ]
+      await coverageReport.add(coverageList)
+    },
+  },
+}
 
 /**
  * Dumps code coverage from Playwright/Puppeteer after every test.
@@ -89,67 +117,92 @@ const v8CoverageHelpers = {
  * * `sourcePath`: option to resolve a custom path.
  *
  */
-
 export default function (config) {
-  config = deepMerge(defaultConfig, config);
-  if (config.debug) config.logging = 'debug';
-  const helpers = container.helpers();
-  console.log(helpers);
-  let coverageRunning = false;
-
-  const v8Names = Object.keys(v8CoverageHelpers);
-  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it));
+  config = deepMerge(defaultConfig, config)
+
+  if (config.debug) config.logging = 'debug'
+
+  const helpers = Container.helpers()
+  let coverageRunning = false
+
+  const v8Names = Object.keys(v8CoverageHelpers)
+  const helperName = Object.keys(helpers).find(it => v8Names.includes(it))
   if (!helperName) {
-    console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`);
+    console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`)
     // no helpers for screenshot
-    return;
+    return
   }
 
-  config.name = `${config.name} - in ${helperName}`;
-  const logger = debug(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`);
+  config.name = `${config.name} - in ${helperName}`
+  const debug = debugModule(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`)
+
+  const helper = helpers[helperName]
 
-  const helper = helpers[helperName];
-  const v8Helper = v8CoverageHelpers[helperName];
+  const v8Helper = v8CoverageHelpers[helperName]
 
   const coverageOptions = {
     ...config,
-  };
-  const coverageReport = new CoverageReport(coverageOptions);
-  coverageReport.cleanCache();
+  }
+
+  if (helperName === 'WebDriver') coverageOptions.coverageProvider = 'v8'
+
+  const coverageReport = new CoverageReport(coverageOptions)
+  coverageReport.cleanCache()
 
-  event.dispatcher.on(event.all.after, async () => {
-    output.print(`writing ${coverageOptions.outputDir}`);
-    await coverageReport.generate();
-  });
+  event.dispatcher.on(event.all.after, () => {
+    // Add coverage generation to recorder to ensure it completes before process exit
+    recorder.add(
+      'generate coverage report',
+      async () => {
+        try {
+          output.print(`writing ${coverageOptions.outputDir}`)
+          await coverageReport.generate()
+        } catch (error) {
+          output.print(`Failed to generate coverage report: ${error.message}`)
+          // Don't throw - coverage failure shouldn't fail tests
+        }
+      },
+      true,
+      false,
+    )
+  })
 
   //  we're going to try to "start" coverage before each step because this is
   //  when the browser is already up and is ready to start coverage.
   event.dispatcher.on(event.step.before, () => {
-    recorder.add('start coverage', async () => {
-      if (coverageRunning) {
-        return;
-      }
-      if (!helper.page || !helper.page.coverage) {
-        return;
-      }
-      coverageRunning = true;
-      logger('--> starting coverage <--');
-      await v8Helper.startCoverage(helper.page);
-    }, true);
-  });
+    recorder.add(
+      'start coverage',
+      async () => {
+        if (coverageRunning) {
+          return
+        }
+        if (!helper.page || !helper.page.coverage) {
+          return
+        }
+        coverageRunning = true
+        debug('--> starting coverage <--')
+        await v8Helper.startCoverage(helper.page)
+      },
+      true,
+    )
+  })
 
   // Save coverage data after every test run
-  event.dispatcher.on(event.test.after, (test) => {
-    recorder.add('take coverage', async () => {
-      if (!coverageRunning) {
-        return;
-      }
-      if (!helper.page || !helper.page.coverage) {
-        return;
-      }
-      coverageRunning = false;
-      logger('--> stopping coverage <--');
-      await v8Helper.takeCoverage(helper.page, coverageReport);
-    }, true);
-  });
+  event.dispatcher.on(event.test.after, test => {
+    recorder.add(
+      'take coverage',
+      async () => {
+        if (!coverageRunning) {
+          return
+        }
+        if (!helper.page || !helper.page.coverage) {
+          return
+        }
+        coverageRunning = false
+        debug('--> stopping coverage <--')
+        await v8Helper.takeCoverage(helper.page, coverageReport)
+      },
+      true,
+    )
+  })
 }

package/lib/plugin/customLocator.js

@@ -1,12 +1,12 @@
-import Locator from '../locator.js';
-import { xpathLocator } from '../utils.js';
+import Locator from '../locator.js'
+import { xpathLocator } from '../utils.js'
 
 const defaultConfig = {
   prefix: '$',
   attribute: 'data-test-id',
   strategy: 'xpath',
   showActual: false,
-};
+}
 
 /**
  * Creates a [custom locator](https://codecept.io/locators#custom-locators) by using special attributes in HTML.
@@ -111,34 +111,35 @@ const defaultConfig = {
  * I.click('=sign-up'); // matches => [data-qa=sign-up],[data-test=sign-up]
  * ```
  */
-export default (config) => {
-  config = { ...defaultConfig, ...config };
+export default function (config) {
+  config = { ...defaultConfig, ...config }
 
   Locator.addFilter((value, locatorObj) => {
-    if (typeof value !== 'string') return;
-    if (!value.startsWith(config.prefix)) return;
+    if (typeof value !== 'string') return
+    if (!value.startsWith(config.prefix)) return
 
-    if (!['String', 'Array'].includes(config.attribute.constructor.name)) return;
+    if (!['String', 'Array'].includes(config.attribute.constructor.name)) return
 
-    const val = value.substr(config.prefix.length);
+    const val = value.substr(config.prefix.length)
 
     if (config.strategy.toLowerCase() === 'xpath') {
-      locatorObj.value = `.//*[${
-        [].concat(config.attribute)
-          .map((attr) => `@${attr}=${xpathLocator.literal(val)}`)
-          .join(' or ')}]`;
-      locatorObj.type = 'xpath';
+      locatorObj.value = `.//*[${[]
+        .concat(config.attribute)
+        .map(attr => `@${attr}=${xpathLocator.literal(val)}`)
+        .join(' or ')}]`
+      locatorObj.type = 'xpath'
     }
 
     if (config.strategy.toLowerCase() === 'css') {
-      locatorObj.value = [].concat(config.attribute)
-        .map((attr) => `[${attr}=${val}]`)
-        .join(',');
-      locatorObj.type = 'css';
+      locatorObj.value = []
+        .concat(config.attribute)
+        .map(attr => `[${attr}=${val}]`)
+        .join(',')
+      locatorObj.type = 'css'
     }
 
     if (config.showActual) {
-      locatorObj.output = locatorObj.value;
+      locatorObj.output = locatorObj.value
     }
-  });
-};
+  })
+}

package/lib/plugin/customReporter.js

@@ -0,0 +1,53 @@
+import event from '../event.js'
+
+
+/**
+ * Sample custom reporter for CodeceptJS.
+ */
+export default function (config) {
+  event.dispatcher.on(event.hook.finished, hook => {
+    if (config.onHookFinished) {
+      config.onHookFinished(hook)
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    if (config.onTestBefore) {
+      config.onTestBefore(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.failed, (test, err) => {
+    if (config.onTestFailed) {
+      config.onTestFailed(test, err)
+    }
+  })
+
+  event.dispatcher.on(event.test.passed, test => {
+    if (config.onTestPassed) {
+      config.onTestPassed(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.skipped, test => {
+    if (config.onTestSkipped) {
+      config.onTestSkipped(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.finished, test => {
+    if (config.onTestFinished) {
+      config.onTestFinished(test)
+    }
+  })
+
+  event.dispatcher.on(event.all.result, result => {
+    if (config.onResult) {
+      config.onResult(result)
+    }
+
+    if (config.save) {
+      result.save()
+    }
+  })
+}

package/lib/plugin/enhancedRetryFailedStep.js

@@ -0,0 +1,99 @@
+import event from '../event.js'
+import recorder from '../recorder.js'
+import store from '../store.js'
+import output from '../output.js'
+import { RETRY_PRIORITIES } from '../retryCoordinator.js'
+
+const defaultConfig = {
+  retries: 3,
+  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
+  factor: 1.5,
+  ignoredSteps: [],
+}
+
+/**
+ * Enhanced retryFailedStep plugin that coordinates with other retry mechanisms
+ *
+ * This plugin provides step-level retries and coordinates with global retry settings
+ * to avoid conflicts and provide predictable behavior.
+ */
+export default config => {
+  config = Object.assign({}, defaultConfig, config)
+  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
+  const customWhen = config.when
+
+  let enableRetry = false
+
+  const when = err => {
+    if (!enableRetry) return false
+    if (store.debugMode) return false
+    if (!store.autoRetries) return false
+    if (customWhen) return customWhen(err)
+    return true
+  }
+  config.when = when
+
+  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 (ignored instanceof RegExp) {
+        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
+  })
+
+  event.dispatcher.on(event.step.finished, () => {
+    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.disableRetryFailedStep || test.disableRetryFailedStep) {
+      store.autoRetries = false
+      output.log(`[Step Retry] Disabled for test: ${test.title}`)
+      return // disable retry when a test is not active
+    }
+
+    // Check if step retries should be disabled due to higher priority scenario retries
+    const scenarioRetries = test.retries()
+    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
+    const scenarioPriority = test.opts.retryPriority || 0
+
+    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
+      // Scenario retries are configured with higher or equal priority
+      // Option 1: Disable step retries (conservative approach)
+      store.autoRetries = false
+      output.log(`[Step Retry] Deferred to scenario retries (${scenarioRetries} retries)`)
+      return
+
+      // Option 2: Reduce step retries to avoid excessive total retries
+      // const reducedStepRetries = Math.max(1, Math.floor(config.retries / scenarioRetries))
+      // config.retries = reducedStepRetries
+      // output.log(`[Step Retry] Reduced to ${reducedStepRetries} retries due to scenario retries (${scenarioRetries})`)
+    }
+
+    // this option is used to set the retries inside _before() block of helpers
+    store.autoRetries = true
+    test.opts.conditionalRetries = config.retries
+    test.opts.stepRetryPriority = stepRetryPriority
+
+    recorder.retry(config)
+
+    output.log(`[Step Retry] Enabled with ${config.retries} retries for test: ${test.title}`)
+  })
+
+  // Add coordination info for debugging
+  event.dispatcher.on(event.test.finished, test => {
+    if (test.state === 'passed' && test.opts.conditionalRetries && store.autoRetries) {
+      const stepRetries = test.opts.conditionalRetries || 0
+      const scenarioRetries = test.retries() || 0
+
+      if (stepRetries > 0 && scenarioRetries > 0) {
+        output.log(`[Retry Coordination] Test used both step retries (${stepRetries}) and scenario retries (${scenarioRetries})`)
+      }
+    }
+  })
+}