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

package/lib/helper/Puppeteer.js

@@ -5,7 +5,6 @@ const path = require('path');
 
 const Helper = require('@codeceptjs/helper');
 const { v4: uuidv4 } = require('uuid');
-const promiseRetry = require('promise-retry');
 const Locator = require('../locator');
 const recorder = require('../recorder');
 const store = require('../store');
@@ -40,9 +39,6 @@ const findReact = require('./extras/React');
 const { highlightElement } = require('./scripts/highlightElement');
 const { blurElement } = require('./scripts/blurElement');
 const { focusElement } = require('./scripts/focusElement');
-const {
-  dontSeeElementError, seeElementError, dontSeeElementInDOMError, seeElementInDOMError,
-} = require('./errors/ElementAssertion');
 
 let puppeteer;
 let perfTiming;
@@ -78,7 +74,7 @@ const consoleLogStore = new Console();
  * @prop {string} [browser=chrome] - can be changed to `firefox` when using [puppeteer-firefox](https://codecept.io/helpers/Puppeteer-firefox).
  * @prop {object} [chrome] - pass additional [Puppeteer run options](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions).
  * @prop {boolean} [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
- */
+*/
 const config = {};
 
 /**
@@ -369,7 +365,7 @@ class Puppeteer extends Helper {
         this.debugSection('Incognito Tab', 'opened');
         this.activeSessionName = name;
 
-        const bc = await this.browser.createBrowserContext();
+        const bc = await this.browser.createIncognitoBrowserContext();
         await bc.newPage();
 
         // Create a new page inside context.
@@ -486,7 +482,7 @@ class Puppeteer extends Helper {
     if (!page) return;
     page.setDefaultNavigationTimeout(this.options.getPageTimeout);
     this.context = await this.page.$('body');
-    if (this.options.browser === 'chrome') {
+    if (this.config.browser === 'chrome') {
       await page.bringToFront();
     }
   }
@@ -599,7 +595,14 @@ class Puppeteer extends Helper {
   }
 
   async _evaluateHandeInContext(...args) {
-    const context = await this._getContext();
+    let context = await this._getContext();
+
+    if (context.constructor.name === 'Frame') {
+      // Currently there is no evalateHandle for the Frame object
+      // https://github.com/GoogleChrome/puppeteer/issues/1051
+      context = await context.executionContext();
+    }
+
     return context.evaluateHandle(...args);
   }
 
@@ -651,9 +654,9 @@ class Puppeteer extends Helper {
       url = this.options.url + url;
     }
 
-    if (this.options.basicAuth && (this.isAuthenticated !== true)) {
+    if (this.config.basicAuth && (this.isAuthenticated !== true)) {
       if (url.includes(this.options.url)) {
-        await this.page.authenticate(this.options.basicAuth);
+        await this.page.authenticate(this.config.basicAuth);
         this.isAuthenticated = true;
       }
     }
@@ -877,8 +880,7 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async _locate(locator) {
-    const context = await this.context;
-    return findElements.call(this, context, locator);
+    return findElements(await this.context, locator);
   }
 
   /**
@@ -904,7 +906,7 @@ class Puppeteer extends Helper {
    * ```
    */
   async _locateClickable(locator) {
-    const context = await this.context;
+    const context = await this._getContext();
     return findClickable.call(this, context, locator);
   }
 
@@ -1036,11 +1038,8 @@ class Puppeteer extends Helper {
     els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v);
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
     els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el));
-    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'));
   }
 
   /**
@@ -1052,11 +1051,8 @@ class Puppeteer extends Helper {
     els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v);
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
     els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el));
-    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'));
   }
 
   /**
@@ -1064,11 +1060,7 @@ class Puppeteer 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'));
   }
 
   /**
@@ -1076,11 +1068,7 @@ class Puppeteer 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'));
   }
 
   /**
@@ -1630,38 +1618,6 @@ class Puppeteer extends Helper {
     if (cookie[0]) return cookie[0];
   }
 
-  /**
-   * {{> 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.page.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 });
-  }
-
   /**
    * {{> clearCookie }}
    */
