codeceptjs 3.6.0-beta.1.ai-healers → 3.6.0

package/lib/helper/REST.js

@@ -72,9 +72,12 @@ class REST extends Helper {
       this.options.maxBodyLength = maxContentLength;
     }
 
-    this.options = { ...this.options, ...config };
+    // override defaults with config
+    this._setConfig(config);
+
     this.headers = { ...this.options.defaultHeaders };
     this.axios = axios.create();
+    // @ts-ignore
     this.axios.defaults.headers = this.options.defaultHeaders;
   }
 

package/lib/helper/WebDriver.js

@@ -2,10 +2,9 @@ let webdriverio;
 
 const assert = require('assert');
 const path = require('path');
-const fs = require('fs');
 
 const Helper = require('@codeceptjs/helper');
-const crypto = require('crypto');
+const promiseRetry = require('promise-retry');
 const stringIncludes = require('../assert/include').includes;
 const { urlEquals, equals } = require('../assert/equal');
 const { debug } = require('../output');
@@ -29,9 +28,14 @@ const ElementNotFound = require('./errors/ElementNotFound');
 const ConnectionRefused = require('./errors/ConnectionRefused');
 const Locator = require('../locator');
 const { highlightElement } = require('./scripts/highlightElement');
-const store = require('../store');
 const { focusElement } = require('./scripts/focusElement');
 const { blurElement } = require('./scripts/blurElement');
+const {
+  dontSeeElementError, seeElementError, seeElementInDOMError, dontSeeElementInDOMError,
+} = require('./errors/ElementAssertion');
+const {
+  dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics,
+} = require('./network/actions');
 
 const SHADOW = 'shadow';
 const webRoot = 'body';
@@ -448,6 +452,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) => {
@@ -487,8 +496,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;
@@ -629,6 +639,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;
   }
 
