codeceptjs 3.6.4 → 3.6.5-beta.1

package/lib/plugin/customLocator.js

@@ -1,12 +1,12 @@
-const Locator = require('../locator');
-const { xpathLocator } = require('../utils');
+const Locator = require('../locator')
+const { xpathLocator } = require('../utils')
 
 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.
@@ -112,33 +112,34 @@ const defaultConfig = {
  * ```
  */
 module.exports = (config) => {
-  config = { ...defaultConfig, ...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)
+      locatorObj.value = []
+        .concat(config.attribute)
         .map((attr) => `[${attr}=${val}]`)
-        .join(',');
-      locatorObj.type = 'css';
+        .join(',')
+      locatorObj.type = 'css'
     }
 
     if (config.showActual) {
-      locatorObj.output = locatorObj.value;
+      locatorObj.output = locatorObj.value
     }
-  });
-};
+  })
+}

package/lib/plugin/debugErrors.js

@@ -1,13 +1,13 @@
-const Container = require('../container');
-const recorder = require('../recorder');
-const event = require('../event');
-const supportedHelpers = require('./standardActingHelpers');
-const { scanForErrorMessages } = require('../html');
-const { output } = require('..');
+const Container = require('../container')
+const recorder = require('../recorder')
+const event = require('../event')
+const supportedHelpers = require('./standardActingHelpers')
+const { scanForErrorMessages } = require('../html')
+const { output } = require('..')
 
 const defaultConfig = {
   errorClasses: ['error', 'warning', 'alert', 'danger'],
-};
+}
 
 /**
  * Prints errors found in HTML code after each failed test.
@@ -30,38 +30,38 @@ const defaultConfig = {
  *
  */
 module.exports = function (config = {}) {
-  const helpers = Container.helpers();
-  let helper;
+  const helpers = Container.helpers()
+  let helper
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   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
 
   event.dispatcher.on(event.test.failed, (test) => {
     recorder.add('HTML snapshot failed test', async () => {
       try {
-        const currentOutputLevel = output.level();
-        output.level(0);
-        const html = await helper.grabHTMLFrom('body');
-        output.level(currentOutputLevel);
+        const currentOutputLevel = output.level()
+        output.level(0)
+        const html = await helper.grabHTMLFrom('body')
+        output.level(currentOutputLevel)
 
-        if (!html) return;
+        if (!html) return
 
-        const errors = scanForErrorMessages(html, config.errorClasses);
+        const errors = scanForErrorMessages(html, config.errorClasses)
         if (errors.length) {
-          output.debug('Detected errors in HTML code');
-          errors.forEach((error) => output.debug(error));
-          test.artifacts.errors = errors;
+          output.debug('Detected errors in HTML code')
+          errors.forEach((error) => output.debug(error))
+          test.artifacts.errors = errors
         }
       } catch (err) {
         // not really needed
       }
-    });
-  });
-};
+    })
+  })
+}

package/lib/plugin/eachElement.js

@@ -1,14 +1,14 @@
-const output = require('../output');
-const store = require('../store');
-const recorder = require('../recorder');
-const container = require('../container');
-const event = require('../event');
-const Step = require('../step');
-const { isAsyncFunction } = require('../utils');
+const output = require('../output')
+const store = require('../store')
+const recorder = require('../recorder')
+const container = require('../container')
+const event = require('../event')
+const Step = require('../step')
+const { isAsyncFunction } = require('../utils')
 
 const defaultConfig = {
   registerGlobal: true,
-};
+}
 
 /**
  * Provides `eachElement` global function to iterate over found elements to perform actions on them.
@@ -69,59 +69,59 @@ const defaultConfig = {
  * @return {Promise<*> | undefined}
  */
 function eachElement(purpose, locator, fn) {
-  if (store.dryRun) return;
-  const helpers = Object.values(container.helpers());
+  if (store.dryRun) return
+  const helpers = Object.values(container.helpers())
 
-  const helper = helpers.filter(h => !!h._locate)[0];
+  const helper = helpers.filter((h) => !!h._locate)[0]
 
   if (!helper) {
-    throw new Error('No helper enabled with _locate method with returns a list of elements.');
+    throw new Error('No helper enabled with _locate method with returns a list of elements.')
   }
 
   if (!isAsyncFunction(fn)) {
-    throw new Error('Async function should be passed into each element');
+    throw new Error('Async function should be passed into each element')
   }
 
-  const step = new Step(helper, `${purpose || 'each element'} within "${locator}"`);
-  step.helperMethod = '_locate';
+  const step = new Step(helper, `${purpose || 'each element'} within "${locator}"`)
+  step.helperMethod = '_locate'
   // eachElement('select all users', 'locator', async (el) => {
-  event.dispatcher.emit(event.step.before, step);
+  event.dispatcher.emit(event.step.before, step)
 
   return recorder.add('register each element wrapper', async () => {
-    event.emit(event.step.started, step);
-    const els = await helper._locate(locator);
-    output.debug(`Found ${els.length} elements for each elements to iterate`);
+    event.emit(event.step.started, step)
+    const els = await helper._locate(locator)
+    output.debug(`Found ${els.length} elements for each elements to iterate`)
 
-    const errs = [];
-    let i = 0;
+    const errs = []
+    let i = 0
     for (const el of els) {
       try {
-        await fn(el, i);
+        await fn(el, i)
       } catch (err) {
-        output.error(`eachElement: failed operation on element #${i} ${el}`);
-        errs.push(err);
+        output.error(`eachElement: failed operation on element #${i} ${el}`)
+        errs.push(err)
       }
