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

package/lib/helper/Playwright.js

@@ -4,8 +4,8 @@ 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');
 const stringIncludes = require('../assert/include').includes;
 const { urlEquals } = require('../assert/equal');
@@ -47,11 +47,6 @@ const {
   setRestartStrategy, restartsSession, restartsContext, restartsBrowser,
 } = require('./extras/PlaywrightRestartOpts');
 const { createValueEngine, createDisabledEngine } = require('./extras/PlaywrightPropEngine');
-const {
-  seeElementError, dontSeeElementError, dontSeeElementInDOMError, seeElementInDOMError,
-} = require('./errors/ElementAssertion');
-const { createAdvancedTestResults, allParameterValuePairsMatchExtreme, extractQueryObjects } = require('./networkTraffics/utils');
-const { log } = require('../output');
 
 const pathSeparator = path.sep;
 
@@ -750,7 +745,9 @@ class Playwright extends Helper {
     });
     this.context = await this.page;
     this.contextLocator = null;
-    await page.bringToFront();
+    if (this.options.browser === 'chrome') {
+      await page.bringToFront();
+    }
   }
 
   /**
@@ -1454,11 +1451,7 @@ class Playwright extends Helper {
   async seeElement(locator) {
     let els = await this._locate(locator);
     els = await Promise.all(els.map(el => el.isVisible()));
-    try {
-      return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
-    } catch (e) {
-      dontSeeElementError(locator);
-    }
+    return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
   }
 
   /**
@@ -1468,11 +1461,7 @@ class Playwright extends Helper {
   async dontSeeElement(locator) {
     let els = await this._locate(locator);
     els = await Promise.all(els.map(el => el.isVisible()));
-    try {
-      return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
-    } catch (e) {
-      seeElementError(locator);
-    }
+    return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
   }
 
   /**
@@ -1480,11 +1469,7 @@ class Playwright extends Helper {
    */
   async seeElementInDOM(locator) {
     const els = await this._locate(locator);
-    try {
-      return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
-    } catch (e) {
-      dontSeeElementInDOMError(locator);
-    }
+    return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
   }
 
   /**
@@ -1492,11 +1477,7 @@ class Playwright extends Helper {
    */
   async dontSeeElementInDOM(locator) {
     const els = await this._locate(locator);
-    try {
-      return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
-    } catch (e) {
-      seeElementInDOMError(locator);
-    }
+    return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
   }
 
   /**
@@ -1805,7 +1786,7 @@ class Playwright extends Helper {
     let optionToSelect = '';
 
     try {
-      optionToSelect = (await el.locator('option', { hasText: option }).textContent()).trim();
+      optionToSelect = await el.locator('option', { hasText: option }).textContent();
     } catch (e) {
       optionToSelect = option;
     }
@@ -2188,8 +2169,6 @@ class Playwright extends Helper {
     let chunked = chunkArray(attrs, values.length);
     chunked = chunked.filter((val) => {
       for (let i = 0; i < val.length; ++i) {
-        // the attribute could be a boolean
-        if (typeof val[i] === 'boolean') return val[i] === values[i];
         // if the attribute doesn't exist, returns false as well
         if (!val[i] || !val[i].includes(values[i])) return false;
       }
@@ -2678,7 +2657,6 @@ class Playwright extends Helper {
    */
   async waitForText(text, sec = null, context = null) {
     const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    const errorMessage = `Text "${text}" was not found on page after ${waitTimeout / 1000} sec.`;
     let waiter;
 
     const contextObject = await this._getContext();
@@ -2689,21 +2667,18 @@ class Playwright extends Helper {
         try {
           await contextObject.locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()} >> text=${text}`).first().waitFor({ timeout: waitTimeout, state: 'visible' });
         } catch (e) {
-          throw new Error(`${errorMessage}\n${e.message}`);
+          console.log(e);
+          throw new Error(`Text "${text}" was not found on page after ${waitTimeout / 1000} sec\n${e.message}`);
         }
       }
 
       if (locator.isXPath()) {
-        try {
-          await contextObject.waitForFunction(([locator, text, $XPath]) => {
-            eval($XPath); // eslint-disable-line no-eval
-            const el = $XPath(null, locator);
-            if (!el.length) return false;
-            return el[0].innerText.indexOf(text) > -1;
-          }, [locator.value, text, $XPath.toString()], { timeout: waitTimeout });
-        } catch (e) {
-          throw new Error(`${errorMessage}\n${e.message}`);
-        }
+        waiter = contextObject.waitForFunction(([locator, text, $XPath]) => {
+          eval($XPath); // eslint-disable-line no-eval
+          const el = $XPath(null, locator);
+          if (!el.length) return false;
+          return el[0].innerText.indexOf(text) > -1;
+        }, [locator.value, text, $XPath.toString()], { timeout: waitTimeout });
       }
     } else {
       // we have this as https://github.com/microsoft/playwright/issues/26829 is not yet implemented
@@ -2717,7 +2692,7 @@ class Playwright extends Helper {
         count += 1000;
       } while (count <= waitTimeout);
 
-      if (!waiter) throw new Error(`${errorMessage}`);
+      if (!waiter) throw new Error(`Text "${text}" was not found on page after ${waitTimeout / 1000} sec`);
     }
   }
 
@@ -2894,38 +2869,6 @@ 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);
   }
@@ -2980,8 +2923,14 @@ class Playwright extends Helper {
   }
 
   /**
-   * {{> flushNetworkTraffics }}
+   * Starts recording the network traffics.
+   * This also resets recorded network requests.
    *
+   * ```js
+   * I.startRecordingTraffic();
+   * ```
+   *
+   * @return {void}
    */
   startRecordingTraffic() {
     this.flushNetworkTraffics();
@@ -3008,34 +2957,44 @@ class Playwright extends Helper {
   }
 
   /**
-   * {{> grabRecordedNetworkTraffics }}
-   */
+  *  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>> }
+  *
+  */
   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.');
     }
 
-    const promises = this.requests.map(async (request) => {
-      const resp = await request.response;
-      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.
-      }
+    const requests = await this.requests;
+    const promises = requests.map(async (request) => request.response.then(
+      async (response) => {
+        let body;
+        try {
+          // There's no 'body' for some requests (redirect etc...)
+          body = JSON.parse((await response.body()).toString());
+        } catch (e) {
+          // only interested in JSON, not HTML responses.
+        }
 
-      return {
-        url: resp.url(),
-        response: {
-          status: resp.status(),
-          statusText: resp.statusText(),
+        request.response = {
+          status: response.status(),
+          statusText: response.statusText(),
           body,
-        },
-      };
-    });
+        };
+      },
+    ));
+    await Promise.all(promises);
 
-    return Promise.all(promises);
+    return this.requests;
   }
 
   /**
@@ -3117,14 +3076,18 @@ class Playwright extends Helper {
   }
 
   /**
-   * {{> flushNetworkTraffics }}
+   * Resets all recorded network requests.
    */
   flushNetworkTraffics() {
     this.requests = [];
   }
 
   /**
-   * {{> stopRecordingTraffic }}
+   * Stops recording of network traffic. Recorded traffic is not flashed.
+   *
+   * ```js
+   * I.stopRecordingTraffic();
+   * ```
    */
   stopRecordingTraffic() {
     this.page.removeAllListeners('request');
@@ -3132,7 +3095,42 @@ class Playwright extends Helper {
   }
 
   /**
-   * {{> seeTraffic }}
+   * 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<*> }
    */
   async seeTraffic({
     name, url, parameters, requestPostData, timeout = 10,
@@ -3214,7 +3212,18 @@ class Playwright extends Helper {
   }
 
   /**
-   * {{> dontSeeTraffic }}
+   * 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({ name, url }) {
@@ -3926,3 +3935,134 @@ 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;
+};