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

package/lib/plugin/commentStep.js

@@ -1,136 +0,0 @@
-const event = require('../event')
-const recorder = require('../recorder')
-const { MetaStep } = require('../step')
-
-let currentCommentStep
-
-const defaultGlobalName = '__'
-
-/**
- * Add descriptive nested steps for your tests:
- *
- * ```js
- * Scenario('project update test', async (I) => {
- *   __`Given`;
- *   const projectId = await I.have('project');
- *
- *   __`When`;
- *   projectPage.update(projectId, { title: 'new title' });
- *
- *   __`Then`;
- *   projectPage.open(projectId);
- *   I.see('new title', 'h1');
- * })
- * ```
- * Steps prefixed with `__` will be printed as nested steps in `--steps` output:
- *
- * ```
- *   Given
- *     I have "project"
- *   When
- *     projectPage update
- *   Then
- *     projectPage open
- *     I see "new title", "h1"
- * ```
- *
- * Also those steps will be exported to allure reports.
- *
- * This plugin can be used
- *
- * ### Config
- *
- * * `enabled` - (default: false) enable a plugin
- * * `registerGlobal` - (default: false) register `__` template literal function globally. You can override function global name by providing a name as a value.
- *
- * ### Examples
- *
- * Registering `__` globally:
- *
- * ```js
- * plugins: {
- *   commentStep: {
- *     enabled: true,
- *     registerGlobal: true
- *   }
- * }
- * ```
- *
- * Registering `Step` globally:
- * ```js
- * plugins: {
- *   commentStep: {
- *     enabled: true,
- *     registerGlobal: 'Step'
- *   }
- * }
- * ```
- *
- * Using only local function names:
- * ```js
- * plugins: {
- *   commentStep: {
- *     enabled: true
- *   }
- * }
- * ```
- * Then inside a test import a comment function from a plugin.
- * For instance, you can prepare Given/When/Then functions to use them inside tests:
- *
- * ```js
- * // inside a test
- * const step = codeceptjs.container.plugins('commentStep');
- *
- * const Given = () => step`Given`;
- * const When = () => step`When`;
- * const Then = () => step`Then`;
- * ```
- *
- * Scenario('project update test', async (I) => {
- *   Given();
- *   const projectId = await I.have('project');
- *
- *   When();
- *   projectPage.update(projectId, { title: 'new title' });
- *
- *   Then();
- *   projectPage.open(projectId);
- *   I.see('new title', 'h1');
- * });
- * ```
- */
-module.exports = function (config) {
-  event.dispatcher.on(event.test.started, () => {
-    currentCommentStep = null
-  })
-
-  event.dispatcher.on(event.step.started, (step) => {
-    if (currentCommentStep) {
-      const metaStep = getRootMetaStep(step)
-
-      if (metaStep !== currentCommentStep) {
-        metaStep.metaStep = currentCommentStep
-      }
-    }
-  })
-
-  if (config.registerGlobal) {
-    if (config.registerGlobal === true) {
-      config.registerGlobal = defaultGlobalName
-    }
-    global[config.registerGlobal] = setCommentString
-  }
-
-  return setCommentString
-}
-
-function getRootMetaStep(step) {
-  if (step.metaStep) return getRootMetaStep(step.metaStep)
-  return step
-}
-
-function setCommentString(string) {
-  recorder.add('set comment metastep', () => {
-    currentCommentStep = new MetaStep(String.raw(string), '')
-  })
-}

package/lib/plugin/debugErrors.js

@@ -1,67 +0,0 @@
-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.
- *
- * It scans HTML and searches for elements with error classes.
- * If an element found prints a text from it to console and adds as artifact to the test.
- *
- * Enable this plugin in config:
- *
- * ```js
- * plugins: {
- *  debugErrors: {
- *   enabled: true,
- * }
- * ```
- *
- * Additional config options:
- *
- * * `errorClasses` - list of classes to search for errors (default: `['error', 'warning', 'alert', 'danger']`)
- *
- */
-module.exports = 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) => {
-    recorder.add('HTML snapshot failed test', async () => {
-      try {
-        const currentOutputLevel = output.level()
-        output.level(0)
-        const html = await helper.grabHTMLFrom('body')
-        output.level(currentOutputLevel)
-
-        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))
-          test.artifacts.errors = errors
-        }
-      } catch (err) {
-        // not really needed
-      }
-    })
-  })
-}

package/lib/plugin/eachElement.js