@@ -1681,8 +1637,8 @@ class Puppeteer extends Helper {
    * {{> executeScript }}
    */
   async executeScript(...args) {
-    let context = await this._getContext();
-    if (this.context && this.context.constructor.name === 'CdpFrame') {
+    let context = this.page;
+    if (this.context && this.context.constructor.name === 'Frame') {
       context = this.context; // switching to iframe context
     }
     return context.evaluate.apply(context, args);
@@ -1763,7 +1719,7 @@ class Puppeteer extends Helper {
    */
   async grabHTMLFromAll(locator) {
     const els = await this._locate(locator);
-    const values = await Promise.all(els.map(el => el.evaluate(element => element.innerHTML, el)));
+    const values = await Promise.all(els.map(el => el.executionContext().evaluate(element => element.innerHTML, el)));
     return values;
   }
 
@@ -1786,7 +1742,7 @@ class Puppeteer extends Helper {
    */
   async grabCssPropertyFromAll(locator, cssProperty) {
     const els = await this._locate(locator);
-    const res = await Promise.all(els.map(el => el.evaluate(el => JSON.parse(JSON.stringify(getComputedStyle(el))), el)));
+    const res = await Promise.all(els.map(el => el.executionContext().evaluate(el => JSON.parse(JSON.stringify(getComputedStyle(el))), el)));
     const cssValues = res.map(props => props[toCamelCase(cssProperty)]);
 
     return cssValues;
@@ -1848,34 +1804,33 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async seeAttributesOnElements(locator, attributes) {
-    const elements = await this._locate(locator);
-    assertElementExists(elements, locator);
-
-    const expectedAttributes = Object.entries(attributes);
+    const res = await this._locate(locator);
+    assertElementExists(res, locator);
 
-    const valuesPromises = elements.map(async (element) => {
-      const elementAttributes = {};
-      await Promise.all(expectedAttributes.map(async ([attribute, expectedValue]) => {
-        const actualValue = await element.evaluate((el, attr) => el[attr] || el.getAttribute(attr), attribute);
-        elementAttributes[attribute] = actualValue;
-      }));
-      return elementAttributes;
+    const elemAmount = res.length;
+    const commands = [];
+    res.forEach((el) => {
+      Object.keys(attributes).forEach((prop) => {
+        commands.push(el
+          .executionContext()
+          .evaluateHandle((el, attr) => el[attr] || el.getAttribute(attr), el, prop)
+          .then(el => el.jsonValue()));
+      });
     });
-
-    const actualAttributes = await Promise.all(valuesPromises);
-
-    const matchingElements = actualAttributes.filter((attrs) => expectedAttributes.every(([attribute, expectedValue]) => {
-      const actualValue = attrs[attribute];
-      if (!actualValue) return false;
-      if (actualValue.toString().match(new RegExp(expectedValue.toString()))) return true;
-      return expectedValue === actualValue;
-    }));
-
-    const elementsCount = elements.length;
-    const matchingCount = matchingElements.length;
-
-    return equals(`all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`)
-      .assert(matchingCount, elementsCount);
+    let attrs = await Promise.all(commands);
+    const values = Object.keys(attributes).map(key => attributes[key]);
+    if (!Array.isArray(attrs)) attrs = [attrs];
+    let chunked = chunkArray(attrs, values.length);
+    chunked = chunked.filter((val) => {
+      for (let i = 0; i < val.length; ++i) {
+        const _actual = Number.isNaN(val[i]) || (typeof values[i]) === 'string' ? val[i] : Number.parseInt(values[i], 10);
+        const _expected = Number.isNaN(values[i]) || (typeof values[i]) === 'string' ? values[i] : Number.parseInt(values[i], 10);
+        // if the attribute doesn't exist, returns false as well
+        if (!_actual || !_actual.includes(_expected)) return false;
+      }
+      return true;
+    });
+    return equals(`all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`).assert(chunked.length, elemAmount);
   }
 
   /**
@@ -2131,7 +2086,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout });
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout });
+      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2152,7 +2107,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, visible: true });
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, visible: true });
+      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout, visible: true });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2171,7 +2126,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true });
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true });
+      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout, hidden: true });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2189,7 +2144,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true });
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true });
+      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout, hidden: true });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2215,7 +2170,7 @@ class Puppeteer extends Helper {
   }
 
   async _getContext() {
-    if (this.context && this.context.constructor.name === 'CdpFrame') {
+    if (this.context && this.context.constructor.name === 'Frame') {
       return this.context;
     }
     return this.page;
@@ -2338,37 +2293,35 @@ class Puppeteer extends Helper {
   async switchTo(locator) {
     if (Number.isInteger(locator)) {
       // Select by frame index of current context
-      let frames = [];
+
+      let childFrames = null;
       if (this.context && typeof this.context.childFrames === 'function') {
-        frames = await this.context.childFrames();
+        childFrames = this.context.childFrames();
       } else {
-        frames = await this.page.mainFrame().childFrames();
+        childFrames = this.page.mainFrame().childFrames();
       }
 
-      if (locator >= 0 && locator < frames.length) {
-        this.context = frames[locator];
+      if (locator >= 0 && locator < childFrames.length) {
+        this.context = childFrames[locator];
       } else {
-        throw new Error('Frame index out of bounds');
+        throw new Error('Element #invalidIframeSelector was not found by text|CSS|XPath');
       }
       return;
     }
-
     if (!locator) {
-      this.context = await this.page.mainFrame();
+      this.context = await this.page.mainFrame().$('body');
       return;
     }
 
-    // Select iframe by selector
+    // iframe by selector
     const els = await this._locate(locator);
     assertElementExists(els, locator);
-
-    const iframeElement = els[0];
-    const contentFrame = await iframeElement.contentFrame();
+    const contentFrame = await els[0].contentFrame();
 
     if (contentFrame) {
       this.context = contentFrame;
     } else {
-      throw new Error('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
+      this.context = els[0];
     }
   }
 
@@ -2464,7 +2417,7 @@ class Puppeteer extends Helper {
 module.exports = Puppeteer;
 
 async function findElements(matcher, locator) {
-  if (locator.react) return findReactElements.call(this, locator);
+  if (locator.react) return findReact(matcher.executionContext(), locator);
   locator = new Locator(locator, 'css');
   if (!locator.isXPath()) return matcher.$$(locator.simplify());
   // puppeteer version < 19.4.0 is no longer supported. This one is backward support.
@@ -2501,7 +2454,7 @@ async function proceedClick(locator, context = null, options = {}) {
 }
 
 async function findClickable(matcher, locator) {
-  if (locator.react) return findReactElements.call(this, locator);
+  if (locator.react) return findReact(matcher.executionContext(), locator);
   locator = new Locator(locator);
   if (!locator.isFuzzy()) return findElements.call(this, matcher, locator);
 
@@ -2850,70 +2803,3 @@ function highlightActiveElement(element, context) {
     highlightElement(element, context);
   }
 }
-
-function _waitForElement(locator, options) {
-  try {
-    return this.context.waitForXPath(locator.value, options);
-  } catch (e) {
-    return this.context.waitForSelector(`::-p-xpath(${locator.value})`, options);
-  }
-}
-
-async function findReactElements(locator, props = {}, state = {}) {
-  const resqScript = await fs.promises.readFile(require.resolve('resq'), 'utf-8');
-  await this.page.evaluate(resqScript.toString());
-
-  await this.page.evaluate(() => window.resq.waitToLoadReact());
-  const arrayHandle = await this.page.evaluateHandle((obj) => {
-    const { selector, props, state } = obj;
-    let elements = window.resq.resq$$(selector);
-    if (Object.keys(props).length) {
-      elements = elements.byProps(props);
-    }
-    if (Object.keys(state).length) {
-      elements = elements.byState(state);
-    }
-
-    if (!elements.length) {
-      return [];
-    }
-
-    // resq returns an array of HTMLElements if the React component is a fragment
-    // this avoids having nested arrays of nodes which the driver does not understand
-    // [[div, div], [div, div]] => [div, div, div, div]
-    let nodes = [];
-
-    elements.forEach((element) => {
-      let { node, isFragment } = element;
-
-      if (!node) {
-        isFragment = true;
-        node = element.children;
-      }
-
-      if (isFragment) {
-        nodes = nodes.concat(node);
-      } else {
-        nodes.push(node);
-      }
-    });
-
-    return [...nodes];
-  }, {
-    selector: locator.react,
-    props: locator.props || {},
-    state: locator.state || {},
-  });
-
-  const properties = await arrayHandle.getProperties();
-  const result = [];
-  for (const property of properties.values()) {
-    const elementHandle = property.asElement();
-    if (elementHandle) {
-      result.push(elementHandle);
-    }
-  }
-
-  await arrayHandle.dispose();
-  return result;
-}

package/lib/helper/REST.js

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