codeceptjs 3.5.15 → 3.6.0

package/lib/helper/Puppeteer.js

@@ -36,13 +36,14 @@ const ElementNotFound = require('./errors/ElementNotFound');
 const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnectionRefused');
 const Popup = require('./extras/Popup');
 const Console = require('./extras/Console');
-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');
+const {
+  dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics,
+} = require('./network/actions');
 
 let puppeteer;
 let perfTiming;
@@ -226,6 +227,17 @@ class Puppeteer extends Helper {
     this.sessionPages = {};
     this.activeSessionName = '';
 
+    // for network stuff
+    this.requests = [];
+    this.recording = false;
+    this.recordedAtLeastOnce = false;
+
+    // for websocket messages
+    this.webSocketMessages = [];
+    this.recordingWebSocketMessages = false;
+    this.recordedWebSocketMessagesAtLeastOnce = false;
+    this.cdpSession = null;
+
     // override defaults with config
     this._setConfig(config);
   }
@@ -2078,7 +2090,6 @@ class Puppeteer extends Helper {
   async waitNumberOfVisibleElements(locator, num, sec) {
     const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
     locator = new Locator(locator, 'css');
-    await this.context;
     let waiter;
     const context = await this._getContext();
     if (locator.isCSS()) {
@@ -2459,6 +2470,214 @@ class Puppeteer extends Helper {
     if (prop) return rect[prop];
     return rect;
   }
+
+  /**
+   * Mocks network request using [`Request Interception`](https://pptr.dev/next/guides/request-interception)
+   *
+   * ```js
+   * I.mockRoute(/(\.png$)|(\.jpg$)/, route => route.abort());
+   * ```
+   * This method allows intercepting and mocking requests & responses. [Learn more about it](https://pptr.dev/next/guides/request-interception)
+   *
+   * @param {string|RegExp} [url] URL, regex or pattern for to match URL
+   * @param {function} [handler] a function to process request
+   */
+  async mockRoute(url, handler) {
+    await this.page.setRequestInterception(true);
+
+    this.page.on('request', interceptedRequest => {
+      if (interceptedRequest.url().match(url)) {
+        // @ts-ignore
+        handler(interceptedRequest);
+      } else {
+        interceptedRequest.continue();
+      }
+    });
+  }
+
+  /**
+   * Stops network mocking created by `mockRoute`.
+   *
+   * ```js
+   * I.stopMockingRoute(/(\.png$)|(\.jpg$)/);
+   * ```
+   *
+   * @param {string|RegExp} [url] URL, regex or pattern for to match URL
+   */
+  async stopMockingRoute(url) {
+    await this.page.setRequestInterception(true);
+
+    this.page.off('request');
+
+    // Resume normal request handling for the given URL
+    this.page.on('request', interceptedRequest => {
+      if (interceptedRequest.url().includes(url)) {
+        interceptedRequest.continue();
+      } else {
+        interceptedRequest.continue();
+      }
+    });
+  }
+
+  /**
+   *
+   * {{> flushNetworkTraffics }}
+   */
+  flushNetworkTraffics() {
+    flushNetworkTraffics.call(this);
+  }
+
+  /**
+   *
+   * {{> stopRecordingTraffic }}
+   */
+  stopRecordingTraffic() {
+    stopRecordingTraffic.call(this);
+  }
+
+  /**
+   * {{> startRecordingTraffic }}
+   *
+   */
+  async startRecordingTraffic() {
+    this.flushNetworkTraffics();
+    this.recording = true;
+    this.recordedAtLeastOnce = true;
+
+    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);
+    });
+  }
+
+  /**
+   *
+   * {{> grabRecordedNetworkTraffics }}
+   */
+  async grabRecordedNetworkTraffics() {
+    return grabRecordedNetworkTraffics.call(this);
+  }
+
+  /**
+   *
+   * {{> seeTraffic }}
+   */
+  async seeTraffic({
+    name, url, parameters, requestPostData, timeout = 10,
+  }) {
+    await seeTraffic.call(this, ...arguments);
+  }
+
+  /**
+   *
+   * {{> dontSeeTraffic }}
+   *
+   */
+  dontSeeTraffic({ name, url }) {
+    dontSeeTraffic.call(this, ...arguments);
+  }
+
+  async getNewCDPSession() {
+    const client = await this.page.target().createCDPSession();
+    return client;
+  }
+
+  /**
+   * {{> startRecordingWebSocketMessages }}
+   */
+  async startRecordingWebSocketMessages() {
+    this.flushWebSocketMessages();
+    this.recordingWebSocketMessages = true;
+    this.recordedWebSocketMessagesAtLeastOnce = true;
+
+    this.cdpSession = await this.getNewCDPSession();
+    await this.cdpSession.send('Network.enable');
+    await this.cdpSession.send('Page.enable');
+
+    this.cdpSession.on(
+      'Network.webSocketFrameReceived',
+      (payload) => {
+        this._logWebsocketMessages(this._getWebSocketLog('RECEIVED', payload));
+      },
+    );
+
+    this.cdpSession.on(
+      'Network.webSocketFrameSent',
+      (payload) => {
+        this._logWebsocketMessages(this._getWebSocketLog('SENT', payload));
+      },
+    );
+
+    this.cdpSession.on(
+      'Network.webSocketFrameError',
+      (payload) => {
+        this._logWebsocketMessages(this._getWebSocketLog('ERROR', payload));
+      },
+    );
+  }
+
+  /**
+   * {{> stopRecordingWebSocketMessages }}
+   */
+  async stopRecordingWebSocketMessages() {
+    await this.cdpSession.send('Network.disable');
+    await this.cdpSession.send('Page.disable');
+    this.page.removeAllListeners('Network');
+    this.recordingWebSocketMessages = false;
+  }
+
+  /**
+   *  Grab the recording WS messages
+   *
+   * @return { Array<any>|undefined }
+   *
+   */
+  grabWebSocketMessages() {
+    if (!this.recordingWebSocketMessages) {
+      if (!this.recordedWebSocketMessagesAtLeastOnce) {
+        throw new Error('Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.');
+      }
+    }
+    return this.webSocketMessages;
+  }
+
+  /**
+   * Resets all recorded WS messages.
+   */
+  flushWebSocketMessages() {
+    this.webSocketMessages = [];
+  }
+
+  _getWebSocketMessage(payload) {
+    if (payload.errorMessage) {
+      return payload.errorMessage;
+    }
+
+    return payload.response.payloadData;
+  }
+
+  _getWebSocketLog(prefix, payload) {
+    return `${prefix} ID: ${payload.requestId} TIMESTAMP: ${payload.timestamp} (${new Date().toISOString()})\n\n${this._getWebSocketMessage(payload)}\n\n`;
+  }
+
+  _logWebsocketMessages(message) {
+    this.webSocketMessages += message;
+  }
 }
 
 module.exports = Puppeteer;