@@ -1,127 +0,0 @@
-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.
- *
- * `eachElement` takes following args:
- * * `purpose` - the goal of an action. A comment text that will be displayed in output.
- * * `locator` - a CSS/XPath locator to match elements
- * * `fn(element, index)` - **asynchronous** function which will be executed for each matched element.
- *
- * Example of usage:
- *
- * ```js
- * // this example works with Playwright and Puppeteer helper
- * await eachElement('click all checkboxes', 'form input[type=checkbox]', async (el) => {
- *   await el.click();
- * });
- * ```
- * Click odd elements:
- *
- * ```js
- * // this example works with Playwright and Puppeteer helper
- * await eachElement('click odd buttons', '.button-select', async (el, index) => {
- *   if (index % 2) await el.click();
- * });
- * ```
- *
- * Check all elements for visibility:
- *
- * ```js
- * // this example works with Playwright and Puppeteer helper
- * const assert = require('assert');
- * await eachElement('check all items are visible', '.item', async (el) => {
- *   assert(await el.isVisible());
- * });
- * ```
- * This method works with WebDriver, Playwright, Puppeteer, Appium helpers.
- *
- * Function parameter `el` represents a matched element.
- * Depending on a helper API of `el` can be different. Refer to API of corresponding browser testing engine for a complete API list:
- *
- * * [Playwright ElementHandle](https://playwright.dev/docs/api/class-elementhandle)
- * * [Puppeteer](https://pptr.dev/#?product=Puppeteer&show=api-class-elementhandle)
- * * [webdriverio element](https://webdriver.io/docs/api)
- *
- * #### Configuration
- *
- * * `registerGlobal` - to register `eachElement` function globally, true by default
- *
- * If `registerGlobal` is false you can use eachElement from the plugin:
- *
- * ```js
- * const eachElement = codeceptjs.container.plugins('eachElement');
- * ```
- *
- * @param {string}  purpose
- * @param {CodeceptJS.LocatorOrString}  locator
- * @param {Function}  fn
- * @return {Promise<*> | undefined}
- */
-function eachElement(purpose, locator, fn) {
-  if (store.dryRun) return
-  const helpers = Object.values(container.helpers())
-
-  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.')
-  }
-
-  if (!isAsyncFunction(fn)) {
-    throw new Error('Async function should be passed into each element')
-  }
-
-  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)
-
-  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`)
-
-    const errs = []
-    let i = 0
-    for (const el of els) {
-      try {
-        await fn(el, i)
-      } catch (err) {
-        output.error(`eachElement: failed operation on element #${i} ${el}`)
-        errs.push(err)
-      }
-      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.passed, step, null)
-    event.emit(event.step.finished, step)
-  })
-}
-
-module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
-
-  if (config.registerGlobal) {
-    global.eachElement = eachElement
-  }
-  return eachElement
-}

package/lib/plugin/fakerTransform.js

@@ -1,49 +0,0 @@
-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
- *
- * #### Usage
- *
- * To start please install `@faker-js/faker` package
- *
- * ```
- * npm install -D @faker-js/faker
- * ```
- *
- * ```
- * yarn add -D @faker-js/faker
- * ```
- *
- * Add this plugin to config file:
- *
- * ```js
- * plugins: {
- *    fakerTransform: {
- *      enabled: true
- *    }
- * }
- * ```
- *
- * Add the faker API using a mustache string format inside examples tables in your gherkin scenario outline
- *
- * ```feature
- * Scenario Outline: ...
- *             Given ...
- *              When ...
- *              Then ...
- *         Examples:
- *   | productName          | customer              | email              | anythingMore |
- *   | {{commerce.product}} | Dr. {{name.findName}} | {{internet.email}} | staticData   |
- * ```
- *
- */
-module.exports = function (config) {
-  transform.addTransformerBeforeAll('gherkin.examples', (value) => {
-    if (typeof value === 'string' && value.length > 0) {
-      return faker.helpers.fake(value)
-    }
-    return value
-  })
-}

package/lib/plugin/retryTo.js

@@ -1,127 +0,0 @@
-const recorder = require('../recorder')
-const { debug } = require('../output')
-
-const defaultConfig = {
-  registerGlobal: true,
-  pollInterval: 200,
-}
-
-/**
- *
- *
- * Adds global `retryTo` which retries steps a few times before failing.
- *
- * Enable this plugin in `codecept.conf.js` (enabled by default for new setups):
- *
- * ```js
- * plugins: {
- *   retryTo: {
- *     enabled: true
- *   }
- * }
- * ```
- *
- * Use it in your tests:
- *
- * ```js
- * // retry these steps 5 times before failing
- * await retryTo((tryNum) => {
- *   I.switchTo('#editor frame');
- *   I.click('Open');
- *   I.see('Opened')
- * }, 5);
- * ```
- * Set polling interval as 3rd argument (200ms by default):
- *
- * ```js
- * // retry these steps 5 times before failing
- * await retryTo((tryNum) => {
- *   I.switchTo('#editor frame');
- *   I.click('Open');
- *   I.see('Opened')
- * }, 5, 100);
- * ```
- *
- * Default polling interval can be changed in a config:
- *
- * ```js
- * plugins: {
- *   retryTo: {
- *     enabled: true,
- *     pollInterval: 500,
- *   }
- * }
- * ```
- *
- * Disables retryFailedStep plugin for steps inside a block;
- *
- * Use this plugin if:
- *
- * * you need repeat a set of actions in flaky tests
- * * iframe was not rendered and you need to retry switching to it
- *
- *
- * #### Configuration
- *
- * * `pollInterval` - default interval between retries in ms. 200 by default.
- * * `registerGlobal` - to register `retryTo` function globally, true by default
- *
- * If `registerGlobal` is false you can use retryTo from the plugin:
- *
- * ```js
- * const retryTo = codeceptjs.container.plugins('retryTo');
- * ```
- *
- */
-module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
-  function retryTo(callback, maxTries, pollInterval = config.pollInterval) {
-    return new Promise((done, reject) => {
-      let tries = 1
-
-      function handleRetryException(err) {
-        recorder.throw(err)
-        reject(err)
-      }
-
-      const tryBlock = async () => {
-        tries++
-        recorder.session.start(`retryTo ${tries}`)
-        try {
-          await callback(tries)
-        } catch (err) {
-          handleRetryException(err)
-        }
-
-        // Call done if no errors
-        recorder.add(() => {
-          recorder.session.restore(`retryTo ${tries}`)
-          done(null)
-        })
-
-        // Catch errors and retry
-        recorder.session.catch((err) => {
-          recorder.session.restore(`retryTo ${tries}`)
-          if (tries <= maxTries) {
-            debug(`Error ${err}... Retrying`)
-            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval))
-          } else {
-            // if maxTries reached
-            handleRetryException(err)
-          }
-        })
-      }
-
-      recorder.add('retryTo', tryBlock).catch((err) => {
-        console.error('An error occurred:', err)
-        done(null)
-      })
-    })
-  }
-
-  if (config.registerGlobal) {
-    global.retryTo = retryTo
-  }
-
-  return retryTo
-}