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

package/lib/listener/retry.js

@@ -1,68 +0,0 @@
-import * as event from '../event.js';
-import * as output from '../output.js';
-import Config from '../config.js';
-import { isNotSet } from '../utils.js';
-
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite'];
-
-export default function () {
-  event.dispatcher.on(event.suite.before, (suite) => {
-    let retryConfig = Config.get('retry');
-    if (!retryConfig) return;
-
-    if (Number.isInteger(+retryConfig)) {
-      // is number
-      const retryNum = +retryConfig;
-      output.output.log(`Retries: ${retryNum}`);
-      suite.retries(retryNum);
-      return;
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig];
-    }
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!suite.title.includes(config.grep)) continue;
-      }
-
-      hooks.filter(hook => !!config[hook]).forEach((hook) => {
-        if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook];
-      });
-
-      if (config.Feature) {
-        if (isNotSet(suite.retries())) suite.retries(config.Feature);
-      }
-
-      output.output.log(`Retries: ${JSON.stringify(config)}`);
-    }
-  });
-
-  event.dispatcher.on(event.test.before, (test) => {
-    let retryConfig = Config.get('retry');
-    if (!retryConfig) return;
-
-    if (Number.isInteger(+retryConfig)) {
-      if (test.retries() === -1) test.retries(retryConfig);
-      return;
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig];
-    }
-
-    retryConfig = retryConfig.filter(config => !!config.Scenario);
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!test.fullTitle().includes(config.grep)) continue;
-      }
-
-      if (config.Scenario) {
-        if (test.retries() === -1) test.retries(config.Scenario);
-        output.output.log(`Retries: ${config.Scenario}`);
-      }
-    }
-  });
-}

package/lib/listener/timeout.js

@@ -1,109 +0,0 @@
-import * as event from '../event.js';
-import * as output from '../output.js';
-import recorder from '../recorder.js';
-import Config from '../config.js';
-import { timeouts } from '../store.js';
-import { Step } from '../step.js';
-
-export default function () {
-  let timeout;
-  let suiteTimeout = [];
-  let currentTest;
-  let currentTimeout;
-
-  if (!timeouts) {
-    console.log('Timeouts were disabled');
-    return;
-  }
-
-  event.dispatcher.on(event.suite.before, (suite) => {
-    suiteTimeout = [];
-    let timeoutConfig = Config.get('timeout');
-
-    if (timeoutConfig) {
-      if (!Number.isNaN(+timeoutConfig)) {
-        checkForSeconds(timeoutConfig);
-        suiteTimeout.push(timeoutConfig);
-      }
-
-      if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig];
-      }
-
-      for (const config of timeoutConfig.filter(c => !!c.Feature)) {
-        if (config.grep) {
-          if (!suite.title.includes(config.grep)) continue;
-        }
-        suiteTimeout.push(config.Feature);
-      }
-    }
-
-    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout);
-    output.output.log(`Timeouts: ${suiteTimeout}`);
-  });
-
-  event.dispatcher.on(event.test.before, (test) => {
-    currentTest = test;
-    let testTimeout = null;
-
-    let timeoutConfig = Config.get('timeout');
-
-    if (typeof timeoutConfig === 'object' || Array.isArray(timeoutConfig)) {
-      if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig];
-      }
-
-      for (const config of timeoutConfig.filter(c => !!c.Scenario)) {
-        console.log('Test Timeout', config, test.title.includes(config.grep));
-        if (config.grep) {
-          if (!test.title.includes(config.grep)) continue;
-        }
-        testTimeout = config.Scenario;
-      }
-    }
-
-    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1];
-    if (!timeout) return;
-    currentTimeout = timeout;
-    output.output.debug(`Test Timeout: ${timeout}s`);
-    timeout *= 1000;
-  });
-
-  event.dispatcher.on(event.test.passed, (test) => {
-    currentTest = null;
-  });
-
-  event.dispatcher.on(event.test.failed, (test) => {
-    currentTest = null;
-  });
-
-  event.dispatcher.on(event.step.before, (step) => {
-    if (typeof timeout !== 'number') return;
-
-    if (timeout < 0) {
-      step.setTimeout(0.01, Step.TIMEOUT_ORDER.testOrSuite);
-    } else {
-      step.setTimeout(timeout, Step.TIMEOUT_ORDER.testOrSuite);
-    }
-  });
-
-  event.dispatcher.on(event.step.finished, (step) => {
-    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration;
-
-    if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
-      if (currentTest && currentTest.callback) {
-        recorder.reset();
-        // replace mocha timeout with custom timeout
-        currentTest.timeout(0);
-        currentTest.callback(new Error(`Timeout ${currentTimeout}s exceeded (with Before hook)`));
-        currentTest.timedOut = true;
-      }
-    }
-  });
-}
-
-function checkForSeconds(timeout) {
-  if (timeout >= 1000) {
-    console.log(`Warning: Timeout was set to ${timeout}secs.\nGlobal timeout should be specified in seconds.`);
-  }
-}

package/lib/mochaFactory.js

