webdriverio 7.17.0 → 7.18.0

package/build/commands/browser/getPuppeteer.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const logger_1 = __importDefault(require("@wdio/logger"));
+const constants_1 = require("../../constants");
+const log = (0, logger_1.default)('webdriverio');
+/**
+ * Get the [Puppeteer Browser instance](https://pptr.dev/#?product=Puppeteer&version=v5.1.0&show=api-class-browser)
+ * to run commands with Puppeteer. Note that all Puppeteer commands are
+ * asynchronous by default so in order to interchange between sync and async
+ * execution make sure to wrap your Puppeteer calls within a `browser.call`
+ * commands as shown in the example.
+ *
+ * :::info
+ *
+ * Note that using Puppeteer requires support for Chrome DevTools protocol and e.g.
+ * can not be used when running automated tests in the cloud. Find out more in the
+ * [Automation Protocols](/docs/automationProtocols) section.
+ *
+ * :::
+ *
+ * <example>
+    :getPuppeteer.test.js
+    it('should allow me to use Puppeteer', async () => {
+        // WebDriver command
+        await browser.url('https://webdriver.io')
+
+        const puppeteerBrowser = await browser.getPuppeteer()
+        // switch to Puppeteer
+        const metrics = await browser.call(async () => {
+            const pages = await puppeteerBrowser.pages()
+            pages[0].setGeolocation({ latitude: 59.95, longitude: 30.31667 })
+            return pages[0].metrics()
+        })
+
+        console.log(metrics.LayoutCount) // returns LayoutCount value
+    })
+ * </example>
+ *
+ * @return {PuppeteerBrowser}  initiated puppeteer instance connected to the browser
+ */
+async function getPuppeteer() {
+    var _a, _b, _c, _d, _e;
+    /**
+     * check if we already connected Puppeteer and if so return
+     * that instance
+     */
+    if ((_a = this.puppeteer) === null || _a === void 0 ? void 0 : _a.isConnected()) {
+        log.debug('Reusing existing puppeteer session');
+        return this.puppeteer;
+    }
+    const caps = this.capabilities.alwaysMatch || this.capabilities;
+    /**
+     * attach to a Selenium 4 CDP Session if it's returned in the capabilities
+     */
+    const cdpEndpoint = caps['se:cdp'];
+    if (cdpEndpoint) {
+        this.puppeteer = await puppeteer_core_1.default.connect({
+            browserWSEndpoint: cdpEndpoint,
+            defaultViewport: null
+        });
+        return this.puppeteer;
+    }
+    /**
+     * attach to a Selenoid\Moon CDP Session if there are Aerokube vendor capabilities
+     */
+    const requestedCapabilities = ((_b = this.requestedCapabilities) === null || _b === void 0 ? void 0 : _b.alwaysMatch) || this.requestedCapabilities;
+    const isAerokubeSession = requestedCapabilities['selenoid:options'] || requestedCapabilities['moon:options'];
+    if (isAerokubeSession) {
+        const { hostname, port } = this.options;
+        this.puppeteer = await puppeteer_core_1.default.connect({
+            browserWSEndpoint: `ws://${hostname}:${port}/devtools/${this.sessionId}`,
+            defaultViewport: null
+        });
+        return this.puppeteer;
+    }
+    /**
+     * attach to Chromium debugger session
+     */
+    const chromiumOptions = caps['goog:chromeOptions'] || caps['ms:edgeOptions'];
+    if (chromiumOptions && chromiumOptions.debuggerAddress) {
+        this.puppeteer = await puppeteer_core_1.default.connect({
+            browserURL: `http://${chromiumOptions.debuggerAddress}`,
+            defaultViewport: null
+        });
+        return this.puppeteer;
+    }
+    /**
+     * attach to Firefox debugger session
+     */
+    if (((_c = caps.browserName) === null || _c === void 0 ? void 0 : _c.toLowerCase()) === 'firefox') {
+        if (!caps.browserVersion) {
+            throw new Error('Can\'t find "browserVersion" in capabilities');
+        }
+        const majorVersion = parseInt(caps.browserVersion.split('.').shift() || '', 10);
+        if (majorVersion >= 79) {
+            const reqCaps = this.requestedCapabilities.alwaysMatch || this.requestedCapabilities;
+            const ffOptions = caps['moz:firefoxOptions'];
+            const ffArgs = (_d = reqCaps['moz:firefoxOptions']) === null || _d === void 0 ? void 0 : _d.args;
+            const rdPort = ffOptions && ffOptions.debuggerAddress
+                ? ffOptions.debuggerAddress
+                : (_e = ffArgs === null || ffArgs === void 0 ? void 0 : ffArgs[ffArgs.findIndex((arg) => arg === constants_1.FF_REMOTE_DEBUG_ARG) + 1]) !== null && _e !== void 0 ? _e : null;
+            if (!rdPort) {
+                throw new Error('Could\'t find remote debug port in Firefox options');
+            }
+            this.puppeteer = await puppeteer_core_1.default.connect({
+                browserURL: `http://localhost:${rdPort}`,
+                defaultViewport: null
+            });
+            return this.puppeteer;
+        }
+    }
+    throw new Error('Using DevTools capabilities is not supported for this session. ' +
+        'This feature is only supported for local testing on Chrome, Firefox and Chromium Edge.');
+}
+exports.default = getPuppeteer;