-      i++;
+      i++
     }
 
     if (errs.length) {
-      event.dispatcher.emit(event.step.after, step);
-      event.emit(event.step.failed, step, errs[0]);
-      event.emit(event.step.finished, step);
-      throw errs[0];
+      event.dispatcher.emit(event.step.after, step)
+      event.emit(event.step.failed, step, errs[0])
+      event.emit(event.step.finished, step)
+      throw errs[0]
     }
 
-    event.dispatcher.emit(event.step.after, step);
-    event.emit(event.step.passed, step, null);
-    event.emit(event.step.finished, step);
-  });
+    event.dispatcher.emit(event.step.after, step)
+    event.emit(event.step.passed, step, null)
+    event.emit(event.step.finished, step)
+  })
 }
 
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   if (config.registerGlobal) {
-    global.eachElement = eachElement;
+    global.eachElement = eachElement
   }
-  return eachElement;
-};
+  return eachElement
+}

package/lib/plugin/fakerTransform.js

@@ -1,5 +1,5 @@
-const { faker } = require('@faker-js/faker');
-const transform = require('../transform');
+const { faker } = require('@faker-js/faker')
+const transform = require('../transform')
 
 /**
  * Use the `@faker-js/faker` package to generate fake data inside examples on your gherkin tests
@@ -42,8 +42,8 @@ const transform = require('../transform');
 module.exports = function (config) {
   transform.addTransformerBeforeAll('gherkin.examples', (value) => {
     if (typeof value === 'string' && value.length > 0) {
-      return faker.helpers.fake(value);
+      return faker.helpers.fake(value)
     }
-    return value;
-  });
-};
+    return value
+  })
+}

package/lib/plugin/heal.js

@@ -1,14 +1,14 @@
-const debug = require('debug')('codeceptjs:heal');
-const colors = require('chalk');
-const recorder = require('../recorder');
-const event = require('../event');
-const output = require('../output');
-const heal = require('../heal');
-const store = require('../store');
+const debug = require('debug')('codeceptjs:heal')
+const colors = require('chalk')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
+const heal = require('../heal')
+const store = require('../store')
 
 const defaultConfig = {
   healLimit: 2,
-};
+}
 
 /**
  * Self-healing tests with AI.
@@ -31,88 +31,91 @@ const defaultConfig = {
 module.exports = function (config = {}) {
   if (store.debugMode && !process.env.DEBUG) {
     event.dispatcher.on(event.test.failed, () => {
-      output.plugin('heal', 'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode');
-    });
-    return;
+      output.plugin(
+        'heal',
+        'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode',
+      )
+    })
+    return
   }
 
-  let currentTest = null;
-  let currentStep = null;
-  let healedSteps = 0;
-  let caughtError;
-  let healTries = 0;
-  let isHealing = false;
+  let currentTest = null
+  let currentStep = null
+  let healedSteps = 0
+  let caughtError
+  let healTries = 0
+  let isHealing = false
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   event.dispatcher.on(event.test.before, (test) => {
-    currentTest = test;
-    healedSteps = 0;
-    caughtError = null;
-  });
+    currentTest = test
+    healedSteps = 0
+    caughtError = null
+  })
 
-  event.dispatcher.on(event.step.started, step => currentStep = step);
+  event.dispatcher.on(event.step.started, (step) => (currentStep = step))
 
   event.dispatcher.on(event.step.after, (step) => {
-    if (isHealing) return;
-    if (healTries >= config.healLimit) return; // out of limit
+    if (isHealing) return
+    if (healTries >= config.healLimit) return // out of limit
 
-    if (!heal.hasCorrespondingRecipes(step)) return;
+    if (!heal.hasCorrespondingRecipes(step)) return
 
     recorder.catchWithoutStop(async (err) => {
-      isHealing = true;
-      if (caughtError === err) throw err; // avoid double handling
-      caughtError = err;
+      isHealing = true
+      if (caughtError === err) throw err // avoid double handling
+      caughtError = err
 
-      const test = currentTest;
+      const test = currentTest
 
-      recorder.session.start('heal');
+      recorder.session.start('heal')
 
-      debug('Self-healing started', step.toCode());
+      debug('Self-healing started', step.toCode())
 
-      await heal.healStep(step, err, { test });
+      await heal.healStep(step, err, { test })
 
-      healTries++;
+      healTries++
 
       recorder.add('close healing session', () => {
-        recorder.reset();
-        recorder.session.restore('heal');
-        recorder.ignoreErr(err);
-      });
-      await recorder.promise();
+        recorder.reset()
+        recorder.session.restore('heal')
+        recorder.ignoreErr(err)
+      })
+      await recorder.promise()
 
-      isHealing = false;
-    });
-  });
+      isHealing = false
+    })
+  })
 
   event.dispatcher.on(event.all.result, () => {
-    if (!heal.fixes?.length) return;
+    if (!heal.fixes?.length) return
 
-    const { print } = output;
+    const { print } = output
 
-    print('');
-    print('===================');
-    print(colors.bold.green('Self-Healing Report:'));
+    print('')
+    print('===================')
+    print(colors.bold.green('Self-Healing Report:'))
 
-    print(`${colors.bold(heal.fixes.length)} ${heal.fixes.length === 1 ? 'step was' : 'steps were'} healed`);
+    print(`${colors.bold(heal.fixes.length)} ${heal.fixes.length === 1 ? 'step was' : 'steps were'} healed`)
 
-    const suggestions = heal.fixes.filter(fix => fix.recipe && heal.recipes[fix.recipe].suggest);
+    const suggestions = heal.fixes.filter((fix) => fix.recipe && heal.recipes[fix.recipe].suggest)
 
-    if (!suggestions.length) return;
+    if (!suggestions.length) return
 
-    let i = 1;
-    print('');
-    print('Suggested changes:');
-    print('');
+    let i = 1
+    print('')
+    print('Suggested changes:')
+    print('')
 
     for (const suggestion of suggestions) {
-      print(`${i}. To fix ${colors.bold.magenta(suggestion.test?.title)}`);
-      print('  Replace the failed code:', colors.gray(`(suggested by ${colors.bold(suggestion.recipe)})`));
-      print(colors.red(`- ${suggestion.step.toCode()}`));
-      print(colors.green(`+ ${suggestion.snippet}`));
-      print(suggestion.step.line());
-      print('');
-      i++;
+      print(`${i}. To fix ${colors.bold.magenta(suggestion.test?.title)}`)
+      print('  Replace the failed code:', colors.gray(`(suggested by ${colors.bold(suggestion.recipe)})`))
+      print(colors.red(`- ${suggestion.step.toCode()}`))
+      print(colors.green(`+ ${suggestion.snippet}`))
+      print(suggestion.step.line())
+      print('')
+      i++
     }
-  });
-};
+  })
+}

package/lib/plugin/pauseOnFail.js

@@ -1,5 +1,5 @@
-const event = require('../event');
-const pause = require('../pause');
+const event = require('../event')
+const pause = require('../pause')
 
 /**
  * Automatically launches [interactive pause](/basics/#pause) when a test fails.
@@ -22,17 +22,17 @@ const pause = require('../pause');
  *
  */
 module.exports = () => {
-  let failed = false;
+  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,21 +1,14 @@
-const event = require('../event');
-const recorder = require('../recorder');
-const container = require('../container');
-const { log } = require('../output');
+const event = require('../event')
+const recorder = require('../recorder')
+const container = require('../container')
+const { log } = require('../output')
 
 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.
@@ -84,45 +77,45 @@ const defaultConfig = {
  *
  */
 module.exports = (config) => {
-  config = Object.assign(defaultConfig, config);
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps);
-  const customWhen = config.when;
+  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;
-    const store = require('../store');
-    if (store.debugMode) return false;
-    if (customWhen) return customWhen(err);
-    return true;
-  };
-  config.when = when;
+    if (!enableRetry) return
+    const store = require('../store')
+    if (store.debugMode) 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') {
-      log('Info: RetryFailedStep plugin is disabled inside tryTo block');
-      return;
+      log('Info: RetryFailedStep plugin is disabled inside tryTo block')
+      return
     }
 
     // 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
