codeceptjs 3.5.13-beta.2 → 3.5.13-beta.3

package/docs/webapi/dontSeeTraffic.mustache

@@ -0,0 +1,13 @@
+Verifies that a certain request is not part of network traffic.
+
+Examples:
+
+```js
+I.dontSeeTraffic({ name: 'Unexpected API Call', url: 'https://api.example.com' });
+I.dontSeeTraffic({ name: 'Unexpected API Call of "user" endpoint', url: /api.example.com.*user/ });
+```
+
+@param {Object} opts - options when checking the traffic network.
+@param {string} opts.name A name of that request. Can be any value. Only relevant to have a more meaningful error message in case of fail.
+@param {string|RegExp} opts.url Expected URL of request in network traffic. Can be a string or a regular expression.
+@return {void} automatically synchronized promise through #recorder

package/docs/webapi/flushNetworkTraffics.mustache

@@ -0,0 +1,5 @@
+Resets all recorded network requests.
+
+```js
+I.flushNetworkTraffics();
+```

package/docs/webapi/grabRecordedNetworkTraffics.mustache

@@ -0,0 +1,10 @@
+Grab the recording network traffics
+
+```js
+const traffics = await I.grabRecordedNetworkTraffics();
+expect(traffics[0].url).to.equal('https://reqres.in/api/comments/1');
+expect(traffics[0].response.status).to.equal(200);
+expect(traffics[0].response.body).to.contain({ name: 'this was mocked' });
+```
+
+@return { Array } recorded network traffics

package/docs/webapi/seeTraffic.mustache

@@ -0,0 +1,36 @@
+Verifies that a certain request is part of network traffic.
+
+```js
+// checking the request url contains certain query strings
+I.amOnPage('https://openai.com/blog/chatgpt');
+I.startRecordingTraffic();
+await I.seeTraffic({
+    name: 'sentry event',
+    url: 'https://images.openai.com/blob/cf717bdb-0c8c-428a-b82b-3c3add87a600',
+    parameters: {
+    width: '1919',
+    height: '1138',
+    },
+  });
+```
+
+```js
+// checking the request url contains certain post data
+I.amOnPage('https://openai.com/blog/chatgpt');
+I.startRecordingTraffic();
+await I.seeTraffic({
+    name: 'event',
+    url: 'https://cloudflareinsights.com/cdn-cgi/rum',
+    requestPostData: {
+    st: 2,
+    },
+  });
+```
+
+@param {Object} opts - options when checking the traffic network.
+@param {string} opts.name A name of that request. Can be any value. Only relevant to have a more meaningful error message in case of fail.
+@param {string} opts.url Expected URL of request in network traffic
+@param {Object} [opts.parameters] Expected parameters of that request in network traffic
+@param {Object} [opts.requestPostData] Expected that request contains post data in network traffic
+@param {number} [opts.timeout] Timeout to wait for request in seconds. Default is 10 seconds.
+@return {void} automatically synchronized promise through #recorder

package/docs/webapi/startRecordingTraffic.mustache

@@ -0,0 +1,8 @@
+Starts recording the network traffics.
+This also resets recorded network requests.
+
+```js
+I.startRecordingTraffic();
+```
+
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/stopRecordingTraffic.mustache

@@ -0,0 +1,5 @@
+Stops recording of network traffic. Recorded traffic is not flashed.
+
+```js
+I.stopRecordingTraffic();
+```

package/lib/helper/Playwright.js