package/build/commands/browser/getWindowSize.d.ts

@@ -0,0 +1,25 @@
+interface BrowserSize {
+    width: number;
+    height: number;
+}
+/**
+ *
+ * Returns browser window size.
+ *
+ * <example>
+    :getWindowSize.js
+    it('should return browser window size', async () => {
+        const windowSize = await browser.getWindowSize();
+        console.log(windowSize);
+        // outputs `{ width: 1280, height: 767 }`
+    });
+ * </example>
+ *
+ * @alias browser.getWindowSize
+ * @return {Object} { x, y, width, height } for W3C or { width, height } for non W3C browser
+ * @type window
+ *
+ */
+export default function getWindowSize(this: WebdriverIO.Browser): Promise<BrowserSize>;
+export {};
+//# sourceMappingURL=getWindowSize.d.ts.map

package/build/commands/browser/getWindowSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWindowSize.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/getWindowSize.ts"],"names":[],"mappings":"AAEA,UAAU,WAAW;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAA8B,aAAa,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,wBASpE"}

package/build/commands/browser/getWindowSize.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+/**
+ *
+ * Returns browser window size.
+ *
+ * <example>
+    :getWindowSize.js
+    it('should return browser window size', async () => {
+        const windowSize = await browser.getWindowSize();
+        console.log(windowSize);
+        // outputs `{ width: 1280, height: 767 }`
+    });
+ * </example>
+ *
+ * @alias browser.getWindowSize
+ * @return {Object} { x, y, width, height } for W3C or { width, height } for non W3C browser
+ * @type window
+ *
+ */
+async function getWindowSize() {
+    const browser = (0, utils_1.getBrowserObject)(this);
+    if (!browser.isW3C) {
+        return browser._getWindowSize();
+    }
+    const { width, height } = await browser.getWindowRect();
+    return { width, height };
+}
+exports.default = getWindowSize;

package/build/commands/browser/keys.d.ts

@@ -0,0 +1,28 @@
+/**
+ *
+ * Send a sequence of key strokes to the active element. You can also use characters like
+ * "Left arrow" or "Back space". WebdriverIO will take care of translating them into unicode
+ * characters. You’ll find all supported characters [here](https://w3c.github.io/webdriver/webdriver-spec.html#keyboard-actions).
+ * To do that, the value has to correspond to a key from the table.
+ *
+ * Modifier like Ctrl, Shift, Alt and Meta will stay pressed so you need to trigger them again to release them.
+ * Modifiying a click however requires you to use the WebDriver Actions API through the [performActions](https://webdriver.io/docs/api/webdriver#performactions) method.
+ *
+ * <example>
+    :keys.js
+    it('copies text out of active element', async () => {
+        // copies text from an input element
+        const input = await $('#username')
+        await input.setValue('anonymous')
+
+        await browser.keys(['Meta', 'a'])
+        await browser.keys(['Meta', 'c'])
+    });
+ * </example>
+ *
+ * @param {String|String[]} value  The sequence of keys to type. An array or string must be provided.
+ * @see https://w3c.github.io/webdriver/#dispatching-actions
+ *
+ */
+export default function keys(this: WebdriverIO.Browser, value: string | string[]): Promise<void>;
+//# sourceMappingURL=keys.d.ts.map