@@ -1,110 +0,0 @@
-import Mocha from 'mocha';
-import fs from 'fs';
-import reporter from './cli.js';
-import gherkinParser from './interfaces/gherkin.js';
-import * as output from './output.js';
-import { genTestId } from './utils.js';
-import ConnectionRefused from './helper/errors/ConnectionRefused.js';
-
-import scenarioUi from './ui.js';
-
-let mocha;
-
-export class MochaFactory {
-  static create(config, opts) {
-    mocha = new Mocha(Object.assign(config, opts));
-    output.output.process(opts.child);
-    mocha.ui(scenarioUi);
-
-    Mocha.Runner.prototype.uncaught = function (err) {
-      if (err) {
-        if (err.toString().indexOf('ECONNREFUSED') >= 0) {
-          err = new ConnectionRefused(err);
-        }
-        output.output.error(err);
-        output.output.print(err.stack);
-        process.exit(1);
-      }
-      output.output.error('Uncaught undefined exception');
-      process.exit(1);
-    };
-
-    mocha.loadFiles = (fn) => {
-      // load features
-      if (mocha.suite.suites.length === 0) {
-        mocha.files
-          .filter(file => file.match(/\.feature$/))
-          .forEach(file => mocha.suite.addSuite(gherkinParser(fs.readFileSync(file, 'utf8'), file)));
-
-        // remove feature files
-        mocha.files = mocha.files.filter(file => !file.match(/\.feature$/));
-
-        Mocha.prototype.loadFiles.call(mocha, fn);
-
-        // add ids for each test and check uniqueness
-        const dupes = [];
-        let missingFeatureInFile = [];
-        const seenTests = [];
-        mocha.suite.eachTest(test => {
-          test.uid = genTestId(test);
-
-          const name = test.fullTitle();
-          if (seenTests.includes(test.uid)) {
-            dupes.push(name);
-          }
-          seenTests.push(test.uid);
-
-          if (name.slice(0, name.indexOf(':')) === '') {
-            missingFeatureInFile.push(test.file);
-          }
-        });
-        if (dupes.length) {
-          // ideally this should be no-op and throw (breaking change)...
-          output.output.error(`Duplicate test names detected - Feature + Scenario name should be unique:\n${dupes.join('\n')}`);
-        }
-
-        if (missingFeatureInFile.length) {
-          missingFeatureInFile = [...new Set(missingFeatureInFile)];
-          output.output.error(`Missing Feature section in:\n${missingFeatureInFile.join('\n')}`);
-        }
-      }
-    };
-
-    const presetReporter = opts.reporter || config.reporter;
-    // use standard reporter
-    if (!presetReporter) {
-      mocha.reporter(reporter, opts);
-      return mocha;
-    }
-
-    // load custom reporter with options
-    const reporterOptions = Object.assign(config.reporterOptions || {});
-
-    if (opts.reporterOptions !== undefined) {
-      opts.reporterOptions.split(',').forEach((opt) => {
-        const L = opt.split('=');
-        if (L.length > 2 || L.length === 0) {
-          throw new Error(`invalid reporter option '${opt}'`);
-        } else if (L.length === 2) {
-          reporterOptions[L[0]] = L[1];
-        } else {
-          reporterOptions[L[0]] = true;
-        }
-      });
-    }
-
-    const attributes = Object.getOwnPropertyDescriptor(reporterOptions, 'codeceptjs-cli-reporter');
-    if (reporterOptions['codeceptjs-cli-reporter'] && attributes) {
-      Object.defineProperty(
-        reporterOptions,
-        'codeceptjs/lib/cli',
-        attributes,
-      );
-      delete reporterOptions['codeceptjs-cli-reporter'];
-    }
-
-    // custom reporters
-    mocha.reporter(presetReporter, reporterOptions);
-    return mocha;
-  }
-}

package/lib/plugin/allure.js

@@ -1,15 +0,0 @@
-export default () => {
-  console.log('Allure plugin was moved to @codeceptjs/allure-legacy. Please install it and update your config');
-  console.log();
-  console.log('npm install @codeceptjs/allure-legacy --save-dev');
-  console.log();
-  console.log('Then update your config to use it:');
-  console.log();
-  console.log('plugins: {');
-  console.log('  allure: {');
-  console.log('    enabled: true,');
-  console.log('    require: \'@codeceptjs/allure-legacy\',');
-  console.log('  }');
-  console.log('}');
-  console.log();
-};

package/lib/plugin/commentStep.js

@@ -1,136 +0,0 @@
-import * as event from '../event.js';
-import recorder from '../recorder.js';
-import { MetaStep } from '../step.js';
-
-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');
- * });
- * ```
- */
-export default function commentStep(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 @@
-import Container from '../container.js';
-import recorder from '../recorder.js';
-import * as event from '../event.js';
-import supportedHelpers from './standardActingHelpers.js';
-import { scanForErrorMessages } from '../html';
-import { output } from '..';
-
-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']`)
- *
- */
-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) => {
-    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 @@
-import * as output from '../output.js';
-import { store } from '../store.js';
-import recorder from '../recorder.js';
-import container from '../container.js';
-import * as event from '../event.js';
-import { Step } from '../step.js';
-import { isAsyncFunction } from '../utils.js';
-
-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.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.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.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);
-  });
-}
-
-export default function (config) {
-  config = Object.assign(defaultConfig, config);
-
-  if (config.registerGlobal) {
-    global.eachElement = eachElement;
-  }
-  return eachElement;
-}

package/lib/plugin/fakerTransform.js

@@ -1,49 +0,0 @@
-import { faker } from '@faker-js/faker';
-import transform from '../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   |
- * ```
- *
- */
-export default function (config) {
-  transform.addTransformerBeforeAll('gherkin.examples', (value) => {
-    if (typeof value === 'string' && value.length > 0) {
-      return faker.helpers.fake(value);
-    }
-    return value;
-  });
-}