codeceptjs 3.5.12 → 3.5.13-beta.2

package/docs/webapi/type.mustache

@@ -0,0 +1,21 @@
+Types out the given text into an active field.
+To slow down typing use a second parameter, to set interval between key presses.
+_Note:_ Should be used when [`fillField`](#fillfield) is not an option.
+
+```js
+// passing in a string
+I.type('Type this out.');
+
+// typing values with a 100ms interval
+I.type('4141555311111111', 100);
+
+// passing in an array
+I.type(['T', 'E', 'X', 'T']);
+
+// passing a secret
+I.type(secret('123456'));
+```
+
+@param {string|string[]} key or array of keys to type.
+@param {?number} [delay=null] (optional) delay in ms between key presses
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/uncheckOption.mustache

@@ -0,0 +1,13 @@
+Unselects a checkbox or radio button.
+Element is located by label or name or CSS or XPath.
+
+The second parameter is a context (CSS or XPath locator) to narrow the search.
+
+```js
+I.uncheckOption('#agree');
+I.uncheckOption('I Agree to Terms and Conditions');
+I.uncheckOption('agree', '//form');
+```
+@param {CodeceptJS.LocatorOrString} field checkbox located by label | name | CSS | XPath | strict locator.
+@param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/wait.mustache

@@ -0,0 +1,8 @@
+Pauses execution for a number of seconds.
+
+```js
+I.wait(2); // wait 2 secs
+```
+
+@param {number} sec number of second to wait.
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForClickable.mustache

@@ -0,0 +1,11 @@
+Waits for element to be clickable (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+```js
+I.waitForClickable('.btn.continue');
+I.waitForClickable('.btn.continue', 5); // wait for 5 secs
+```
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForCookie.mustache

@@ -0,0 +1,9 @@
+Waits for the specified cookie in the cookies.
+
+```js
+I.waitForCookie("token");
+```
+
+@param {string} name expected cookie name.
+@param {number} [sec=3] (optional, `3` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForDetached.mustache

@@ -0,0 +1,10 @@
+Waits for an element to become not attached to the DOM on a page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+```js
+I.waitForDetached('#popup');
+```
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForElement.mustache

@@ -0,0 +1,11 @@
+Waits for element to be present on page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+```js
+I.waitForElement('.btn.continue');
+I.waitForElement('.btn.continue', 5); // wait for 5 secs
+```
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForEnabled.mustache

@@ -0,0 +1,6 @@
+Waits for element to become enabled (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec=1] (optional) time in seconds to wait, 1 by default.
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForFunction.mustache

@@ -0,0 +1,17 @@
+Waits for a function to return true (waits for 1 sec by default).
+Running in browser context.
+
+```js
+I.waitForFunction(fn[, [args[, timeout]])
+```
+
+```js
+I.waitForFunction(() => window.requests == 0);
+I.waitForFunction(() => window.requests == 0, 5); // waits for 5 sec
+I.waitForFunction((count) => window.requests == count, [3], 5) // pass args and wait for 5 sec
+```
+
+@param {string|function} fn to be executed in browser context.
+@param {any[]|number} [argsOrSec] (optional, `1` by default) arguments for function or seconds.
+@param {number} [sec] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForInvisible.mustache

@@ -0,0 +1,10 @@
+Waits for an element to be removed or become invisible on a page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+```js
+I.waitForInvisible('#popup');
+```
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForNumberOfTabs.mustache

@@ -0,0 +1,9 @@
+Waits for number of tabs.
+
+```js
+I.waitForNumberOfTabs(2);
+```
+
+@param {number} expectedTabs expecting the number of tabs.
+@param {number} sec number of secs to wait.
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForText.mustache

@@ -0,0 +1,13 @@
+Waits for a text to appear (by default waits for 1sec).
+Element can be located by CSS or XPath.
+Narrow down search results by providing context.
+
+```js
+I.waitForText('Thank you, form has been submitted');
+I.waitForText('Thank you, form has been submitted', 5, '#modal');
+```
+
+@param {string }text to wait for.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@param {CodeceptJS.LocatorOrString} [context] (optional) element located by CSS|XPath|strict locator.
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForValue.mustache

@@ -0,0 +1,10 @@
+Waits for the specified value to be in value attribute.
+
+```js
+I.waitForValue('//input', "GoodValue");
+```
+
+@param {LocatorOrString} field input field.
+@param {string }value expected value.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitForVisible.mustache

@@ -0,0 +1,10 @@
+Waits for an element to become visible on a page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+```js
+I.waitForVisible('#popup');
+```
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitInUrl.mustache

@@ -0,0 +1,9 @@
+Waiting for the part of the URL to match the expected. Useful for SPA to understand that page was changed.
+
+```js
+I.waitInUrl('/info', 2);
+```
+
+@param {string} urlPart value to check.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitNumberOfVisibleElements.mustache

@@ -0,0 +1,10 @@
+Waits for a specified number of elements on the page.
+
+```js
+I.waitNumberOfVisibleElements('a', 3);
+```
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} num number of elements.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitToHide.mustache

@@ -0,0 +1,10 @@
+Waits for an element to hide (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+```js
+I.waitToHide('#popup');
+```
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/waitUrlEquals.mustache

@@ -0,0 +1,10 @@
+Waits for the entire URL to match the expected
+
+```js
+I.waitUrlEquals('/info', 2);
+I.waitUrlEquals('http://127.0.0.1:8000/info');
+```
+
+@param {string} urlPart value to check.
+@param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+@returns {void} automatically synchronized promise through #recorder

package/lib/helper/Appium.js

@@ -2,6 +2,7 @@ let webdriverio;
 
 const fs = require('fs');
 const axios = require('axios').default;
+const { v4: uuidv4 } = require('uuid');
 
 const Webdriver = require('./WebDriver');
 const AssertionFailedError = require('../assert/error');
@@ -1088,17 +1089,40 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async performSwipe(from, to) {
-    await this.browser.touchPerform([{
-      action: 'press',
-      options: from,
-    }, {
-      action: 'wait',
-      options: { ms: 1000 },
-    }, {
-      action: 'moveTo',
-      options: to,
-    }, {
-      action: 'release',
+    await this.browser.performActions([{
+      id: uuidv4(),
+      type: 'pointer',
+      parameters: {
+        pointerType: 'touch',
+      },
+      actions: [
+        {
+          duration: 0,
+          x: from.x,
+          y: from.y,
+          type: 'pointerMove',
+          origin: 'viewport',
+        },
+        {
+          button: 1,
+          type: 'pointerDown',
+        },
+        {
+          duration: 200,
+          type: 'pause',
+        },
+        {
+          duration: 600,
+          x: to.x,
+          y: to.y,
+          type: 'pointerMove',
+          origin: 'viewport',
+        },
+        {
+          button: 1,
+          type: 'pointerUp',
+        },
+      ],
     }]);
     await this.browser.pause(1000);
   }
@@ -1128,7 +1152,7 @@ class Appium extends Webdriver {
       yoffset = 100;
     }
 
-    return this.swipe(locator, 0, yoffset, speed);
+    return this.swipe(parseLocator.call(this, locator), 0, yoffset, speed);
   }
 
   /**

package/lib/helper/Expect.js

@@ -1,12 +1,15 @@
-const chai = require('chai');
 const output = require('../output');
 
-const { expect } = chai;
+let expect;
 
-chai.use(require('chai-string'));
-// @ts-ignore
-chai.use(require('chai-exclude'));
-chai.use(require('chai-match-pattern'));
+import('chai').then(chai => {
+  expect = chai.expect;
+  chai.use(require('chai-string'));
+  // @ts-ignore
+  chai.use(require('chai-exclude'));
+  chai.use(require('chai-match-pattern'));
+  chai.use(require('chai-json-schema'));
+});
 
 /**
  * This helper allows performing assertions based on Chai.
@@ -179,7 +182,7 @@ class ExpectHelper {
   expectJsonSchema(targetData, jsonSchema, customErrorMsg = '') {
     // @ts-ignore
     output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema "${JSON.stringify(jsonSchema)}"`);
-    chai.use(require('chai-json-schema'));
+
     return expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema);
   }
 

package/lib/helper/JSONResponse.js

@@ -1,12 +1,13 @@
-const assert = require('assert');
-const chai = require('chai');
-const joi = require('joi');
-const chaiDeepMatch = require('chai-deep-match');
 const Helper = require('@codeceptjs/helper');
 
-chai.use(chaiDeepMatch);
+let expect;
+
+import('chai').then(chai => {
+  expect = chai.expect;
+  chai.use(require('chai-deep-match'));
+});
 
-const { expect } = chai;
+const joi = require('joi');
 
 /**
  * This helper allows performing assertions on JSON responses paired with following helpers:
@@ -91,7 +92,6 @@ class JSONResponse extends Helper {
   static _checkRequirements() {
     try {
       require('joi');
-      require('chai');
     } catch (e) {
       return ['joi'];
     }
@@ -194,7 +194,7 @@ class JSONResponse extends Helper {
           fails++;
         }
       }
-      assert.ok(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`);
+      expect(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`).to.be.true;
     } else {
       expect(this.response.data).to.deep.match(json);
     }

package/lib/helper/MockServer.js

@@ -0,0 +1,221 @@
+const { mock, settings } = require('pactum');
+
+/**
+ * ## Configuration
+ *
+ * This helper should be configured in codecept.conf.(js|ts)
+ *
+ * @typedef MockServerConfig
+ * @type {object}
+ * @prop {number} [port=9393] - Mock server port
+ * @prop {string} [host="0.0.0.0"] - Mock server host
+ * @prop {object} [httpsOpts] - key & cert values are the paths to .key and .crt files
+ */
+let config = {
+  port: 9393,
+  host: '0.0.0.0',
+  httpsOpts: {
+    key: '',
+    cert: '',
+  },
+};
+
+/**
+ * MockServer
+ *
+ * The MockServer Helper in CodeceptJS empowers you to mock any server or service via HTTP or HTTPS, making it an excellent tool for simulating REST endpoints and other HTTP-based APIs.
+ *
+ * <!-- configuration -->
+ *
+ * #### Examples
+ *
+ * You can seamlessly integrate MockServer with other helpers like REST or Playwright. Here's a configuration example inside the `codecept.conf.js` file:
+ *
+ * ```javascript
+ * {
+ *   helpers: {
+ *     REST: {...},
+ *     MockServer: {
+ *       // default mock server config
+ *       port: 9393,
+ *       host: '0.0.0.0',
+ *       httpsOpts: {
+ *         key: '',
+ *         cert: '',
+ *       },
+ *     },
+ *   }
+ * }
+ * ```
+ *
+ * #### Adding Interactions
+ *
+ * Interactions add behavior to the mock server. Use the `I.addInteractionToMockServer()` method to include interactions. It takes an interaction object as an argument, containing request and response details.
+ *
+ * ```javascript
+ * I.addInteractionToMockServer({
+ *    request: {
+ *      method: 'GET',
+ *      path: '/api/hello'
+ *    },
+ *    response: {
+ *      status: 200,
+ *      body: {
+ *        'say': 'hello to mock server'
+ *      }
+ *    }
+ * });
+ * ```
+ *
+ * #### Request Matching
+ *
+ * When a real request is sent to the mock server, it matches the received request with the interactions. If a match is found, it returns the specified response; otherwise, a 404 status code is returned.
+ *
+ * - Strong match on HTTP Method, Path, Query Params & JSON body.
+ * - Loose match on Headers.
+ *
+ * ##### Strong Match on Query Params
+ *
+ * You can send different responses based on query parameters:
+ *
+ * ```javascript
+ * I.addInteractionToMockServer({
+ *   request: {
+ *     method: 'GET',
+ *     path: '/api/users',
+ *     queryParams: {
+ *       id: 1
+ *     }
+ *   },
+ *   response: {
+ *     status: 200,
+ *     body: 'user 1'
+ *   }
+ * });
+ *
+ * I.addInteractionToMockServer({
+ *   request: {
+ *     method: 'GET',
+ *     path: '/api/users',
+ *     queryParams: {
+ *       id: 2
+ *     }
+ *   },
+ *   response: {
+ *     status: 200,
+ *     body: 'user 2'
+ *   }
+ * });
+ * ```
+ *
+ * - GET to `/api/users?id=1` will return 'user 1'.
+ * - GET to `/api/users?id=2` will return 'user 2'.
+ * - For all other requests, it returns a 404 status code.
+ *
+ * ##### Loose Match on Body
+ *
+ * When `strict` is set to false, it performs a loose match on query params and response body:
+ *
+ * ```javascript
+ * I.addInteractionToMockServer({
+ *   strict: false,
+ *   request: {
+ *     method: 'POST',
+ *     path: '/api/users',
+ *     body: {
+ *       name: 'john'
+ *     }
+ *   },
+ *   response: {
+ *     status: 200
+ *   }
+ * });
+ * ```
+ *
+ * - POST to `/api/users` with the body containing `name` as 'john' will return a 200 status code.
+ * - POST to `/api/users` without the `name` property in the body will return a 404 status code.
+ *
+ * Happy testing with MockServer in CodeceptJS! 🚀
+ *
+ * ## Methods
+ */
+class MockServer {
+  constructor(passedConfig) {
+    settings.setLogLevel('SILENT');
+    config = { ...passedConfig };
+    if (global.debugMode) {
+      settings.setLogLevel('VERBOSE');
+    }
+  }
+
+  /**
+   * Start the mock server
+   * @param {number} [port] start the mock server with given port
+   *
+   * @returns void
+   */
+  async startMockServer(port) {
+    const _config = { ...config };
+    if (port) _config.port = port;
+    await mock.setDefaults(_config);
+    await mock.start();
+  }
+
+  /**
+   * Stop the mock server
+   *
+   * @returns void
+   *
+   */
+  async stopMockServer() {
+    await mock.stop();
+  }
+
+  /**
+   * An interaction adds behavior to the mock server
+   *
+   *
+   * ```js
+   * I.addInteractionToMockServer({
+   *    request: {
+   *      method: 'GET',
+   *      path: '/api/hello'
+   *    },
+   *    response: {
+   *      status: 200,
+   *      body: {
+   *        'say': 'hello to mock server'
+   *      }
+   *    }
+   * });
+   * ```
+   * ```js
+   * // with query params
+   * I.addInteractionToMockServer({
+   *    request: {
+   *      method: 'GET',
+   *      path: '/api/hello',
+   *      queryParams: {
+   *       id: 2
+   *     }
+   *    },
+   *    response: {
+   *      status: 200,
+   *      body: {
+   *        'say': 'hello to mock server'
+   *      }
+   *    }
+   * });
+   * ```
+   *
+   * @param {CodeceptJS.MockInteraction|object} interaction add behavior to the mock server
+   *
+   * @returns void
+   *
+   */
+  async addInteractionToMockServer(interaction) {
+    await mock.addInteraction(interaction);
+  }
+}
+
+module.exports = MockServer;

package/lib/helper/Playwright.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const Helper = require('@codeceptjs/helper');
 const { v4: uuidv4 } = require('uuid');
 const assert = require('assert');
+const promiseRetry = require('promise-retry');
 const Locator = require('../locator');
 const store = require('../store');
 const recorder = require('../recorder');
@@ -50,6 +51,7 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
 const {
   seeElementError, dontSeeElementError, dontSeeElementInDOMError, seeElementInDOMError,
 } = require('./errors/ElementAssertion');
+const { log } = require('../output');
 
 const pathSeparator = path.sep;
 
@@ -748,9 +750,7 @@ class Playwright extends Helper {
     });
     this.context = await this.page;
     this.contextLocator = null;
-    if (this.options.browser === 'chrome') {
-      await page.bringToFront();
-    }
+    await page.bringToFront();
   }
 
   /**
@@ -1805,7 +1805,7 @@ class Playwright extends Helper {
     let optionToSelect = '';
 
     try {
-      optionToSelect = await el.locator('option', { hasText: option }).textContent();
+      optionToSelect = (await el.locator('option', { hasText: option }).textContent()).trim();
     } catch (e) {
       optionToSelect = option;
     }
@@ -2890,6 +2890,38 @@ class Playwright extends Helper {
     }
   }
 
+  /**
+   * {{> waitForCookie }}
+   */
+  async waitForCookie(name, sec) {
+    // by default, we will retry 3 times
+    let retries = 3;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+
+    if (sec) {
+      retries = sec;
+    } else {
+      retries = Math.ceil(waitTimeout / 1000) - 1;
+    }
+
+    return promiseRetry(async (retry, number) => {
+      const _grabCookie = async (name) => {
+        const cookies = await this.browserContext.cookies();
+        const cookie = cookies.filter(c => c.name === name);
+        if (cookie.length === 0) throw Error(`Cookie ${name} is not found after ${retries}s`);
+      };
+
+      this.debugSection('Wait for cookie: ', name);
+      if (number > 1) this.debugSection('Retrying... Attempt #', number);
+
+      try {
+        await _grabCookie(name);
+      } catch (e) {
+        retry(e);
+      }
+    }, { retries, maxTimeout: 1000 });
+  }
+
   async _waitForAction() {
     return this.wait(this.options.waitForAction / 1000);
   }