package/build/commands/browser/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/keys.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,UAAU,IAAI,CACxB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,iBAoC3B"}

package/build/commands/browser/keys.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+/**
+ *
+ * Send a sequence of key strokes to the active element. You can also use characters like
+ * "Left arrow" or "Back space". WebdriverIO will take care of translating them into unicode
+ * characters. You’ll find all supported characters [here](https://w3c.github.io/webdriver/webdriver-spec.html#keyboard-actions).
+ * To do that, the value has to correspond to a key from the table.
+ *
+ * Modifier like Ctrl, Shift, Alt and Meta will stay pressed so you need to trigger them again to release them.
+ * Modifiying a click however requires you to use the WebDriver Actions API through the [performActions](https://webdriver.io/docs/api/webdriver#performactions) method.
+ *
+ * <example>
+    :keys.js
+    it('copies text out of active element', async () => {
+        // copies text from an input element
+        const input = await $('#username')
+        await input.setValue('anonymous')
+
+        await browser.keys(['Meta', 'a'])
+        await browser.keys(['Meta', 'c'])
+    });
+ * </example>
+ *
+ * @param {String|String[]} value  The sequence of keys to type. An array or string must be provided.
+ * @see https://w3c.github.io/webdriver/#dispatching-actions
+ *
+ */
+function keys(value) {
+    let keySequence = [];
+    /**
+     * replace key with corresponding unicode character
+     */
+    if (typeof value === 'string') {
+        keySequence = (0, utils_1.checkUnicode)(value, this.isDevTools);
+    }
+    else if (Array.isArray(value)) {
+        const charArray = value;
+        for (const charSet of charArray) {
+            keySequence = keySequence.concat((0, utils_1.checkUnicode)(charSet, this.isDevTools));
+        }
+    }
+    else {
+        throw new Error('"keys" command requires a string or array of strings as parameter');
+    }
+    /**
+     * JsonWireProtocol action
+     */
+    if (!this.isW3C) {
+        return this.sendKeys(keySequence);
+    }
+    /**
+     * W3C way of handle it key actions
+     */
+    const keyDownActions = keySequence.map((value) => ({ type: 'keyDown', value }));
+    const keyUpActions = keySequence.map((value) => ({ type: 'keyUp', value }));
+    return this.performActions([{
+            type: 'key',
+            id: 'keyboard',
+            actions: [...keyDownActions, ...keyUpActions]
+        }]).then(() => this.releaseActions());
+}
+exports.default = keys;

package/build/commands/browser/mock.d.ts