package/lib/helper/WebDriver.js

@@ -2,10 +2,8 @@ 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');
@@ -30,13 +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 { allParameterValuePairsMatchExtreme, extractQueryObjects, createAdvancedTestResults } = require('./networkTraffics/utils');
+const {
+  dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics,
+} = require('./network/actions');
 
 const SHADOW = 'shadow';
 const webRoot = 'body';
@@ -2758,42 +2757,7 @@ class WebDriver extends Helper {
       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);
+    return grabRecordedNetworkTraffics.call(this);
   }
 
   /**
@@ -2809,47 +2773,7 @@ class WebDriver extends Helper {
       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()}`,
-      );
-    }
+    await seeTraffic.call(this, ...arguments);
   }
 
   /**
@@ -2864,69 +2788,7 @@ class WebDriver extends Helper {
       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;
+    dontSeeTraffic.call(this, ...arguments);
   }
 }
 

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/{networkTraffics → network}/utils.js

@@ -129,9 +129,59 @@ const allRequestPostDataValuePairsMatchExtreme = (RequestPostDataObject, advance
   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,
 };

package/lib/index.js

@@ -39,5 +39,8 @@ module.exports = {
   /** @type {typeof CodeceptJS.Locator} */
   locator: require('./locator'),
 
+  heal: require('./heal'),
+  ai: require('./ai'),
+
   Workers: require('./workers'),
 };

package/lib/listener/steps.js

@@ -67,7 +67,6 @@ module.exports = function () {
   });
 
   event.dispatcher.on(event.step.started, (step) => {
-    if (store.debugMode) return;
     step.startedAt = +new Date();
     step.test = currentTest;
     if (currentHook && Array.isArray(currentHook.steps)) {
@@ -78,7 +77,6 @@ module.exports = function () {
   });
 
   event.dispatcher.on(event.step.finished, (step) => {
-    if (store.debugMode) return;
     step.finishedAt = +new Date();
     if (step.startedAt) step.duration = step.finishedAt - step.startedAt;
     debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`);