oxygen-cli 1.25.0 → 1.27.0

package/build/ox_services/service-devtools/submodule-network.js

@@ -4,13 +4,21 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 require("source-map-support/register");
+
 var _OxygenSubModule = require("../../core/OxygenSubModule");
+
 var _chromeHar = require("chrome-har");
+
 var _helper = _interopRequireDefault(require("../../errors/helper"));
+
 var _OxygenError = _interopRequireDefault(require("../../errors/OxygenError"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const observe = ['Page.domContentEventFired', 'Page.fileChooserOpened', 'Page.frameAttached', 'Page.frameDetached', 'Page.frameNavigated', 'Page.interstitialHidden', 'Page.interstitialShown', 'Page.javascriptDialogClosed', 'Page.javascriptDialogOpening', 'Page.lifecycleEvent', 'Page.loadEventFired', 'Page.windowOpen', 'Page.frameClearedScheduledNavigation', 'Page.frameScheduledNavigation', 'Page.compilationCacheProduced', 'Page.downloadProgress', 'Page.downloadWillBegin', 'Page.frameRequestedNavigation', 'Page.frameResized', 'Page.frameStartedLoading', 'Page.frameStoppedLoading', 'Page.navigatedWithinDocument', 'Page.screencastFrame', 'Page.screencastVisibilityChanged', 'Network.dataReceived', 'Network.eventSourceMessageReceived', 'Network.loadingFailed', 'Network.loadingFinished', 'Network.requestServedFromCache', 'Network.requestWillBeSent', 'Network.responseReceived', 'Network.webSocketClosed', 'Network.webSocketCreated', 'Network.webSocketFrameError', 'Network.webSocketFrameReceived', 'Network.webSocketFrameSent', 'Network.webSocketHandshakeResponseReceived', 'Network.webSocketWillSendHandshakeRequest', 'Network.requestWillBeSentExtraInfo', 'Network.resourceChangedPriority', 'Network.responseReceivedExtraInfo', 'Network.signedExchangeReceived', 'Network.requestIntercepted'];
+
+const observe = ['Page.domContentEventFired', 'Page.frameAttached', 'Page.loadEventFired', 'Page.frameRequestedNavigation', 'Page.frameStartedLoading', 'Page.navigatedWithinDocument', 'Network.dataReceived', 'Network.loadingFailed', 'Network.loadingFinished', 'Network.requestServedFromCache', 'Network.requestWillBeSent', 'Network.responseReceived', 'Network.requestWillBeSentExtraInfo', 'Network.resourceChangedPriority', 'Network.responseReceivedExtraInfo'];
+
 class NetworkSubModule extends _OxygenSubModule.OxygenSubModule {
   constructor(name, parent) {
     super(name, parent);
@@ -18,11 +26,13 @@ class NetworkSubModule extends _OxygenSubModule.OxygenSubModule {
     this._collectData = false;
     this._events = [];
   }
+
   init(devTools) {
     if (!devTools || !this._parent || !this._parent.getDriver || typeof this._parent.getDriver !== 'function' || !this._parent.getDriver()) {
       super.init();
       return false;
     }
+
     this._devTools = devTools;
     this._driver = this._parent.getDriver();
     observe.forEach(method => {
@@ -38,6 +48,7 @@ class NetworkSubModule extends _OxygenSubModule.OxygenSubModule {
     super.init();
     return true;
   }
+
   async dispose() {
     try {
       if (this._driver) {
@@ -48,46 +59,56 @@ class NetworkSubModule extends _OxygenSubModule.OxygenSubModule {
         await this._driver.emit('Network.close');
       }
     } catch (e) {}
+
     this._devTools = null;
     this._driver = null;
     this._events = [];
     super.dispose();
   }
+
   start() {
     this._collectData = true;
     this._events = [];
   }
+
   stop() {
     this._collectData = false;
   }
+
   async getRequests() {
     return await this._getEntries();
   }
+
   async _getEntries() {
     try {
       const har = (0, _chromeHar.harFromMessages)(this._events);
+
       if (har && har.log && har.log.entries && har.log.entries.map) {
         har.log.entries.reverse();
         return await Promise.all(har.log.entries.map(async item => {
           let responseBody = {};
+
           try {
             responseBody = await this._driver.cdp('Network', 'getResponseBody', {
               requestId: item._requestId
             });
           } catch (e) {}
+
           if (responseBody && responseBody.body) {
             try {
               responseBody.body = JSON.parse(responseBody.body);
             } catch (e) {}
           }
+
           let requestPostData = {};
+
           try {
             requestPostData = await this._driver.cdp('Network', 'getRequestPostData', {
               requestId: item._requestId
             });
           } catch (e) {}
-          return {
-            ...item,
+
+          return { ...item,
             url: item.request.url,
             requestId: item._requestId,
             ...item.response,
@@ -102,147 +123,205 @@ class NetworkSubModule extends _OxygenSubModule.OxygenSubModule {
       return [];
     }
   }
+
   async waitForUrl(pattern, timeout = 60 * 1000) {
     if (!this._driver || !this._isInitialized || !this._parent) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');
     }
+
     if (!this._collectData) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network.start()` must be executed prior to using `network` commands.');
     }
+
     this._parent.helpers.assertArgument(pattern, 'pattern');
+
     this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');
+
     const start = Date.now();
+
     while (Date.now() - start < timeout) {
       const networkRequests = await this._getEntries();
+
       for (let req of networkRequests) {
         if (pattern.constructor.name === 'RegExp' && pattern.test(req.url) || pattern === req.url) {
           return req;
         }
       }
+
       await this._driver.pause(500);
     }
+
     throw new _OxygenError.default(_helper.default.errorCode.TIMEOUT, `No request matching the URL "${pattern}" was found.`);
   }
+
   async waitForNotUrl(pattern, timeout = 60 * 1000) {
     if (!this._driver || !this._isInitialized || !this._parent) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');
     }
+
     if (!this._collectData) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network.start()` must be executed prior to using `network` commands.');
     }
+
     this._parent.helpers.assertArgument(pattern, 'pattern');
+
     this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');
+
     const start = Date.now();
+
     while (Date.now() - start < timeout) {
       const networkRequests = await this._getEntries();
+
       for (let req of networkRequests) {
         if (pattern.constructor.name === 'RegExp' && pattern.test(req.url) || pattern === req.url) {
           throw new _OxygenError.default(_helper.default.errorCode.TIMEOUT, `A request matching the URL "${pattern}" was found.`);
         }
       }
+
       await this._driver.pause(500);
     }
   }
+
   async waitFor(matcher, timeout = 60 * 1000) {
     if (!this._driver || !this._isInitialized || !this._parent) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` module is not initialized.');
     }
+
     if (!this._collectData) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');
     }
+
     this._parent.helpers.assertArgument(matcher, 'matcher');
+
     this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');
+
     const start = Date.now();
+
     while (Date.now() - start < timeout) {
       const networkRequests = await this._getEntries();
+
       for (var req of networkRequests) {
         if (matcher(req)) {
           return req;
         }
       }
+
       await this._driver.pause(500);
     }
+
     throw new _OxygenError.default(_helper.default.errorCode.TIMEOUT, 'No request found using the provided matcher.');
   }
+
   async assertUrl(url, timeout = 60 * 1000) {
     if (!this._driver || !this._isInitialized || !this._parent) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');
     }
+
     if (!this._collectData) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');
     }
+
     this._parent.helpers.assertArgument(url, 'url');
+
     this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');
+
     const start = Date.now();
+
     while (Date.now() - start < timeout) {
       const networkRequests = await this._getEntries();
+
       for (let req of networkRequests) {
         if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {
           return req;
         }
       }
+
       await this._driver.pause(500);
     }
+
     throw new _OxygenError.default(_helper.default.errorCode.ASSERT_ERROR, `No request matching the URL "${url}" was found.`);
   }
+
   async assertStatusCode(url, statusCode, failureMessage = null, timeout = 60 * 1000) {
     if (!this._driver || !this._isInitialized || !this._parent) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');
     }
+
     if (!this._collectData) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');
     }
+
     this._parent.helpers.assertArgument(url, 'url');
+
     this._parent.helpers.assertArgument(statusCode, 'statusCode');
+
     this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');
+
     const start = Date.now();
     let matchedReq = null;
+
     while (Date.now() - start < timeout && !matchedReq) {
       const networkRequests = await this._getEntries();
+
       for (let req of networkRequests) {
         if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {
           matchedReq = req;
           break;
         }
       }
+
       !matchedReq && (await this._driver.pause(500));
     }
+
     if (!matchedReq) {
       throw new _OxygenError.default(_helper.default.errorCode.ASSERT_ERROR, `No request matching the URL "${url}" was found.`);
     }
+
     if (statusCode !== matchedReq.status) {
       const message = failureMessage || `The expected status code "${statusCode}" does not match "${matchedReq.status}".`;
       throw new _OxygenError.default(_helper.default.errorCode.ASSERT_ERROR, message);
     }
   }
+
   async assertResponseContent(url, content, failureMessage = null, timeout = 60 * 1000) {
     if (!this._driver || !this._isInitialized || !this._parent) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');
     }
+
     if (!this._collectData) {
       throw new _OxygenError.default(_helper.default.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');
     }
+
     this._parent.helpers.assertArgument(url, 'url');
+
     this._parent.helpers.assertArgument(content, 'content');
+
     this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');
+
     const start = Date.now();
     let matchedReq = null;
+
     while (Date.now() - start < timeout && !matchedReq) {
       const networkRequests = await this._getEntries();
+
       for (let req of networkRequests) {
         if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {
           matchedReq = req;
           break;
         }
       }
+
       !matchedReq && (await this._driver.pause(500));
     }
+
     if (!matchedReq) {
       throw new _OxygenError.default(_helper.default.errorCode.ASSERT_ERROR, `No request matching the URL "${url}" was found.`);
     }
+
     const resp = await this._driver.cdp('Network', 'getResponseBody', {
       requestId: matchedReq.requestId
     });
+
     if (resp && resp.body && !resp.base64Encoded) {
       if (content.constructor.name === 'RegExp' && (content.test(resp.body) || resp.body.indexOf(content) > -1)) {
         return true;
@@ -252,6 +331,14 @@ class NetworkSubModule extends _OxygenSubModule.OxygenSubModule {
       }
     }
   }
+
+  async blockUrls(urls) {
+    await this._driver.cdp('Network', 'setBlockedURLs', {
+      urls
+    });
+  }
+
 }
+
 exports.default = NetworkSubModule;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["observe","NetworkSubModule","OxygenSubModule","constructor","name","parent","_devTools","_collectData","_events","init","devTools","_parent","getDriver","_driver","forEach","method","on","params","push","dispose","removeListener","emit","e","start","stop","getRequests","_getEntries","har","harFromMessages","log","entries","map","reverse","Promise","all","item","responseBody","cdp","requestId","_requestId","body","JSON","parse","requestPostData","url","request","response","waitForUrl","pattern","timeout","_isInitialized","OxError","errHelper","errorCode","MODULE_NOT_INITIALIZED_ERROR","helpers","assertArgument","assertArgumentTimeout","Date","now","networkRequests","req","test","pause","TIMEOUT","waitForNotUrl","waitFor","matcher","assertUrl","ASSERT_ERROR","assertStatusCode","statusCode","failureMessage","matchedReq","status","message","assertResponseContent","content","resp","base64Encoded","indexOf"],"sources":["../../../src/ox_services/service-devtools/submodule-network.js"],"sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/**\r\n * Provides methods for monitoring and analyzing Chrome browser network activities.\r\n*/\r\nimport { OxygenSubModule } from '../../core/OxygenSubModule';\r\nimport { harFromMessages } from 'chrome-har';\r\nimport errHelper from '../../errors/helper';\r\nimport OxError from '../../errors/OxygenError';\r\n\r\nconst observe = [\r\n    'Page.domContentEventFired',\r\n    'Page.fileChooserOpened',\r\n    'Page.frameAttached',\r\n    'Page.frameDetached',\r\n    'Page.frameNavigated',\r\n    'Page.interstitialHidden',\r\n    'Page.interstitialShown',\r\n    'Page.javascriptDialogClosed',\r\n    'Page.javascriptDialogOpening',\r\n    'Page.lifecycleEvent',\r\n    'Page.loadEventFired',\r\n    'Page.windowOpen',\r\n    'Page.frameClearedScheduledNavigation',\r\n    'Page.frameScheduledNavigation',\r\n    'Page.compilationCacheProduced',\r\n    'Page.downloadProgress',\r\n    'Page.downloadWillBegin',\r\n    'Page.frameRequestedNavigation',\r\n    'Page.frameResized',\r\n    'Page.frameStartedLoading',\r\n    'Page.frameStoppedLoading',\r\n    'Page.navigatedWithinDocument',\r\n    'Page.screencastFrame',\r\n    'Page.screencastVisibilityChanged',\r\n    'Network.dataReceived',\r\n    'Network.eventSourceMessageReceived',\r\n    'Network.loadingFailed',\r\n    'Network.loadingFinished',\r\n    'Network.requestServedFromCache',\r\n    'Network.requestWillBeSent',\r\n    'Network.responseReceived',\r\n    'Network.webSocketClosed',\r\n    'Network.webSocketCreated',\r\n    'Network.webSocketFrameError',\r\n    'Network.webSocketFrameReceived',\r\n    'Network.webSocketFrameSent',\r\n    'Network.webSocketHandshakeResponseReceived',\r\n    'Network.webSocketWillSendHandshakeRequest',\r\n    'Network.requestWillBeSentExtraInfo',\r\n    'Network.resourceChangedPriority',\r\n    'Network.responseReceivedExtraInfo',\r\n    'Network.signedExchangeReceived',\r\n    'Network.requestIntercepted'\r\n];\r\nexport default class NetworkSubModule extends OxygenSubModule {\r\n    constructor(name, parent) {\r\n        super(name, parent);\r\n        this._devTools = null;\r\n        this._collectData = false;\r\n        this._events = [];\r\n    }\r\n\r\n    init(devTools) {\r\n        if (!devTools || !this._parent || !this._parent.getDriver || typeof this._parent.getDriver !== 'function' || !this._parent.getDriver()) {\r\n            super.init();\r\n            return false;\r\n        }\r\n        this._devTools = devTools;\r\n        this._driver = this._parent.getDriver();\r\n\r\n        observe.forEach(method => {\r\n            this._driver.on(method, params => {\r\n                if (this._collectData) {\r\n                    this._events.push({ method, params });\r\n                }\r\n            });\r\n        });\r\n\r\n        super.init();\r\n        return true;\r\n    }\r\n\r\n    async dispose() {\r\n\r\n        try {\r\n            if (this._driver) {\r\n\r\n                observe.forEach(async method => {\r\n                    await this._driver.removeListener(method, () => {});\r\n                });\r\n\r\n                await this._driver.emit('Network.disable');\r\n                await this._driver.emit('Network.close');\r\n            }\r\n        } catch (e) {\r\n            // ignore errors;\r\n        }\r\n\r\n        this._devTools = null;\r\n        this._driver = null;\r\n        this._events = [];\r\n        super.dispose();\r\n    }\r\n\r\n    /**\r\n     * @summary Begin collecting network requests.\r\n     * @description Any previously collected requests will be discarded. Network request collection is supported only on Chrome 63 and later.\r\n     * @function start\r\n     * @example <caption>[javascript] Usage example</caption>\r\n     * web.init();\r\n     * web.network.start();\r\n     * web.open(\"https://www.yourwebsite.com\");\r\n     * // print the collected request so far:\r\n     * let requests = web.network.getRequests();\r\n     * for (let req of requests) {\r\n     *   log.info(req);\r\n     * }\r\n     * // wait for a request using a verbatim URL match:\r\n     * web.network.waitForUrl('https://www.yourwebsite.com/foo/bar');\r\n     * // wait for a request using a regular expression URL match:\r\n     * web.network.waitForUrl(/https:\\/\\/.*\\/foo\\/bar/);\r\n     * // wait for a request using a custom matcher:\r\n     * web.network.waitFor(function (request) {\r\n     *   return request.statusText === 'OK' && request.url === 'https://www.yourwebsite.com/foo/bar';\r\n     * });\r\n     */\r\n    start() {\r\n        this._collectData = true;\r\n        this._events = [];\r\n    }\r\n\r\n    /**\r\n     * @summary Stop collecting network requests.\r\n     * @function stop\r\n     */\r\n    stop() {\r\n        this._collectData = false;\r\n    }\r\n\r\n    /**\r\n     * @summary Return all the collected network requests so far.\r\n     * @function getRequests\r\n     * @return {Object[]} Array containing network requests.\r\n     */\r\n    async getRequests() {\r\n        return await this._getEntries();\r\n    }\r\n\r\n    async _getEntries() {\r\n        try {\r\n            const har = harFromMessages(this._events);\r\n\r\n            if (har && har.log && har.log.entries && har.log.entries.map) {\r\n                har.log.entries.reverse();\r\n                return await Promise.all(har.log.entries.map(async (item) => {\r\n                    // backward compatibility\r\n\r\n                    let responseBody = {};\r\n                    try {\r\n                        responseBody = await this._driver.cdp('Network','getResponseBody', {\r\n                            requestId: item._requestId\r\n                        });\r\n                    } catch (e) {\r\n                        // ignore getResponseBody errors\r\n                    }\r\n\r\n                    if (responseBody && responseBody.body) {\r\n                        try {\r\n                            responseBody.body = JSON.parse(responseBody.body);\r\n                        } catch (e) {\r\n                            // ignore parse errors\r\n                        }\r\n                    }\r\n\r\n                    let requestPostData = {};\r\n                    try {\r\n                        requestPostData = await this._driver.cdp('Network','getRequestPostData', {\r\n                            requestId: item._requestId\r\n                        });\r\n                    } catch (e) {\r\n                        // ignore getRequestPostData errors\r\n                    }\r\n\r\n                    return {\r\n                        ...item,\r\n                        url: item.request.url,\r\n                        requestId: item._requestId,\r\n                        ...item.response,\r\n                        responseBody,\r\n                        requestPostData\r\n                    };\r\n                }));\r\n            } else {\r\n                return [];\r\n            }\r\n        } catch (e) {\r\n            return [];\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Wait for a network request matching the specified URL.\r\n     * @function waitForUrl\r\n     * @param {String|RegExp} pattern - An URL to match verbatim or a RegExp.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async waitForUrl(pattern, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(pattern, 'pattern');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (pattern.constructor.name === 'RegExp' && pattern.test(req.url) || pattern === req.url) {\r\n                    return req;\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n        throw new OxError(errHelper.errorCode.TIMEOUT, `No request matching the URL \"${pattern}\" was found.`);\r\n    }\r\n\r\n    /**\r\n     * @summary Fail the test if request with a matching URL was received within the specified time frame.\r\n     * @function waitForNotUrl\r\n     * @param {String|RegExp} pattern - An URL to match verbatim or a RegExp.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     */\r\n    async waitForNotUrl(pattern, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(pattern, 'pattern');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (pattern.constructor.name === 'RegExp' && pattern.test(req.url) || pattern === req.url) {\r\n                    throw new OxError(errHelper.errorCode.TIMEOUT, `A request matching the URL \"${pattern}\" was found.`);\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Wait for a network request.\r\n     * @function networkWaitFor\r\n     * @param {Function} matcher - Matching function. Should return true on match, or false otherwise.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async waitFor(matcher, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(matcher, 'matcher');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (var req of networkRequests) {\r\n                if (matcher(req)) {\r\n                    return req;\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n        throw new OxError(errHelper.errorCode.TIMEOUT, 'No request found using the provided matcher.');\r\n    }\r\n\r\n    /**\r\n     * @summary Assert if network request matching the specified URL.\r\n     * @function assertUrl\r\n     * @param {String|RegExp} url - A request URL to match verbatim or a RegExp.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async assertUrl(url, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(url, 'url');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {\r\n                    return req;\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n        throw new OxError(errHelper.errorCode.ASSERT_ERROR, `No request matching the URL \"${url}\" was found.`);\r\n    }\r\n\r\n    /**\r\n     * @summary Assert whether HTTP response status code matches the specified value.\r\n     * @function assertStatusCode\r\n     * @param {String|RegExp} url - A request URL to match verbatim or a RegExp.\r\n     * @param {Number} statusCode - A response status code to match verbatim or a RegExp.\r\n     * @param {String=} failureMessage - An optional failure message.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async assertStatusCode(url, statusCode, failureMessage = null, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(url, 'url');\r\n        this._parent.helpers.assertArgument(statusCode, 'statusCode');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        let matchedReq = null;\r\n        while (Date.now() - start < timeout && !matchedReq) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {\r\n                    matchedReq = req;\r\n                    break;\r\n                }\r\n            }\r\n            !matchedReq && await this._driver.pause(500);\r\n        }\r\n        if (!matchedReq) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `No request matching the URL \"${url}\" was found.`);\r\n        }\r\n        if (statusCode !== matchedReq.status) {\r\n            const message = failureMessage || `The expected status code \"${statusCode}\" does not match \"${matchedReq.status}\".`;\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Assert whether HTTP response content matches the specified value or pattern.\r\n     * @function assertResponseContent\r\n     * @param {String|RegExp} url - A request URL to match verbatim or a RegExp.\r\n     * @param {String|RegExp} content - A response body content to match verbatim or a RegExp.\r\n     * @param {String=} failureMessage - An optional failure message.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async assertResponseContent(url, content, failureMessage = null, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(url, 'url');\r\n        this._parent.helpers.assertArgument(content, 'content');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        let matchedReq = null;\r\n        while (Date.now() - start < timeout && !matchedReq) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {\r\n                    matchedReq = req;\r\n                    break;\r\n                }\r\n            }\r\n            !matchedReq && await this._driver.pause(500);\r\n        }\r\n        if (!matchedReq) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `No request matching the URL \"${url}\" was found.`);\r\n        }\r\n        const resp = await this._driver.cdp('Network','getResponseBody', {\r\n            requestId: matchedReq.requestId\r\n        });\r\n        if (resp && resp.body && !resp.base64Encoded) {\r\n            if (content.constructor.name === 'RegExp' && (content.test(resp.body) || resp.body.indexOf(content) > -1)) {\r\n                return true;\r\n            }\r\n            else {\r\n                const message = failureMessage || `Response \"${url}\" body content does not match \"${content}.`;\r\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\r\n            }\r\n        }\r\n    }\r\n\r\n}"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/ox_services/service-devtools/submodule-network.js"],"names":["observe","NetworkSubModule","OxygenSubModule","constructor","name","parent","_devTools","_collectData","_events","init","devTools","_parent","getDriver","_driver","forEach","method","on","params","push","dispose","removeListener","emit","e","start","stop","getRequests","_getEntries","har","log","entries","map","reverse","Promise","all","item","responseBody","cdp","requestId","_requestId","body","JSON","parse","requestPostData","url","request","response","waitForUrl","pattern","timeout","_isInitialized","OxError","errHelper","errorCode","MODULE_NOT_INITIALIZED_ERROR","helpers","assertArgument","assertArgumentTimeout","Date","now","networkRequests","req","test","pause","TIMEOUT","waitForNotUrl","waitFor","matcher","assertUrl","ASSERT_ERROR","assertStatusCode","statusCode","failureMessage","matchedReq","status","message","assertResponseContent","content","resp","base64Encoded","indexOf","blockUrls","urls"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/**\r\n * Provides methods for monitoring and analyzing Chrome browser network activities.\r\n*/\r\nimport { OxygenSubModule } from '../../core/OxygenSubModule';\r\nimport { harFromMessages } from 'chrome-har';\r\nimport errHelper from '../../errors/helper';\r\nimport OxError from '../../errors/OxygenError';\r\n\r\n// below are the events that need to be observed for \"chrome-har\" module to generate a proper HAR file\r\nconst observe = [\r\n    'Page.domContentEventFired',\r\n    //'Page.fileChooserOpened',\r\n    'Page.frameAttached',\r\n    //'Page.frameDetached',\r\n    //'Page.frameNavigated',\r\n    //'Page.interstitialHidden',\r\n    //'Page.interstitialShown',\r\n    //'Page.javascriptDialogClosed',\r\n    //'Page.javascriptDialogOpening',\r\n    //'Page.lifecycleEvent',\r\n    'Page.loadEventFired',\r\n    //'Page.windowOpen',\r\n    //'Page.frameClearedScheduledNavigation',\r\n    //'Page.frameScheduledNavigation',\r\n    //'Page.compilationCacheProduced',\r\n    //'Page.downloadProgress',\r\n    //'Page.downloadWillBegin',\r\n    'Page.frameRequestedNavigation',\r\n    //'Page.frameResized',\r\n    'Page.frameStartedLoading',\r\n    //'Page.frameStoppedLoading',\r\n    'Page.navigatedWithinDocument',\r\n    //'Page.screencastFrame',\r\n    //'Page.screencastVisibilityChanged',\r\n    'Network.dataReceived',\r\n    //'Network.eventSourceMessageReceived',\r\n    'Network.loadingFailed',\r\n    'Network.loadingFinished',\r\n    'Network.requestServedFromCache',\r\n    'Network.requestWillBeSent',\r\n    'Network.responseReceived',\r\n    //'Network.webSocketClosed',\r\n    //'Network.webSocketCreated',\r\n    //'Network.webSocketFrameError',\r\n    //'Network.webSocketFrameReceived',\r\n    //'Network.webSocketFrameSent',\r\n    //'Network.webSocketHandshakeResponseReceived',\r\n    //'Network.webSocketWillSendHandshakeRequest',\r\n    'Network.requestWillBeSentExtraInfo',\r\n    'Network.resourceChangedPriority',\r\n    'Network.responseReceivedExtraInfo',\r\n    //'Network.signedExchangeReceived',\r\n    //'Network.requestIntercepted'\r\n];\r\nexport default class NetworkSubModule extends OxygenSubModule {\r\n    constructor(name, parent) {\r\n        super(name, parent);\r\n        this._devTools = null;\r\n        this._collectData = false;\r\n        this._events = [];\r\n    }\r\n\r\n    init(devTools) {\r\n        if (!devTools || !this._parent || !this._parent.getDriver || typeof this._parent.getDriver !== 'function' || !this._parent.getDriver()) {\r\n            super.init();\r\n            return false;\r\n        }\r\n        this._devTools = devTools;\r\n        this._driver = this._parent.getDriver();\r\n\r\n        observe.forEach(method => {\r\n            this._driver.on(method, params => {\r\n                if (this._collectData) {\r\n                    this._events.push({ method, params });\r\n                }\r\n            });\r\n        });\r\n\r\n        super.init();\r\n        return true;\r\n    }\r\n\r\n    async dispose() {\r\n\r\n        try {\r\n            if (this._driver) {\r\n\r\n                observe.forEach(async method => {\r\n                    await this._driver.removeListener(method, () => {});\r\n                });\r\n\r\n                await this._driver.emit('Network.disable');\r\n                await this._driver.emit('Network.close');\r\n            }\r\n        } catch (e) {\r\n            // ignore errors;\r\n        }\r\n\r\n        this._devTools = null;\r\n        this._driver = null;\r\n        this._events = [];\r\n        super.dispose();\r\n    }\r\n\r\n    /**\r\n     * @summary Begin collecting network requests.\r\n     * @description Any previously collected requests will be discarded. Network request collection is supported only on Chrome 63 and later.\r\n     * @function start\r\n     * @example <caption>[javascript] Usage example</caption>\r\n     * web.init();\r\n     * web.network.start();\r\n     * web.open(\"https://www.yourwebsite.com\");\r\n     * // print the collected request so far:\r\n     * let requests = web.network.getRequests();\r\n     * for (let req of requests) {\r\n     *   log.info(req);\r\n     * }\r\n     * // wait for a request using a verbatim URL match:\r\n     * web.network.waitForUrl('https://www.yourwebsite.com/foo/bar');\r\n     * // wait for a request using a regular expression URL match:\r\n     * web.network.waitForUrl(/https:\\/\\/.*\\/foo\\/bar/);\r\n     * // wait for a request using a custom matcher:\r\n     * web.network.waitFor(function (request) {\r\n     *   return request.statusText === 'OK' && request.url === 'https://www.yourwebsite.com/foo/bar';\r\n     * });\r\n     */\r\n    start() {\r\n        this._collectData = true;\r\n        this._events = [];\r\n    }\r\n\r\n    /**\r\n     * @summary Stop collecting network requests.\r\n     * @function stop\r\n     */\r\n    stop() {\r\n        this._collectData = false;\r\n    }\r\n\r\n    /**\r\n     * @summary Return all the collected network requests so far.\r\n     * @function getRequests\r\n     * @return {Object[]} Array containing network requests.\r\n     */\r\n    async getRequests() {\r\n        return await this._getEntries();\r\n    }\r\n\r\n    async _getEntries() {\r\n        try {\r\n            const har = harFromMessages(this._events);\r\n\r\n            if (har && har.log && har.log.entries && har.log.entries.map) {\r\n                har.log.entries.reverse();\r\n                return await Promise.all(har.log.entries.map(async (item) => {\r\n                    // backward compatibility\r\n\r\n                    let responseBody = {};\r\n                    try {\r\n                        responseBody = await this._driver.cdp('Network','getResponseBody', {\r\n                            requestId: item._requestId\r\n                        });\r\n                    } catch (e) {\r\n                        // ignore getResponseBody errors\r\n                    }\r\n\r\n                    if (responseBody && responseBody.body) {\r\n                        try {\r\n                            responseBody.body = JSON.parse(responseBody.body);\r\n                        } catch (e) {\r\n                            // ignore parse errors\r\n                        }\r\n                    }\r\n\r\n                    let requestPostData = {};\r\n                    try {\r\n                        requestPostData = await this._driver.cdp('Network','getRequestPostData', {\r\n                            requestId: item._requestId\r\n                        });\r\n                    } catch (e) {\r\n                        // ignore getRequestPostData errors\r\n                    }\r\n\r\n                    return {\r\n                        ...item,\r\n                        url: item.request.url,\r\n                        requestId: item._requestId,\r\n                        ...item.response,\r\n                        responseBody,\r\n                        requestPostData\r\n                    };\r\n                }));\r\n            } else {\r\n                return [];\r\n            }\r\n        } catch (e) {\r\n            return [];\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Wait for a network request matching the specified URL.\r\n     * @function waitForUrl\r\n     * @param {String|RegExp} pattern - An URL to match verbatim or a RegExp.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async waitForUrl(pattern, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(pattern, 'pattern');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (pattern.constructor.name === 'RegExp' && pattern.test(req.url) || pattern === req.url) {\r\n                    return req;\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n        throw new OxError(errHelper.errorCode.TIMEOUT, `No request matching the URL \"${pattern}\" was found.`);\r\n    }\r\n\r\n    /**\r\n     * @summary Fail the test if request with a matching URL was received within the specified time frame.\r\n     * @function waitForNotUrl\r\n     * @param {String|RegExp} pattern - An URL to match verbatim or a RegExp.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     */\r\n    async waitForNotUrl(pattern, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(pattern, 'pattern');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (pattern.constructor.name === 'RegExp' && pattern.test(req.url) || pattern === req.url) {\r\n                    throw new OxError(errHelper.errorCode.TIMEOUT, `A request matching the URL \"${pattern}\" was found.`);\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Wait for a network request.\r\n     * @function networkWaitFor\r\n     * @param {Function} matcher - Matching function. Should return true on match, or false otherwise.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async waitFor(matcher, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(matcher, 'matcher');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (var req of networkRequests) {\r\n                if (matcher(req)) {\r\n                    return req;\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n        throw new OxError(errHelper.errorCode.TIMEOUT, 'No request found using the provided matcher.');\r\n    }\r\n\r\n    /**\r\n     * @summary Assert if network request matching the specified URL.\r\n     * @function assertUrl\r\n     * @param {String|RegExp} url - A request URL to match verbatim or a RegExp.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async assertUrl(url, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(url, 'url');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        while (Date.now() - start < timeout) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {\r\n                    return req;\r\n                }\r\n            }\r\n            await this._driver.pause(500);\r\n        }\r\n        throw new OxError(errHelper.errorCode.ASSERT_ERROR, `No request matching the URL \"${url}\" was found.`);\r\n    }\r\n\r\n    /**\r\n     * @summary Assert whether HTTP response status code matches the specified value.\r\n     * @function assertStatusCode\r\n     * @param {String|RegExp} url - A request URL to match verbatim or a RegExp.\r\n     * @param {Number} statusCode - A response status code to match verbatim or a RegExp.\r\n     * @param {String=} failureMessage - An optional failure message.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async assertStatusCode(url, statusCode, failureMessage = null, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(url, 'url');\r\n        this._parent.helpers.assertArgument(statusCode, 'statusCode');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        let matchedReq = null;\r\n        while (Date.now() - start < timeout && !matchedReq) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {\r\n                    matchedReq = req;\r\n                    break;\r\n                }\r\n            }\r\n            !matchedReq && await this._driver.pause(500);\r\n        }\r\n        if (!matchedReq) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `No request matching the URL \"${url}\" was found.`);\r\n        }\r\n        if (statusCode !== matchedReq.status) {\r\n            const message = failureMessage || `The expected status code \"${statusCode}\" does not match \"${matchedReq.status}\".`;\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Assert whether HTTP response content matches the specified value or pattern.\r\n     * @function assertResponseContent\r\n     * @param {String|RegExp} url - A request URL to match verbatim or a RegExp.\r\n     * @param {String|RegExp} content - A response body content to match verbatim or a RegExp.\r\n     * @param {String=} failureMessage - An optional failure message.\r\n     * @param {Number=} timeout - Timeout. Default is 60 seconds.\r\n     * @return {Object} Network request details if the network request was found.\r\n     */\r\n    async assertResponseContent(url, content, failureMessage = null, timeout = 60*1000) {\r\n        if (!this._driver || !this._isInitialized || !this._parent) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`network` or `web` module is not initialized.');\r\n        }\r\n\r\n        if (!this._collectData) {\r\n            throw new OxError(errHelper.errorCode.MODULE_NOT_INITIALIZED_ERROR, '`web.network.start()` must be executed prior to using `network` commands.');\r\n        }\r\n\r\n        this._parent.helpers.assertArgument(url, 'url');\r\n        this._parent.helpers.assertArgument(content, 'content');\r\n        this._parent.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n        const start = Date.now();\r\n        let matchedReq = null;\r\n        while (Date.now() - start < timeout && !matchedReq) {\r\n            const networkRequests = await this._getEntries();\r\n            for (let req of networkRequests) {\r\n                if (url.constructor.name === 'RegExp' && url.test(req.url) || url === req.url) {\r\n                    matchedReq = req;\r\n                    break;\r\n                }\r\n            }\r\n            !matchedReq && await this._driver.pause(500);\r\n        }\r\n        if (!matchedReq) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `No request matching the URL \"${url}\" was found.`);\r\n        }\r\n        const resp = await this._driver.cdp('Network','getResponseBody', {\r\n            requestId: matchedReq.requestId\r\n        });\r\n        if (resp && resp.body && !resp.base64Encoded) {\r\n            if (content.constructor.name === 'RegExp' && (content.test(resp.body) || resp.body.indexOf(content) > -1)) {\r\n                return true;\r\n            }\r\n            else {\r\n                const message = failureMessage || `Response \"${url}\" body content does not match \"${content}.`;\r\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Sets a list of request URLs to be blocked from loading.\r\n     * @function blockUrls\r\n     * @param {Array<String>} urls - A list of URLs that match the requests to be blocked.\r\n     */\r\n    async blockUrls(urls) {\r\n        await this._driver.cdp('Network','setBlockedURLs', {\r\n            urls\r\n        });\r\n    }\r\n}"]}

package/build/ox_services/service-devtools.js

@@ -4,49 +4,66 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 require("source-map-support/register");
+
 var _devtoolsService = _interopRequireDefault(require("@wdio/devtools-service"));
+
 var _OxygenService = _interopRequireDefault(require("../core/OxygenService"));
+
 var _submoduleNetwork = _interopRequireDefault(require("./service-devtools/submodule-network"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const CHROME_BROWSER = 'chrome';
+
 class DevToolsService extends _OxygenService.default {
   constructor(options, ctx, results, logger) {
     super(options, ctx, results, logger);
     this._subModules = {};
     this.isServiceInitialized = true;
   }
+
   onModuleLoaded(module) {
     if (!module || !module.getDriver || typeof module.getDriver !== 'function' || !module.getCapabilities || typeof module.getCapabilities !== 'function') {
       return;
     }
+
     const networkSubmodule = new _submoduleNetwork.default('network', module);
     module.addSubModule('network', networkSubmodule);
     this._subModules[module.name] = networkSubmodule;
   }
+
   async onModuleInitialized(module) {
     if (!module || !module.getDriver || typeof module.getDriver !== 'function' || !module.getCapabilities || typeof module.getCapabilities !== 'function') {
       return;
     }
+
     const submodule = this._subModules[module.name];
+
     if (!submodule || submodule.isInitialized) {
       return;
     }
+
     let options = {};
     const capabilities = module.getCapabilities() || {};
     const {
       browserName
     } = capabilities;
     this._driver = module.getDriver();
+
     if (this._driver && this._driver.capabilities && this._driver.capabilities['goog:chromeOptions'] && this._driver.capabilities['goog:chromeOptions']['debuggerAddress']) {
       options.debuggerAddress = this._driver.capabilities['goog:chromeOptions']['debuggerAddress'];
     }
+
     if (this._driver.provider === null && browserName && browserName.toLowerCase() === CHROME_BROWSER) {
       const devToolsSvc = new _devtoolsService.default(options);
       const UNSUPPORTED_ERROR_MESSAGE = devToolsSvc.beforeSession(null, capabilities);
+
       if (UNSUPPORTED_ERROR_MESSAGE) {
         console.log('UNSUPPORTED_ERROR_MESSAGE', UNSUPPORTED_ERROR_MESSAGE);
       }
+
       if (devToolsSvc._isSupported) {
         global.browser = module.getDriver();
         await devToolsSvc.before(null, null, this._driver);
@@ -54,13 +71,18 @@ class DevToolsService extends _OxygenService.default {
       }
     }
   }
+
   onModuleWillDispose(module) {
     const submodule = this._subModules[module.name];
+
     if (!submodule) {
       return;
     }
+
     submodule.dispose();
   }
+
 }
+
 exports.default = DevToolsService;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CHROME_BROWSER","DevToolsService","OxygenService","constructor","options","ctx","results","logger","_subModules","isServiceInitialized","onModuleLoaded","module","getDriver","getCapabilities","networkSubmodule","NetworkSubModule","addSubModule","name","onModuleInitialized","submodule","isInitialized","capabilities","browserName","_driver","debuggerAddress","provider","toLowerCase","devToolsSvc","WDIODevToolsService","UNSUPPORTED_ERROR_MESSAGE","beforeSession","console","log","_isSupported","global","browser","before","init","onModuleWillDispose","dispose"],"sources":["../../src/ox_services/service-devtools.js"],"sourcesContent":["/* eslint-disable no-unreachable */\r\nimport WDIODevToolsService from '@wdio/devtools-service';\r\n\r\nimport OxygenService from '../core/OxygenService';\r\nimport NetworkSubModule from './service-devtools/submodule-network';\r\n\r\nconst CHROME_BROWSER = 'chrome';\r\n\r\nexport default class DevToolsService extends OxygenService {\r\n    constructor(options, ctx, results, logger) {\r\n        super(options, ctx, results, logger);\r\n        // hash of webdriver based modules\r\n        this._subModules = {};\r\n        this.isServiceInitialized = true;\r\n    }\r\n    onModuleLoaded(module) {\r\n        // skip any module that does not implement .getDriver() method (e.g. not webdriver based)\r\n        if (!module || !module.getDriver || typeof module.getDriver !== 'function' || !module.getCapabilities || typeof module.getCapabilities !== 'function') {\r\n            return;\r\n        }\r\n\r\n        const networkSubmodule = new NetworkSubModule('network', module);\r\n        module.addSubModule('network', networkSubmodule);\r\n        this._subModules[module.name] = networkSubmodule;\r\n    }\r\n    async onModuleInitialized(module) {\r\n        // skip any module that does not implement getDriver method (e.g. not webdriver based)\r\n        if (!module || !module.getDriver || typeof module.getDriver !== 'function' || !module.getCapabilities || typeof module.getCapabilities !== 'function') {\r\n            return;\r\n        }\r\n        const submodule = this._subModules[module.name];\r\n        if (!submodule || submodule.isInitialized) {\r\n            return;\r\n        }\r\n\r\n        let options = {};\r\n        const capabilities = module.getCapabilities() || {};\r\n        const { browserName } = capabilities;\r\n        this._driver = module.getDriver();\r\n\r\n        if (\r\n            this._driver &&\r\n            this._driver.capabilities &&\r\n            this._driver.capabilities['goog:chromeOptions'] &&\r\n            this._driver.capabilities['goog:chromeOptions']['debuggerAddress']\r\n        ) {\r\n            options.debuggerAddress = this._driver.capabilities['goog:chromeOptions']['debuggerAddress'];\r\n        }\r\n\r\n        // if we are not using any 3rd party provider\r\n        if (this._driver.provider === null && browserName && browserName.toLowerCase() === CHROME_BROWSER) {\r\n            // initialize DevToolsService and hook it to the current webdriver object\r\n            const devToolsSvc = new WDIODevToolsService(options);\r\n            const UNSUPPORTED_ERROR_MESSAGE = devToolsSvc.beforeSession(null, capabilities);\r\n\r\n            if (UNSUPPORTED_ERROR_MESSAGE) {\r\n                console.log('UNSUPPORTED_ERROR_MESSAGE', UNSUPPORTED_ERROR_MESSAGE);\r\n            }\r\n\r\n            if (devToolsSvc._isSupported) {\r\n                // change global.browser to the current module's webdriver instance\r\n                // const orgGlobalBrowser = global.browser;\r\n                global.browser = module.getDriver();\r\n                await devToolsSvc.before(null, null, this._driver);\r\n                submodule.init(devToolsSvc);\r\n                // global.browser = orgGlobalBrowser;\r\n            }\r\n        }\r\n    }\r\n    onModuleWillDispose(module) {\r\n        const submodule = this._subModules[module.name];\r\n        if (!submodule) {\r\n            return;\r\n        }\r\n        submodule.dispose();\r\n    }\r\n}"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ox_services/service-devtools.js"],"names":["CHROME_BROWSER","DevToolsService","OxygenService","constructor","options","ctx","results","logger","_subModules","isServiceInitialized","onModuleLoaded","module","getDriver","getCapabilities","networkSubmodule","NetworkSubModule","addSubModule","name","onModuleInitialized","submodule","isInitialized","capabilities","browserName","_driver","debuggerAddress","provider","toLowerCase","devToolsSvc","WDIODevToolsService","UNSUPPORTED_ERROR_MESSAGE","beforeSession","console","log","_isSupported","global","browser","before","init","onModuleWillDispose","dispose"],"mappings":"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","sourcesContent":["/* eslint-disable no-unreachable */\r\nimport WDIODevToolsService from '@wdio/devtools-service';\r\n\r\nimport OxygenService from '../core/OxygenService';\r\nimport NetworkSubModule from './service-devtools/submodule-network';\r\n\r\nconst CHROME_BROWSER = 'chrome';\r\n\r\nexport default class DevToolsService extends OxygenService {\r\n    constructor(options, ctx, results, logger) {\r\n        super(options, ctx, results, logger);\r\n        // hash of webdriver based modules\r\n        this._subModules = {};\r\n        this.isServiceInitialized = true;\r\n    }\r\n    onModuleLoaded(module) {\r\n        // skip any module that does not implement .getDriver() method (e.g. not webdriver based)\r\n        if (!module || !module.getDriver || typeof module.getDriver !== 'function' || !module.getCapabilities || typeof module.getCapabilities !== 'function') {\r\n            return;\r\n        }\r\n\r\n        const networkSubmodule = new NetworkSubModule('network', module);\r\n        module.addSubModule('network', networkSubmodule);\r\n        this._subModules[module.name] = networkSubmodule;\r\n    }\r\n    async onModuleInitialized(module) {\r\n        // skip any module that does not implement getDriver method (e.g. not webdriver based)\r\n        if (!module || !module.getDriver || typeof module.getDriver !== 'function' || !module.getCapabilities || typeof module.getCapabilities !== 'function') {\r\n            return;\r\n        }\r\n        const submodule = this._subModules[module.name];\r\n        if (!submodule || submodule.isInitialized) {\r\n            return;\r\n        }\r\n\r\n        let options = {};\r\n        const capabilities = module.getCapabilities() || {};\r\n        const { browserName } = capabilities;\r\n        this._driver = module.getDriver();\r\n\r\n        if (\r\n            this._driver &&\r\n            this._driver.capabilities &&\r\n            this._driver.capabilities['goog:chromeOptions'] &&\r\n            this._driver.capabilities['goog:chromeOptions']['debuggerAddress']\r\n        ) {\r\n            options.debuggerAddress = this._driver.capabilities['goog:chromeOptions']['debuggerAddress'];\r\n        }\r\n\r\n        // if we are not using any 3rd party provider\r\n        if (this._driver.provider === null && browserName && browserName.toLowerCase() === CHROME_BROWSER) {\r\n            // initialize DevToolsService and hook it to the current webdriver object\r\n            const devToolsSvc = new WDIODevToolsService(options);\r\n            const UNSUPPORTED_ERROR_MESSAGE = devToolsSvc.beforeSession(null, capabilities);\r\n\r\n            if (UNSUPPORTED_ERROR_MESSAGE) {\r\n                console.log('UNSUPPORTED_ERROR_MESSAGE', UNSUPPORTED_ERROR_MESSAGE);\r\n            }\r\n\r\n            if (devToolsSvc._isSupported) {\r\n                // change global.browser to the current module's webdriver instance\r\n                // const orgGlobalBrowser = global.browser;\r\n                global.browser = module.getDriver();\r\n                await devToolsSvc.before(null, null, this._driver);\r\n                submodule.init(devToolsSvc);\r\n                // global.browser = orgGlobalBrowser;\r\n            }\r\n        }\r\n    }\r\n    onModuleWillDispose(module) {\r\n        const submodule = this._subModules[module.name];\r\n        if (!submodule) {\r\n            return;\r\n        }\r\n        submodule.dispose();\r\n    }\r\n}"]}