@@ -0,0 +1,111 @@
+import type Interception from '../../utils/interception/index';
+import type { Mock } from '../../types';
+import type { MockFilterOptions } from '../../utils/interception/types';
+export declare const SESSION_MOCKS: Record<string, Set<Interception>>;
+/**
+ * Mock the response of a request. You can define a mock based on a matching
+ * glob and corresponding header and status code. Calling the mock method
+ * returns a stub object that you can use to modify the response of the
+ * web resource.
+ *
+ * With the stub object you can then either return a custom response or
+ * have the request fail.
+ *
+ * There are 3 ways to modify the response:
+ * - return a custom JSON object (for stubbing API request)
+ * - replace web resource with a local file (service a modified JavaScript file) or
+ * - redirect resource to a different url
+ *
+ * :::info
+ *
+ * Note that using the `mock` command requires support for Chrome DevTools protocol and e.g.
+ * can not be used when running automated tests in the cloud. Find out more in the
+ * [Automation Protocols](/docs/automationProtocols) section.
+ *
+ * :::
+ *
+ * <example>
+    :mock.js
+    it('should mock network resources', async () => {
+        // via static string
+        const userListMock = await browser.mock('**' + '/users/list')
+        // or as regular expression
+        const userListMock = await browser.mock(/https:\/\/(domainA|domainB)\.com\/.+/)
+        // you can also specifying the mock even more by filtering resources
+        // by request or response headers, status code, postData, e.g. mock only responses with specific
+        // header set and statusCode
+        const strictMock = await browser.mock('**', {
+            // mock all json responses
+            statusCode: 200,
+            headers: { 'Content-Type': 'application/json' },
+            responseHeaders: { 'Cache-Control': 'no-cache' },
+            postData: 'foobar'
+        })
+
+        // comparator function
+        const apiV1Mock = await browser.mock('**' + '/api/v1', {
+            statusCode: (statusCode) => statusCode >= 200 && statusCode <= 203,
+            headers: (headers) => headers['Authorization'] && headers['Authorization'].startsWith('Bearer '),
+            responseHeaders: (headers) => headers['Impersonation'],
+            postData: (data) => typeof data === 'string' && data.includes('foo')
+        })
+    })
+
+    it('should modify API responses', async () => {
+        // filter by method
+        const todoMock = await browser.mock('**' + '/todos', {
+            method: 'get'
+        })
+
+        // mock an endpoint with a fixed fixture
+        mock.respond([{
+            title: 'Injected Todo',
+            order: null,
+            completed: false,
+            url: "http://todo-backend-express-knex.herokuapp.com/916"
+        }])
+
+        // respond with different status code or header
+        mock.respond([{
+            title: 'Injected Todo',
+            order: null,
+            completed: false,
+            url: "http://todo-backend-express-knex.herokuapp.com/916"
+        }], {
+            statusCode: 404,
+            headers: {
+                'x-custom-header': 'foobar'
+            }
+        })
+    })
+
+    it('should modify text assets', async () => {
+        const scriptMock = await browser.mock('**' + '/script.min.js')
+        scriptMock.respond('./tests/fixtures/script.js')
+    })
+
+    it('should redirect web resources', async () => {
+        const headerMock = await browser.mock('**' + '/header.png')
+        headerMock.respond('https://media.giphy.com/media/F9hQLAVhWnL56/giphy.gif')
+
+        const pageMock = await browser.mock('https://google.com/')
+        pageMock.respond('https://webdriver.io')
+        await browser.url('https://google.com')
+        console.log(await browser.getTitle()) // returns "WebdriverIO · Next-gen browser and mobile automation test framework for Node.js"
+    })
+ * </example>
+ *
+ * @alias browser.mock
+ * @param {String|RegExp}       url                             url to mock
+ * @param {MockFilterOptions=}  filterOptions                   filter mock resource by additional options
+ * @param {String|Function=}    filterOptions.method            filter resource by HTTP method
+ * @param {Object|Function=}    filterOptions.headers           filter resource by specific request headers
+ * @param {Object|Function=}    filterOptions.responseHeaders   filter resource by specific response headers
+ * @param {String|Function=}    filterOptions.postData          filter resource by request postData
+ * @param {Number|Function=}    filterOptions.statusCode        filter resource by response statusCode
+ * @return {Mock}                                               a mock object to modify the response
+ * @type utility
+ *
+ */
+export default function mock(this: WebdriverIO.Browser, url: string | RegExp, filterOptions?: MockFilterOptions): Promise<Mock>;
+//# sourceMappingURL=mock.d.ts.map

package/build/commands/browser/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/mock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,gCAAgC,CAAA;AAI9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAEvE,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAY,CAAC,CAAM,CAAA;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwGG;AACH,wBAA8B,IAAI,CAC9B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,aAAa,CAAC,EAAE,iBAAiB,iBA6DpC"}