@@ -51,6 +51,7 @@ const { createValueEngine, createDisabledEngine } = require('./extras/Playwright
 const {
   seeElementError, dontSeeElementError, dontSeeElementInDOMError, seeElementInDOMError,
 } = require('./errors/ElementAssertion');
+const { createAdvancedTestResults, allParameterValuePairsMatchExtreme, extractQueryObjects } = require('./networkTraffics/utils');
 const { log } = require('../output');
 
 const pathSeparator = path.sep;
@@ -2976,14 +2977,8 @@ class Playwright extends Helper {
   }
 
   /**
-   * Starts recording the network traffics.
-   * This also resets recorded network requests.
+   * {{> flushNetworkTraffics }}
    *
-   * ```js
-   * I.startRecordingTraffic();
-   * ```
-   *
-   * @return {void}
    */
   startRecordingTraffic() {
     this.flushNetworkTraffics();
@@ -3010,18 +3005,8 @@ class Playwright extends Helper {
   }
 
   /**
-  *  Grab the recording network traffics
-  *
-  * ```js
-  * const traffics = await I.grabRecordedNetworkTraffics();
-  * expect(traffics[0].url).to.equal('https://reqres.in/api/comments/1');
-  * expect(traffics[0].response.status).to.equal(200);
-  * expect(traffics[0].response.body).to.contain({ name: 'this was mocked' });
-  * ```
-  *
-  * @return { Promise<Array<any>> }
-  *
-  */
+   * {{> grabRecordedNetworkTraffics }}
+   */
   async grabRecordedNetworkTraffics() {
     if (!this.recording || !this.recordedAtLeastOnce) {
       throw new Error('Failure in test automation. You use "I.grabRecordedNetworkTraffics", but "I.startRecordingTraffic" was never called before.');
@@ -3129,18 +3114,14 @@ class Playwright extends Helper {
   }
 
   /**
-   * Resets all recorded network requests.
+   * {{> flushNetworkTraffics }}
    */
   flushNetworkTraffics() {
     this.requests = [];
   }
 
   /**
-   * Stops recording of network traffic. Recorded traffic is not flashed.
-   *
-   * ```js
-   * I.stopRecordingTraffic();
-   * ```
+   * {{> stopRecordingTraffic }}
    */
   stopRecordingTraffic() {
     this.page.removeAllListeners('request');
@@ -3148,42 +3129,7 @@ class Playwright extends Helper {
   }
 
   /**
-   * Verifies that a certain request is part of network traffic.
-   *
-   * ```js
-   * // checking the request url contains certain query strings
-   * I.amOnPage('https://openai.com/blog/chatgpt');
-   * I.startRecordingTraffic();
-   * await I.seeTraffic({
-   *    name: 'sentry event',
-   *    url: 'https://images.openai.com/blob/cf717bdb-0c8c-428a-b82b-3c3add87a600',
-   *    parameters: {
-   *       width: '1919',
-   *       height: '1138',
-   *     },
-   * });
-   * ```
-   *
-   * ```js
-   * // checking the request url contains certain post data
-   * I.amOnPage('https://openai.com/blog/chatgpt');
-   * I.startRecordingTraffic();
-   * await I.seeTraffic({
-   *    name: 'event',
-   *    url: 'https://cloudflareinsights.com/cdn-cgi/rum',
-   *    requestPostData: {
-   *       st: 2,
-   *     },
-   * });
-   * ```
-   *
-   * @param {Object} opts - options when checking the traffic network.
-   * @param {string} opts.name A name of that request. Can be any value. Only relevant to have a more meaningful error message in case of fail.
-   * @param {string} opts.url Expected URL of request in network traffic
-   * @param {Object} [opts.parameters] Expected parameters of that request in network traffic
-   * @param {Object} [opts.requestPostData] Expected that request contains post data in network traffic
-   * @param {number} [opts.timeout] Timeout to wait for request in seconds. Default is 10 seconds.
-   * @return { Promise<*> }
+   * {{> seeTraffic }}
    */
   async seeTraffic({
     name, url, parameters, requestPostData, timeout = 10,
@@ -3265,18 +3211,7 @@ class Playwright extends Helper {
   }
 
   /**
-   * Verifies that a certain request is not part of network traffic.
-   *
-   * Examples:
-   *
-   * ```js
-   * I.dontSeeTraffic({ name: 'Unexpected API Call', url: 'https://api.example.com' });
-   * I.dontSeeTraffic({ name: 'Unexpected API Call of "user" endpoint', url: /api.example.com.*user/ });
-   * ```
-   *
-   * @param {Object} opts - options when checking the traffic network.
-   * @param {string} opts.name A name of that request. Can be any value. Only relevant to have a more meaningful error message in case of fail.
-   * @param {string|RegExp} opts.url Expected URL of request in network traffic. Can be a string or a regular expression.
+   * {{> dontSeeTraffic }}
    *
    */
   dontSeeTraffic({ name, url }) {
@@ -3988,134 +3923,3 @@ async function highlightActiveElement(element) {
     });
   }
 }
-
-const createAdvancedTestResults = (url, dataToCheck, requests) => {
-  // Creates advanced test results for a network traffic check.
-  // Advanced test results only applies when expected parameters are set
-  if (!dataToCheck) return '';
-
-  let urlFound = false;
-  let advancedResults;
-  requests.forEach((request) => {
-    // url not found in this request. continue with next request
-    if (urlFound || !request.url.match(new RegExp(url))) return;
-    urlFound = true;
-
-    // Url found. Now we create advanced test report for that URL and show which parameters failed
-    if (!request.requestPostData) {
-      advancedResults = allParameterValuePairsMatchExtreme(extractQueryObjects(request.url), dataToCheck);
-    } else if (request.requestPostData) {
-      advancedResults = allRequestPostDataValuePairsMatchExtreme(request.requestPostData, dataToCheck);
-    }
-  });
-  return advancedResults;
-};
-
-const extractQueryObjects = (queryString) => {
-  // Converts a string of GET parameters into an array of parameter objects. Each parameter object contains the properties "name" and "value".
-  if (queryString.indexOf('?') === -1) {
-    return [];
-  }
-  const queryObjects = [];
-
-  const queryPart = queryString.split('?')[1];
-
-  const queryParameters = queryPart.split('&');
-
-  queryParameters.forEach((queryParameter) => {
-    const keyValue = queryParameter.split('=');
-    const queryObject = {};
-    // eslint-disable-next-line prefer-destructuring
-    queryObject.name = keyValue[0];
-    queryObject.value = decodeURIComponent(keyValue[1]);
-    queryObjects.push(queryObject);
-  });
-
-  return queryObjects;
-};
-
-const allParameterValuePairsMatchExtreme = (queryStringObject, advancedExpectedParameterValuePairs) => {
-  // More advanced check if all request parameters match with the expectations
-  let littleReport = '\nQuery parameters:\n';
-  let success = true;
-
-  for (const expectedKey in advancedExpectedParameterValuePairs) {
-    if (!Object.prototype.hasOwnProperty.call(advancedExpectedParameterValuePairs, expectedKey)) {
-      continue;
-    }
-    let parameterFound = false;
-    const expectedValue = advancedExpectedParameterValuePairs[expectedKey];
-
-    for (const queryParameter of queryStringObject) {
-      if (queryParameter.name === expectedKey) {
-        parameterFound = true;
-        if (expectedValue === undefined) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`;
-        } else if (typeof expectedValue === 'object' && expectedValue.base64) {
-          const decodedActualValue = Buffer.from(queryParameter.value, 'base64').toString('utf8');
-          if (decodedActualValue === expectedValue.base64) {
-            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`;
-          } else {
-            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`;
-            success = false;
-          }
-        } else if (queryParameter.value === expectedValue) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`;
-        } else {
-          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${queryParameter.value}"\n`;
-          success = false;
-        }
-      }
-    }
-
-    if (parameterFound === false) {
-      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> parameter not found in request\n`;
-      success = false;
-    }
-  }
-
-  return success ? true : littleReport;
-};
-
-const allRequestPostDataValuePairsMatchExtreme = (RequestPostDataObject, advancedExpectedRequestPostValuePairs) => {
-  // More advanced check if all request post data match with the expectations
-  let littleReport = '\nRequest Post Data:\n';
-  let success = true;
-
-  for (const expectedKey in advancedExpectedRequestPostValuePairs) {
-    if (!Object.prototype.hasOwnProperty.call(advancedExpectedRequestPostValuePairs, expectedKey)) {
-      continue;
-    }
-    let keyFound = false;
-    const expectedValue = advancedExpectedRequestPostValuePairs[expectedKey];
-
-    for (const [key, value] of Object.entries(RequestPostDataObject)) {
-      if (key === expectedKey) {
-        keyFound = true;
-        if (expectedValue === undefined) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`;
-        } else if (typeof expectedValue === 'object' && expectedValue.base64) {
-          const decodedActualValue = Buffer.from(value, 'base64').toString('utf8');
-          if (decodedActualValue === expectedValue.base64) {
-            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`;
-          } else {
-            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`;
-            success = false;
-          }
-        } else if (value === expectedValue) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`;
-        } else {
-          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${value}"\n`;
-          success = false;
-        }
-      }
-    }
-
-    if (keyFound === false) {
-      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> key not found in request\n`;
-      success = false;
-    }
-  }
-
-  return success ? true : littleReport;
-};

package/lib/helper/WebDriver.js

@@ -36,6 +36,7 @@ const { blurElement } = require('./scripts/blurElement');
 const {
   dontSeeElementError, seeElementError, seeElementInDOMError, dontSeeElementInDOMError,
 } = require('./errors/ElementAssertion');
+const { allParameterValuePairsMatchExtreme, extractQueryObjects, createAdvancedTestResults } = require('./networkTraffics/utils');
 
 const SHADOW = 'shadow';
 const webRoot = 'body';
@@ -452,6 +453,11 @@ class WebDriver extends Helper {
     this.activeSessionName = '';
     this.customLocatorStrategies = config.customLocatorStrategies;
 
+    // for network stuff
+    this.requests = [];
+    this.recording = false;
+    this.recordedAtLeastOnce = false;
+
     this._setConfig(config);
 
     Locator.addFilter((locator, result) => {
@@ -491,8 +497,9 @@ class WebDriver extends Helper {
     if (config.host) {
       // webdriverio spec
       config.hostname = config.host;
-      config.path = '/wd/hub';
+      config.path = config.path ? config.path : '/wd/hub';
     }
+
     config.baseUrl = config.url || config.baseUrl;
     if (config.desiredCapabilities && Object.keys(config.desiredCapabilities).length) {
       config.capabilities = config.desiredCapabilities;
@@ -633,6 +640,11 @@ class WebDriver extends Helper {
     if (this.browser.capabilities && this.browser.capabilities.platformName) {
       this.browser.capabilities.platformName = this.browser.capabilities.platformName.toLowerCase();
     }
+
+    if (this.options.automationProtocol) {
+      this.puppeteerBrowser = await this.browser.getPuppeteer();
+    }
+
     return this.browser;
   }
 
@@ -2603,9 +2615,9 @@ class WebDriver extends Helper {
       return;
     }
     this.geoLocation = { latitude, longitude };
-    const puppeteerBrowser = await this.browser.getPuppeteer();
+
     await this.browser.call(async () => {
-      const pages = await puppeteerBrowser.pages();
+      const pages = await this.puppeteerBrowser.pages();
       await pages[0].setGeolocation({ latitude, longitude });
     });
   }
@@ -2667,6 +2679,255 @@ class WebDriver extends Helper {
   runInWeb(fn) {
     return fn();
   }
+
+  /**
+   *
+   * _Note:_ Only works when devtoolsProtocol is enabled.
+   *
+   * {{> flushNetworkTraffics }}
+   */
+  flushNetworkTraffics() {
+    if (!this.options.automationProtocol) {
+      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
+      return;
+    }
+    this.requests = [];
+  }
+
+  /**
+   *
+   * _Note:_ Only works when devtoolsProtocol is enabled.
+   *
+   * {{> stopRecordingTraffic }}
+   */
+  stopRecordingTraffic() {
+    if (!this.options.automationProtocol) {
+      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
+      return;
+    }
+    this.page.removeAllListeners('request');
+    this.recording = false;
+  }
+
+  /**
+   *
+   * _Note:_ Only works when devtoolsProtocol is enabled.
+   *
+   * {{> startRecordingTraffic }}
+   *
+   */
+  async startRecordingTraffic() {
+    if (!this.options.automationProtocol) {
+      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
+      return;
+    }
+    this.flushNetworkTraffics();
+    this.recording = true;
+    this.recordedAtLeastOnce = true;
+
+    this.page = (await this.puppeteerBrowser.pages())[0];
+    await this.page.setRequestInterception(true);
+
+    this.page.on('request', (request) => {
+      const information = {
+        url: request.url(),
+        method: request.method(),
+        requestHeaders: request.headers(),
+        requestPostData: request.postData(),
+        response: request.response(),
+      };
+
+      this.debugSection('REQUEST: ', JSON.stringify(information));
+
+      if (typeof information.requestPostData === 'object') {
+        information.requestPostData = JSON.parse(information.requestPostData);
+      }
+      request.continue();
+      this.requests.push(information);
+    });
+  }
+
+  /**
+   *
+   * _Note:_ Only works when devtoolsProtocol is enabled.
+   *
+   * {{> grabRecordedNetworkTraffics }}
+   */
+  async grabRecordedNetworkTraffics() {
+    if (!this.options.automationProtocol) {
+      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
+      return;
+    }
+    if (!this.recording || !this.recordedAtLeastOnce) {
+      throw new Error('Failure in test automation. You use "I.grabRecordedNetworkTraffics", but "I.startRecordingTraffic" was never called before.');
+    }
+
+    const promises = this.requests.map(async (request) => {
+      const resp = await request.response;
+
+      if (!resp) {
+        return {
+          url: '',
+          response: {
+            status: '',
+            statusText: '',
+            body: '',
+          },
+        };
+      }
+
+      let body;
+      try {
+        // There's no 'body' for some requests (redirect etc...)
+        body = JSON.parse((await resp.body()).toString());
+      } catch (e) {
+        // only interested in JSON, not HTML responses.
+      }
+
+      return {
+        url: resp.url(),
+        response: {
+          status: resp.status(),
+          statusText: resp.statusText(),
+          body,
+        },
+      };
+    });
+    return Promise.all(promises);
+  }
+
+  /**
+   *
+   * _Note:_ Only works when devtoolsProtocol is enabled.
+   *
+   * {{> seeTraffic }}
+   */
+  async seeTraffic({
+    name, url, parameters, requestPostData, timeout = 10,
+  }) {
+    if (!this.options.automationProtocol) {
+      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
+      return;
+    }
+    if (!name) {
+      throw new Error('Missing required key "name" in object given to "I.seeTraffic".');
+    }
+
+    if (!url) {
+      throw new Error('Missing required key "url" in object given to "I.seeTraffic".');
+    }
+
+    if (!this.recording || !this.recordedAtLeastOnce) {
+      throw new Error('Failure in test automation. You use "I.seeTraffic", but "I.startRecordingTraffic" was never called before.');
+    }
+
+    for (let i = 0; i <= timeout * 2; i++) {
+      const found = this._isInTraffic(url, parameters);
+      if (found) {
+        return true;
+      }
+      await new Promise((done) => {
+        setTimeout(done, 1000);
+      });
+    }
+
+    // check request post data
+    if (requestPostData && this._isInTraffic(url)) {
+      const advancedTestResults = createAdvancedTestResults(url, requestPostData, this.requests);
+
+      assert.equal(advancedTestResults, true, `Traffic named "${name}" found correct URL ${url}, BUT the post data did not match:\n ${advancedTestResults}`);
+    } else if (parameters && this._isInTraffic(url)) {
+      const advancedTestResults = createAdvancedTestResults(url, parameters, this.requests);
+
+      assert.fail(
+        `Traffic named "${name}" found correct URL ${url}, BUT the query parameters did not match:\n`
+        + `${advancedTestResults}`,
+      );
+    } else {
+      assert.fail(
+        `Traffic named "${name}" not found in recorded traffic within ${timeout} seconds.\n`
+        + `Expected url: ${url}.\n`
+        + `Recorded traffic:\n${this._getTrafficDump()}`,
+      );
+    }
+  }
+
+  /**
+   *
+   * _Note:_ Only works when devtoolsProtocol is enabled.
+   *
+   * {{> dontSeeTraffic }}
+   *
+   */
+  dontSeeTraffic({ name, url }) {
+    if (!this.options.automationProtocol) {
+      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
+      return;
+    }
+    if (!this.recordedAtLeastOnce) {
+      throw new Error('Failure in test automation. You use "I.dontSeeTraffic", but "I.startRecordingTraffic" was never called before.');
+    }
+
+    if (!name) {
+      throw new Error('Missing required key "name" in object given to "I.dontSeeTraffic".');
+    }
+
+    if (!url) {
+      throw new Error('Missing required key "url" in object given to "I.dontSeeTraffic".');
+    }
+
+    if (this._isInTraffic(url)) {
+      assert.fail(`Traffic with name "${name}" (URL: "${url}') found, but was not expected to be found.`);
+    }
+  }
+
+  /**
+   * Checks if URL with parameters is part of network traffic. Returns true or false. Internal method for this helper.
+   *
+   * @param url URL to look for.
+   * @param [parameters] Parameters that this URL needs to contain
+   * @return {boolean} Whether or not URL with parameters is part of network traffic.
+   * @private
+   */
+  _isInTraffic(url, parameters) {
+    let isInTraffic = false;
+    this.requests.forEach((request) => {
+      if (isInTraffic) {
+        return; // We already found traffic. Continue with next request
+      }
+
+      if (!request.url.match(new RegExp(url))) {
+        return; // url not found in this request. continue with next request
+      }
+
+      // URL has matched. Now we check the parameters
+
+      if (parameters) {
+        const advancedReport = allParameterValuePairsMatchExtreme(extractQueryObjects(request.url), parameters);
+        if (advancedReport === true) {
+          isInTraffic = true;
+        }
+      } else {
+        isInTraffic = true;
+      }
+    });
+
+    return isInTraffic;
+  }
+
+  /**
+   * Returns all URLs of all network requests recorded so far during execution of test scenario.
+   *
+   * @return {string} List of URLs recorded as a string, separated by new lines after each URL
+   * @private
+   */
+  _getTrafficDump() {
+    let dumpedTraffic = '';
+    this.requests.forEach((request) => {
+      dumpedTraffic += `${request.method} - ${request.url}\n`;
+    });
+    return dumpedTraffic;
+  }
 }
 
 async function proceedSee(assertType, text, context, strict = false) {

package/lib/helper/networkTraffics/utils.js

@@ -0,0 +1,137 @@
+const createAdvancedTestResults = (url, dataToCheck, requests) => {
+  // Creates advanced test results for a network traffic check.
+  // Advanced test results only applies when expected parameters are set
+  if (!dataToCheck) return '';
+
+  let urlFound = false;
+  let advancedResults;
+  requests.forEach((request) => {
+    // url not found in this request. continue with next request
+    if (urlFound || !request.url.match(new RegExp(url))) return;
+    urlFound = true;
+
+    // Url found. Now we create advanced test report for that URL and show which parameters failed
+    if (!request.requestPostData) {
+      advancedResults = allParameterValuePairsMatchExtreme(extractQueryObjects(request.url), dataToCheck);
+    } else if (request.requestPostData) {
+      advancedResults = allRequestPostDataValuePairsMatchExtreme(request.requestPostData, dataToCheck);
+    }
+  });
+  return advancedResults;
+};
+
+const extractQueryObjects = (queryString) => {
+  // Converts a string of GET parameters into an array of parameter objects. Each parameter object contains the properties "name" and "value".
+  if (queryString.indexOf('?') === -1) {
+    return [];
+  }
+  const queryObjects = [];
+
+  const queryPart = queryString.split('?')[1];
+
+  const queryParameters = queryPart.split('&');
+
+  queryParameters.forEach((queryParameter) => {
+    const keyValue = queryParameter.split('=');
+    const queryObject = {};
+    // eslint-disable-next-line prefer-destructuring
+    queryObject.name = keyValue[0];
+    queryObject.value = decodeURIComponent(keyValue[1]);
+    queryObjects.push(queryObject);
+  });
+
+  return queryObjects;
+};
+
+const allParameterValuePairsMatchExtreme = (queryStringObject, advancedExpectedParameterValuePairs) => {
+  // More advanced check if all request parameters match with the expectations
+  let littleReport = '\nQuery parameters:\n';
+  let success = true;
+
+  for (const expectedKey in advancedExpectedParameterValuePairs) {
+    if (!Object.prototype.hasOwnProperty.call(advancedExpectedParameterValuePairs, expectedKey)) {
+      continue;
+    }
+    let parameterFound = false;
+    const expectedValue = advancedExpectedParameterValuePairs[expectedKey];
+
+    for (const queryParameter of queryStringObject) {
+      if (queryParameter.name === expectedKey) {
+        parameterFound = true;
+        if (expectedValue === undefined) {
+          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`;
+        } else if (typeof expectedValue === 'object' && expectedValue.base64) {
+          const decodedActualValue = Buffer.from(queryParameter.value, 'base64').toString('utf8');
+          if (decodedActualValue === expectedValue.base64) {
+            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`;
+          } else {
+            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`;
+            success = false;
+          }
+        } else if (queryParameter.value === expectedValue) {
+          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`;
+        } else {
+          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${queryParameter.value}"\n`;
+          success = false;
+        }
+      }
+    }
+
+    if (parameterFound === false) {
+      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> parameter not found in request\n`;
+      success = false;
+    }
+  }
+
+  return success ? true : littleReport;
+};
+
+const allRequestPostDataValuePairsMatchExtreme = (RequestPostDataObject, advancedExpectedRequestPostValuePairs) => {
+  // More advanced check if all request post data match with the expectations
+  let littleReport = '\nRequest Post Data:\n';
+  let success = true;
+
+  for (const expectedKey in advancedExpectedRequestPostValuePairs) {
+    if (!Object.prototype.hasOwnProperty.call(advancedExpectedRequestPostValuePairs, expectedKey)) {
+      continue;
+    }
+    let keyFound = false;
+    const expectedValue = advancedExpectedRequestPostValuePairs[expectedKey];
+
+    for (const [key, value] of Object.entries(RequestPostDataObject)) {
+      if (key === expectedKey) {
+        keyFound = true;
+        if (expectedValue === undefined) {
+          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`;
+        } else if (typeof expectedValue === 'object' && expectedValue.base64) {
+          const decodedActualValue = Buffer.from(value, 'base64').toString('utf8');
+          if (decodedActualValue === expectedValue.base64) {
+            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`;
+          } else {
+            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`;
+            success = false;
+          }
+        } else if (value === expectedValue) {
+          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`;
+        } else {
+          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${value}"\n`;
+          success = false;
+        }
+      }
+    }
+
+    if (keyFound === false) {
+      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> key not found in request\n`;
+      success = false;
+    }
+  }
+
+  return success ? true : littleReport;
+};
+
+module.exports = {
+  createAdvancedTestResults,
+  extractQueryObjects,
+  allParameterValuePairsMatchExtreme,
+  allRequestPostDataValuePairsMatchExtreme,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.5.13-beta.2",
+  "version": "3.5.13-beta.3",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -134,7 +134,7 @@
     "contributor-faces": "1.1.0",
     "documentation": "12.3.0",
     "dtslint": "4.2.1",
-    "electron": "28.1.4",
+    "electron": "28.2.1",
     "eslint": "8.56.0",
     "eslint-config-airbnb-base": "15.0.0",
     "eslint-plugin-import": "2.29.1",