-  });
+    enableRetry = true // enable retry for a step
+  })
 
   event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false;
-  });
+    enableRetry = false
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
-    if (test && test.disableRetryFailedStep) return; // disable retry when a test is not active
+    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);
-  });
-};
+    process.env.FAILED_STEP_RETRIES = config.retries
+    recorder.retry(config)
+  })
+}

package/lib/plugin/retryTo.js

@@ -1,10 +1,10 @@
-const recorder = require('../recorder');
-const { debug } = require('../output');
+const recorder = require('../recorder')
+const { debug } = require('../output')
 
 const defaultConfig = {
   registerGlobal: true,
   pollInterval: 200,
-};
+}
 
 /**
  *
@@ -74,54 +74,54 @@ const defaultConfig = {
  *
  */
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
   function retryTo(callback, maxTries, pollInterval = config.pollInterval) {
     return new Promise((done, reject) => {
-      let tries = 1;
+      let tries = 1
 
       function handleRetryException(err) {
-        recorder.throw(err);
-        reject(err);
+        recorder.throw(err)
+        reject(err)
       }
 
       const tryBlock = async () => {
-        tries++;
-        recorder.session.start(`retryTo ${tries}`);
+        tries++
+        recorder.session.start(`retryTo ${tries}`)
         try {
-          await callback(tries);
+          await callback(tries)
         } catch (err) {
-          handleRetryException(err);
+          handleRetryException(err)
         }
 
         // Call done if no errors
         recorder.add(() => {
-          recorder.session.restore(`retryTo ${tries}`);
-          done(null);
-        });
+          recorder.session.restore(`retryTo ${tries}`)
+          done(null)
+        })
 
         // Catch errors and retry
         recorder.session.catch((err) => {
-          recorder.session.restore(`retryTo ${tries}`);
+          recorder.session.restore(`retryTo ${tries}`)
           if (tries <= maxTries) {
-            debug(`Error ${err}... Retrying`);
-            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval));
+            debug(`Error ${err}... Retrying`)
+            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval))
           } else {
             // if maxTries reached
-            handleRetryException(err);
+            handleRetryException(err)
           }
-        });
-      };
+        })
+      }
 
-      recorder.add('retryTo', tryBlock).catch(err => {
-        console.error('An error occurred:', err);
-        done(null);
-      });
-    });
+      recorder.add('retryTo', tryBlock).catch((err) => {
+        console.error('An error occurred:', err)
+        done(null)
+      })
+    })
   }
 
   if (config.registerGlobal) {
-    global.retryTo = retryTo;
+    global.retryTo = retryTo
   }
 
-  return retryTo;
-};
+  return retryTo
+}