package/build/commands/browser/mock.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_MOCKS = void 0;
+const devtools_1 = __importDefault(require("../../utils/interception/devtools"));
+const webdriver_1 = __importDefault(require("../../utils/interception/webdriver"));
+const utils_1 = require("../../utils");
+exports.SESSION_MOCKS = {};
+/**
+ * Mock the response of a request. You can define a mock based on a matching
+ * glob and corresponding header and status code. Calling the mock method
+ * returns a stub object that you can use to modify the response of the
+ * web resource.
+ *
+ * With the stub object you can then either return a custom response or
+ * have the request fail.
+ *
+ * There are 3 ways to modify the response:
+ * - return a custom JSON object (for stubbing API request)
+ * - replace web resource with a local file (service a modified JavaScript file) or
+ * - redirect resource to a different url
+ *
+ * :::info
+ *
+ * Note that using the `mock` command requires support for Chrome DevTools protocol and e.g.
+ * can not be used when running automated tests in the cloud. Find out more in the
+ * [Automation Protocols](/docs/automationProtocols) section.
+ *
+ * :::
+ *
+ * <example>
+    :mock.js
+    it('should mock network resources', async () => {
+        // via static string
+        const userListMock = await browser.mock('**' + '/users/list')
+        // or as regular expression
+        const userListMock = await browser.mock(/https:\/\/(domainA|domainB)\.com\/.+/)
+        // you can also specifying the mock even more by filtering resources
+        // by request or response headers, status code, postData, e.g. mock only responses with specific
+        // header set and statusCode
+        const strictMock = await browser.mock('**', {
+            // mock all json responses
+            statusCode: 200,
+            headers: { 'Content-Type': 'application/json' },
+            responseHeaders: { 'Cache-Control': 'no-cache' },
+            postData: 'foobar'
+        })
+
+        // comparator function
+        const apiV1Mock = await browser.mock('**' + '/api/v1', {
+            statusCode: (statusCode) => statusCode >= 200 && statusCode <= 203,
+            headers: (headers) => headers['Authorization'] && headers['Authorization'].startsWith('Bearer '),
+            responseHeaders: (headers) => headers['Impersonation'],
+            postData: (data) => typeof data === 'string' && data.includes('foo')
+        })
+    })
+
+    it('should modify API responses', async () => {
+        // filter by method
+        const todoMock = await browser.mock('**' + '/todos', {
+            method: 'get'
+        })
+
+        // mock an endpoint with a fixed fixture
+        mock.respond([{
+            title: 'Injected Todo',
+            order: null,
+            completed: false,
+            url: "http://todo-backend-express-knex.herokuapp.com/916"
+        }])
+
+        // respond with different status code or header
+        mock.respond([{
+            title: 'Injected Todo',
+            order: null,
+            completed: false,
+            url: "http://todo-backend-express-knex.herokuapp.com/916"
+        }], {
+            statusCode: 404,
+            headers: {
+                'x-custom-header': 'foobar'
+            }
+        })
+    })
+
+    it('should modify text assets', async () => {
+        const scriptMock = await browser.mock('**' + '/script.min.js')
+        scriptMock.respond('./tests/fixtures/script.js')
+    })
+
+    it('should redirect web resources', async () => {
+        const headerMock = await browser.mock('**' + '/header.png')
+        headerMock.respond('https://media.giphy.com/media/F9hQLAVhWnL56/giphy.gif')
+
+        const pageMock = await browser.mock('https://google.com/')
+        pageMock.respond('https://webdriver.io')
+        await browser.url('https://google.com')
+        console.log(await browser.getTitle()) // returns "WebdriverIO · Next-gen browser and mobile automation test framework for Node.js"
+    })
+ * </example>
+ *
+ * @alias browser.mock
+ * @param {String|RegExp}       url                             url to mock
+ * @param {MockFilterOptions=}  filterOptions                   filter mock resource by additional options
+ * @param {String|Function=}    filterOptions.method            filter resource by HTTP method
+ * @param {Object|Function=}    filterOptions.headers           filter resource by specific request headers
+ * @param {Object|Function=}    filterOptions.responseHeaders   filter resource by specific response headers
+ * @param {String|Function=}    filterOptions.postData          filter resource by request postData
+ * @param {Number|Function=}    filterOptions.statusCode        filter resource by response statusCode
+ * @return {Mock}                                               a mock object to modify the response
+ * @type utility
+ *
+ */
+async function mock(url, filterOptions) {
+    const NetworkInterception = this.isSauce ? webdriver_1.default : devtools_1.default;
+    if (!this.isSauce) {
+        await this.getPuppeteer();
+    }
+    if (!this.puppeteer) {
+        throw new Error('No Puppeteer connection could be established which is required to use this command');
+    }
+    const browser = (0, utils_1.getBrowserObject)(this);
+    const handle = await browser.getWindowHandle();
+    if (!exports.SESSION_MOCKS[handle]) {
+        exports.SESSION_MOCKS[handle] = new Set();
+    }
+    /**
+     * enable network Mocking if not already
+     */
+    if (exports.SESSION_MOCKS[handle].size === 0 && !this.isSauce) {
+        const pages = await this.puppeteer.pages();
+        /**
+         * get active page
+         */
+        let page;
+        for (let i = 0; i < pages.length && !page; i++) {
+            const isHidden = await pages[i].evaluate(() => document.hidden);
+            if (!isHidden) {
+                page = pages[i];
+            }
+        }
+        /**
+         * fallback to the first page
+         */
+        if (!page) {
+            page = pages[0];
+        }
+        const client = await page.target().createCDPSession();
+        await client.send('Fetch.enable', {
+            patterns: [{ requestStage: 'Request' }, { requestStage: 'Response' }]
+        });
+        client.on('Fetch.requestPaused', NetworkInterception
+            .handleRequestInterception(client, exports.SESSION_MOCKS[handle]));
+    }
+    const networkInterception = new NetworkInterception(url, filterOptions, browser);
+    exports.SESSION_MOCKS[handle].add(networkInterception);
+    if (this.isSauce) {
+        await networkInterception.init();
+    }
+    return networkInterception;
+}
+exports.default = mock;