@@ -961,12 +976,12 @@ class WebDriver extends Helper {
    */
   amOnPage(url) {
     let split_url;
-    if (this.config.basicAuth) {
+    if (this.options.basicAuth) {
       if (url.startsWith('/')) {
-        url = this.config.url + url;
+        url = this.options.url + url;
       }
       split_url = url.split('//');
-      url = `${split_url[0]}//${this.config.basicAuth.username}:${this.config.basicAuth.password}@${split_url[1]}`;
+      url = `${split_url[0]}//${this.options.basicAuth.username}:${this.options.basicAuth.password}@${split_url[1]}`;
     }
     return this.browser.url(url);
   }
@@ -1461,7 +1476,11 @@ class WebDriver extends Helper {
     const res = await this._locate(locator, true);
     assertElementExists(res, locator);
     const selected = await forEachAsync(res, async el => el.isDisplayed());
-    return truth(`elements of ${(new Locator(locator))}`, 'to be seen').assert(selected);
+    try {
+      return truth(`elements of ${(new Locator(locator))}`, 'to be seen').assert(selected);
+    } catch (e) {
+      dontSeeElementError(locator);
+    }
   }
 
   /**
@@ -1474,7 +1493,11 @@ class WebDriver extends Helper {
       return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(false);
     }
     const selected = await forEachAsync(res, async el => el.isDisplayed());
-    return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(selected);
+    try {
+      return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(selected);
+    } catch (e) {
+      seeElementError(locator);
+    }
   }
 
   /**
@@ -1483,7 +1506,11 @@ class WebDriver extends Helper {
    */
   async seeElementInDOM(locator) {
     const res = await this._res(locator);
-    return empty('elements').negate(res);
+    try {
+      return empty('elements').negate(res);
+    } catch (e) {
+      dontSeeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -1492,7 +1519,11 @@ class WebDriver extends Helper {
    */
   async dontSeeElementInDOM(locator) {
     const res = await this._res(locator);
-    return empty('elements').assert(res);
+    try {
+      return empty('elements').assert(res);
+    } catch (e) {
+      seeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -1612,6 +1643,8 @@ class WebDriver extends Helper {
       for (let i = 0; i < val.length; ++i) {
         const _actual = Number.isNaN(val[i]) || (typeof values[i]) === 'string' ? val[i] : Number.parseInt(val[i], 10);
         const _expected = Number.isNaN(values[i]) || (typeof values[i]) === 'string' ? values[i] : Number.parseInt(values[i], 10);
+        // the attribute could be a boolean
+        if (typeof _actual === 'boolean') return _actual === _expected;
         if (_actual !== _expected) return false;
       }
       return true;
@@ -1839,6 +1872,37 @@ class WebDriver extends Helper {
     return cookie[0];
   }
 
+  /**
+   * {{> waitForCookie }}
+   */
+  async waitForCookie(name, sec) {
+    // by default, we will retry 3 times
+    let retries = 3;
+    const waitTimeout = sec || this.options.waitForTimeoutInSeconds;
+
+    if (sec) {
+      retries = sec;
+    } else {
+      retries = waitTimeout - 1;
+    }
+
+    return promiseRetry(async (retry, number) => {
+      const _grabCookie = async (name) => {
+        const cookie = await this.browser.getCookies([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 });
+  }
+
   /**
    * Accepts the active JavaScript native popup window, as created by window.alert|window.confirm|window.prompt.
    * Don't confuse popups with modal windows, as created by [various
@@ -2550,9 +2614,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 });
     });
   }
@@ -2614,6 +2678,118 @@ 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;
+    }
+    return grabRecordedNetworkTraffics.call(this);
+  }
+
+  /**
+   *
+   * _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;
+    }
+    await seeTraffic.call(this, ...arguments);
+  }
+
+  /**
+   *
+   * _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;
+    }
+    dontSeeTraffic.call(this, ...arguments);
+  }
 }
 
 async function proceedSee(assertType, text, context, strict = false) {

package/lib/helper/errors/ElementAssertion.js

@@ -0,0 +1,38 @@
+const Locator = require('../../locator');
+
+const prefixMessage = 'Element';
+
+function seeElementError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is still visible on page.`);
+}
+
+function seeElementInDOMError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is still seen in DOM.`);
+}
+
+function dontSeeElementError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is not visible on page.`);
+}
+
+function dontSeeElementInDOMError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is not seen in DOM.`);
+}
+
+module.exports = {
+  seeElementError,
+  dontSeeElementError,
+  seeElementInDOMError,
+  dontSeeElementInDOMError,
+};

package/lib/helper/extras/PlaywrightReactVueLocator.js

@@ -20,6 +20,11 @@ async function findVue(matcher, locator) {
   return matcher.locator(_locator).all();
 }
 
+async function findByPlaywrightLocator(matcher, locator) {
+  if (locator && locator.toString().includes(process.env.testIdAttribute)) return matcher.getByTestId(locator.pw.value.split('=')[1]);
+  return matcher.locator(locator.pw).all();
+}
+
 function propBuilder(props) {
   let _props = '';
 
@@ -35,4 +40,4 @@ function propBuilder(props) {
   return _props;
 }
 
-module.exports = { findReact, findVue };
+module.exports = { findReact, findVue, findByPlaywrightLocator };

package/lib/helper/network/actions.js

@@ -0,0 +1,123 @@
+const assert = require('assert');
+const { isInTraffic, createAdvancedTestResults, getTrafficDump } = require('./utils');
+
+function dontSeeTraffic({ name, url }) {
+  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 (isInTraffic.call(this, url)) {
+    assert.fail(`Traffic with name "${name}" (URL: "${url}') found, but was not expected to be found.`);
+  }
+}
+
+async function seeTraffic({
+  name, url, parameters, requestPostData, timeout = 10,
+}) {
+  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 = isInTraffic.call(this, url, parameters);
+    if (found) {
+      return true;
+    }
+    await new Promise((done) => {
+      setTimeout(done, 1000);
+    });
+  }
+
+  // check request post data
+  if (requestPostData && isInTraffic.call(this, 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 && isInTraffic.call(this, 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${getTrafficDump.call(this)}`,
+    );
+  }
+}
+
+async function grabRecordedNetworkTraffics() {
+  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);
+}
+
+function stopRecordingTraffic() {
+  // @ts-ignore
+  this.page.removeAllListeners('request');
+  this.recording = false;
+}
+
+function flushNetworkTraffics() {
+  this.requests = [];
+}
+
+module.exports = {
+  dontSeeTraffic,
+  seeTraffic,
+  grabRecordedNetworkTraffics,
+  stopRecordingTraffic,
+  flushNetworkTraffics,
+};

package/lib/helper/network/utils.js

@@ -0,0 +1,187 @@
+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;
+};
+
+/**
+ * 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
+ */
+function getTrafficDump() {
+  let dumpedTraffic = '';
+  this.requests.forEach((request) => {
+    dumpedTraffic += `${request.method} - ${request.url}\n`;
+  });
+  return dumpedTraffic;
+}
+
+/**
+ * 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
+ */
+function 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;
+}
+
+module.exports = {
+  createAdvancedTestResults,
+  extractQueryObjects,
+  allParameterValuePairsMatchExtreme,
+  allRequestPostDataValuePairsMatchExtreme,
+  getTrafficDump,
+  isInTraffic,
+};