codeceptjs 3.2.0 → 3.3.0-beta.1

package/lib/helper/extras/Console.js

@@ -14,6 +14,14 @@ class Console {
     this._logEntries = [];
   }
 
+  includes(msg) {
+    const prev = this._logEntries[this._logEntries.length - 1];
+    if (!prev) return false;
+    const text = msg.text && msg.text() || msg._text || '';
+    const prevText = prev.text && prev.text() || prev._text || '';
+    return text === prevText;
+  }
+
   add(entry) {
     if (Array.isArray(entry)) {
       this._logEntries = this._logEntries.concat(entry);

package/lib/helper/extras/PlaywrightRestartOpts.js

@@ -0,0 +1,35 @@
+const RESTART_OPTS = {
+  session: 'keep',
+  browser: true,
+  context: false,
+};
+
+let restarts = null;
+
+module.exports = {
+
+  setRestartStrategy(options) {
+    const { restart } = options;
+    const stringOpts = Object.keys(RESTART_OPTS);
+
+    if (stringOpts.includes(restart)) {
+      return restarts = restart;
+    }
+
+    restarts = Object.keys(RESTART_OPTS).find(key => RESTART_OPTS[key] === restart);
+
+    console.log(restarts);
+
+    if (restarts === null || restarts === undefined) throw new Error('No restart strategy set, use the following values for restart: session, context, browser');
+  },
+
+  restartsSession() {
+    return restarts === 'session';
+  },
+  restartsContext() {
+    return restarts === 'context';
+  },
+  restartsBrowser() {
+    return restarts === 'browser';
+  },
+};

package/lib/interfaces/bdd.js

@@ -25,7 +25,8 @@ const parameterTypeRegistry = new ParameterTypeRegistry();
 const matchStep = (step) => {
   for (const stepName in steps) {
     if (stepName.indexOf('/') === 0) {
-      const res = step.match(new RegExp(stepName.slice(1, -1)));
+      const regExpArr = stepName.match(new RegExp('^/(.*?)/([gimy]*)$')) || [];
+      const res = step.match(new RegExp(regExpArr[1], regExpArr[2]));
       if (res) {
         const fn = steps[stepName];
         fn.params = res.slice(1);
@@ -56,6 +57,7 @@ module.exports = {
   Given: addStep,
   When: addStep,
   Then: addStep,
+  And: addStep,
   matchStep,
   getSteps,
   clearSteps,

package/lib/listener/timeout.js

@@ -3,6 +3,7 @@ const output = require('../output');
 const recorder = require('../recorder');
 const Config = require('../config');
 const { timeouts } = require('../store');
+const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER;
 
 module.exports = function () {
   let timeout;
@@ -49,14 +50,14 @@ module.exports = function () {
     if (typeof timeout !== 'number') return;
 
     if (timeout < 0) {
-      step.totalTimeout = 0.01;
+      step.setTimeout(0.01, TIMEOUT_ORDER.testOrSuite);
     } else {
-      step.totalTimeout = timeout;
+      step.setTimeout(timeout, TIMEOUT_ORDER.testOrSuite);
     }
   });
 
   event.dispatcher.on(event.step.finished, (step) => {
-    timeout -= step.duration;
+    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration;
 
     if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
       if (currentTest && currentTest.callback) {

package/lib/plugin/allure.js

@@ -64,6 +64,18 @@ const defaultConfig = {
  * * `addAttachment(name, buffer, type)` - add an attachment to current test / suite
  * * `addLabel(name, value)` - adds a label to current test
  * * `addParameter(kind, name, value)` - adds a parameter to current test
+ * * `createStep(name, stepFunc)` - create a step, stepFunc could consist an attachment
+ * Example of usage:
+ * ```js
+ *     allure.createStep('New created step', () => {
+ *       allure.addAttachment(
+ *         'Request params',
+ *         '{"clientId":123, "name":"Tom", "age":29}',
+ *         'application/json'
+ *       );
+ *     });
+ * ```
+ * ![Created Step Image](https://user-images.githubusercontent.com/63167966/139339384-e6e70a62-3638-406d-a224-f32473071428.png)
  * * `severity(value)` - adds severity label
  * * `epic(value)` - adds epic label
  * * `feature(value)` - adds feature label

package/lib/plugin/autoLogin.js

@@ -37,7 +37,7 @@ const defaultConfig = {
  * ```js
  * // inside a test file
  * // use login to inject auto-login function
- * Before(login => {
+ * Before(({ login }) => {
  *    login('user'); // login using user session
  * });
  *

package/lib/plugin/eachElement.js

@@ -0,0 +1,127 @@
+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/retryFailedStep.js

@@ -2,7 +2,7 @@ const event = require('../event');
 const recorder = require('../recorder');
 
 const defaultConfig = {
-  retries: 5,
+  retries: 3,
   defaultIgnoredSteps: [
     'amOnPage',
     'wait*',
@@ -11,6 +11,7 @@ const defaultConfig = {
     'run*',
     'have*',
   ],
+  factor: 1.5,
   ignoredSteps: [],
 };
 
@@ -36,9 +37,9 @@ const defaultConfig = {
  *
  * #### Configuration:
  *
- * * `retries` - number of retries (by default 5),
+ * * `retries` - number of retries (by default 3),
  * * `when` - function, when to perform a retry (accepts error as parameter)
- * * `factor` - The exponential factor to use. Default is 2.
+ * * `factor` - The exponential factor to use. Default is 1.5.
  * * `minTimeout` - The number of milliseconds before starting the first retry. Default is 1000.
  * * `maxTimeout` - The maximum number of milliseconds between two retries. Default is Infinity.
  * * `randomize` - Randomizes the timeouts by multiplying with a factor between 1 to 2. Default is false.

package/lib/plugin/stepTimeout.js

@@ -1,8 +1,9 @@
 const event = require('../event');
+const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER;
 
 const defaultConfig = {
   timeout: 150,
-  force: false,
+  overrideStepLimits: false,
   noTimeoutSteps: [
     'amOnPage',
     'wait*',
@@ -33,7 +34,7 @@ const defaultConfig = {
  * #### Configuration:
  *
  * * `timeout` - global step timeout, default 150 seconds
- * * `force` - whether to use timeouts set in plugin config to override step timeouts set in code with I.limitTime(x).action(...), default false
+ * * `overrideStepLimits` - whether to use timeouts set in plugin config to override step timeouts set in code with I.limitTime(x).action(...), default false
  * * `noTimeoutSteps` - an array of steps with no timeout. Default:
  *     * `amOnPage`
  *     * `wait*`
@@ -49,7 +50,7 @@ const defaultConfig = {
  * plugins: {
  *     stepTimeout: {
  *         enabled: true,
- *         force: true,
+ *         overrideStepLimits: true,
  *         noTimeoutSteps: [
  *           'scroll*', // ignore all scroll steps
  *           /Cookie/, // ignore all steps with a Cookie in it (by regexp)
@@ -85,6 +86,6 @@ module.exports = (config) => {
       }
     }
     stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout;
-    step.totalTimeout = stepTimeout * 1000;
+    step.setTimeout(stepTimeout * 1000, config.overrideStepLimits ? TIMEOUT_ORDER.stepTimeoutHard : TIMEOUT_ORDER.stepTimeoutSoft);
   });
 };

package/lib/plugin/tryTo.js

@@ -42,6 +42,12 @@ const defaultConfig = {
  * #### Multiple Conditional Assertions
  *
  * ```js
+ *
+ * Add assert requires first:
+ * ```js
+ * const assert = require('assert');
+ * ```
+ * Then use the assert:
  * const result1 = await tryTo(() => I.see('Hello, user'));
  * const result2 = await tryTo(() => I.seeElement('.welcome'));
  * assert.ok(result1 && result2, 'Assertions were not succesful');

package/lib/recorder.js

@@ -178,7 +178,8 @@ module.exports = {
     if (process.env.DEBUG) debug(`${currentQueue()}Queued | ${taskName}`);
 
     return promise = Promise.resolve(promise).then((res) => {
-      const retryOpts = this.retries.slice(-1).pop();
+      // prefer options for non-conditional retries
+      const retryOpts = this.retries.sort((r1, r2) => r1.when && !r2.when).slice(-1).pop();
       // no retries or unnamed tasks
       if (!retryOpts || !taskName || !retry) {
         const [promise, timer] = getTimeoutPromise(timeout, taskName);

package/lib/step.js

@@ -13,6 +13,27 @@ const STACK_LINE = 4;
  * @param {string} name
  */
 class Step {
+  static get TIMEOUT_ORDER() {
+    return {
+      /**
+       * timeouts set with order below zero only override timeouts of higher order if their value is smaller
+       */
+      testOrSuite: -5,
+      /**
+       * 0-9 - designated for override of timeouts set from code, 5 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=true
+       */
+      stepTimeoutHard: 5,
+      /**
+       * 10-19 - designated for timeouts set from code, 15 is order of I.setTimeout(t) operation
+       */
+      codeLimitTime: 15,
+      /**
+       * 20-29 - designated for timeout settings which could be overriden in tests code, 25 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=false
+       */
+      stepTimeoutSoft: 25,
+    };
+  }
+
   constructor(helper, name) {
     /** @member {string} */
     this.actor = 'I'; // I = actor
@@ -38,8 +59,40 @@ class Step {
     this.metaStep = undefined;
     /** @member {string} */
     this.stack = '';
-    /** @member {number} */
-    this.totalTimeout = undefined;
+
+    const timeouts = new Map();
+    /**
+     * @method
+     * @returns {number|undefined}
+     */
+    this.getTimeout = function () {
+      let totalTimeout;
+      // iterate over all timeouts starting from highest values of order
+      new Map([...timeouts.entries()].sort().reverse()).forEach((timeout, order) => {
+        if (timeout !== undefined && (
+          // when orders >= 0 - timeout value overrides those set with higher order elements
+          order >= 0
+
+          // when `order < 0 && totalTimeout === undefined` - timeout is used when nothing is set by elements with higher order
+          || totalTimeout === undefined
+
+          // when `order < 0` - timeout overrides higher values of timeout or 'no timeout' (totalTimeout === 0) set by elements with higher order
+          || timeout > 0 && (timeout < totalTimeout || totalTimeout === 0)
+        )) {
+          totalTimeout = timeout;
+        }
+      });
+      return totalTimeout;
+    };
+    /**
+     * @method
+     * @param {number} timeout - timeout in milliseconds or 0 if no timeout
+     * @param {number} order - order defines the priority of timeout, timeouts set with lower order override those set with higher order.
+     *                         When order below 0 value of timeout only override if new value is lower
+     */
+    this.setTimeout = function (timeout, order) {
+      timeouts.set(order, timeout);
+    };
 
     this.setTrace();
   }
@@ -231,6 +284,8 @@ class MetaStep extends Step {
   }
 }
 
+Step.TIMEOUTS = {};
+
 /** @type {Class<MetaStep>} */
 Step.MetaStep = MetaStep;
 

package/lib/utils.js

@@ -431,3 +431,23 @@ module.exports.modifierKeys = modifierKeys;
 module.exports.isModifierKey = function (key) {
   return modifierKeys.includes(key);
 };
+
+module.exports.requireWithFallback = function (...packages) {
+  const exists = function (pkg) {
+    try {
+      require.resolve(pkg);
+    } catch (e) {
+      return false;
+    }
+
+    return true;
+  };
+
+  for (const pkg of packages) {
+    if (exists(pkg)) {
+      return require(pkg);
+    }
+  }
+
+  throw new Error(`Cannot find modules ${packages.join(',')}`);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.2.0",
+  "version": "3.3.0-beta.1",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -59,6 +59,7 @@
     "allure-js-commons": "^1.3.2",
     "arrify": "^2.0.1",
     "axios": "^0.21.1",
+    "chai-deep-match": "^1.2.1",
     "chalk": "^4.1.0",
     "commander": "^2.20.3",
     "cross-spawn": "^7.0.3",
@@ -72,6 +73,7 @@
     "gherkin": "^5.1.0",
     "glob": "^6.0.1",
     "inquirer": "^6.5.2",
+    "joi": "^17.6.0",
     "js-beautify": "^1.11.0",
     "lodash.clonedeep": "^4.5.0",
     "lodash.merge": "^4.6.2",
@@ -97,7 +99,7 @@
     "@wdio/selenium-standalone-service": "^5.16.10",
     "@wdio/utils": "^5.23.0",
     "apollo-server-express": "^2.19.0",
-    "chai": "^3.4.1",
+    "chai": "^3.5.0",
     "chai-as-promised": "^5.2.0",
     "chai-subset": "^1.6.0",
     "contributor-faces": "^1.0.3",
@@ -110,7 +112,7 @@
     "eslint-plugin-mocha": "^6.3.0",
     "expect": "^26.6.2",
     "express": "^4.17.1",
-    "faker": "^5.5.1",
+    "faker": "5.5.3",
     "form-data": "^3.0.0",
     "graphql": "^14.6.0",
     "husky": "^4.3.5",
@@ -120,7 +122,7 @@
     "mocha-parallel-tests": "^2.3.0",
     "nightmare": "^3.0.2",
     "nodemon": "^1.19.4",
-    "playwright": "^1.9.1",
+    "playwright": "^1.18.1",
     "puppeteer": "^10.0.0",
     "qrcode-terminal": "^0.12.0",
     "rosie": "^1.6.0",

package/translations/pt-BR.js

@@ -1,5 +1,13 @@
 module.exports = {
   I: 'Eu',
+  contexts: {
+    Feature: 'Funcionalidade',
+    Scenario: 'Cenário',
+    Before: 'Antes',
+    After: 'Depois',
+    BeforeSuite: 'AntesDaSuite',
+    AfterSuite: 'DepoisDaSuite',
+  },
   actions: {
     amOutsideAngularApp: 'naoEstouEmAplicacaoAngular',
     amInsideAngularApp: 'estouNaAplicacaoAngular',

package/typings/index.d.ts

@@ -2,6 +2,8 @@
 /// <reference path="./types.d.ts" />
 /// <reference types="webdriverio" />
 /// <reference path="./Mocha.d.ts" />
+/// <reference types="joi" />
+/// <reference types="playwright" />
 
 declare namespace CodeceptJS {
   type WithTranslation<T> = T &
@@ -10,6 +12,8 @@ declare namespace CodeceptJS {
   type Cookie = {
     name: string;
     value: string;
+    domain?: string,
+    path?: string,
   };
 
   interface PageScrollPosition {