package/build/commands/browser/mockClearAll.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Resets all information stored in all registered mocks of the session.
+ *
+ * <example>
+    :mockClearAll.js
+    it('should clear all mocks', async () => {
+        const docMock = await browser.mock('**', {
+            headers: { 'Content-Type': 'text/html' }
+        })
+        const jsMock = await browser.mock('**', {
+            headers: { 'Content-Type': 'application/javascript' }
+        })
+
+        await browser.url('http://guinea-pig.webdriver.io/')
+        console.log(docMock.calls.length, jsMock.calls.length) // returns "1 4"
+
+        await browser.url('http://guinea-pig.webdriver.io/')
+        console.log(docMock.calls.length, jsMock.calls.length) // returns "2 4" (JavaScript comes from cache)
+
+        await browser.mockClearAll()
+        console.log(docMock.calls.length, jsMock.calls.length) // returns "0 0"
+    })
+ * </example>
+ *
+ * @alias browser.mockClearAll
+ */
+export default function mockClearAll(): Promise<void>;
+//# sourceMappingURL=mockClearAll.d.ts.map

package/build/commands/browser/mockClearAll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockClearAll.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/mockClearAll.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAA8B,YAAY,kBAOzC"}

package/build/commands/browser/mockClearAll.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("@wdio/logger"));
+const mock_1 = require("./mock");
+const log = (0, logger_1.default)('webdriverio:mockClearAll');
+/**
+ * Resets all information stored in all registered mocks of the session.
+ *
+ * <example>
+    :mockClearAll.js
+    it('should clear all mocks', async () => {
+        const docMock = await browser.mock('**', {
+            headers: { 'Content-Type': 'text/html' }
+        })
+        const jsMock = await browser.mock('**', {
+            headers: { 'Content-Type': 'application/javascript' }
+        })
+
+        await browser.url('http://guinea-pig.webdriver.io/')
+        console.log(docMock.calls.length, jsMock.calls.length) // returns "1 4"
+
+        await browser.url('http://guinea-pig.webdriver.io/')
+        console.log(docMock.calls.length, jsMock.calls.length) // returns "2 4" (JavaScript comes from cache)
+
+        await browser.mockClearAll()
+        console.log(docMock.calls.length, jsMock.calls.length) // returns "0 0"
+    })
+ * </example>
+ *
+ * @alias browser.mockClearAll
+ */
+async function mockClearAll() {
+    for (const [handle, mocks] of Object.entries(mock_1.SESSION_MOCKS)) {
+        log.trace(`Clearing mocks for ${handle}`);
+        for (const mock of mocks) {
+            mock.clear();
+        }
+    }
+}
+exports.default = mockClearAll;

package/build/commands/browser/mockRestoreAll.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Restores all mock information and behavior stored in all registered
+ * mocks of the session.
+ *
+ * <example>
+    :mockRestoreAll.js
+    it('should restore all mocks', async () => {
+        const googleMock = await browser.mock('https://google.com/')
+        googleMock.respond('https://webdriver.io')
+        const wdioMock = await browser.mock('https://webdriver.io')
+        wdioMock.respond('http://json.org')
+
+        await browser.url('https://google.com/')
+        console.log(await browser.getTitle()) // JSON
+
+        await browser.mockRestoreAll()
+
+        await browser.url('https://google.com/')
+        console.log(await browser.getTitle()) // Google
+    })
+ * </example>
+ *
+ * @alias browser.mockRestoreAll
+ */
+export default function mockRestoreAll(): Promise<void>;
+//# sourceMappingURL=mockRestoreAll.d.ts.map

package/build/commands/browser/mockRestoreAll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockRestoreAll.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/mockRestoreAll.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAA8B,cAAc,kBAO3C"}