webdriverio 7.17.0 → 7.18.0

package/build/commands/browser/debug.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const serialize_error_1 = require("serialize-error");
+const repl_1 = __importDefault(require("@wdio/repl"));
+/**
+ *
+ * This command helps you to debug your integration tests. It stops the running browser and gives
+ * you time to jump into it and check the state of your application (e.g. using dev tools).
+ * Your terminal transforms into a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop)
+ * interface that will allow you to try out certain commands, find elements and test actions on
+ * them.
+ *
+ * [![WebdriverIO REPL](https://webdriver.io/img/repl.gif)](https://webdriver.io/img/repl.gif)
+ *
+ * If you run the WDIO testrunner make sure you increase the timeout property of the test framework
+ * you are using (e.g. Mocha or Jasmine) in order to prevent test termination due to a test timeout.
+ * Also avoid executing the command with multiple capabilities running at the same time.
+ *
+ * <iframe width="560" height="315" src="https://www.youtube.com/embed/xWwP-3B_YyE" frameborder="0" allowFullScreen></iframe>
+ *
+ * <example>
+    :debug.js
+    it('should demonstrate the debug command', async () => {
+        await $('#input').setValue('FOO')
+        await browser.debug() // jumping into the browser and change value of #input to 'BAR'
+        const value = await $('#input').getValue()
+        console.log(value) // outputs: "BAR"
+    })
+ * </example>
+ *
+ * @alias browser.debug
+ * @type utility
+ *
+ */
+function debug(commandTimeout = 5000) {
+    const repl = new repl_1.default();
+    const { introMessage } = repl_1.default;
+    /**
+     * run repl in standalone mode
+     */
+    if (!process.env.WDIO_WORKER || typeof process.send !== 'function') {
+        // eslint-disable-next-line
+        console.log(repl_1.default.introMessage);
+        const context = {
+            browser: this,
+            driver: this,
+            $: this.$.bind(this),
+            $$: this.$$.bind(this)
+        };
+        return repl.start(context);
+    }
+    /**
+     * register worker process as debugger target
+     */
+    process._debugProcess(process.pid);
+    /**
+     * initialise repl in testrunner
+     */
+    process.send({
+        origin: 'debugger',
+        name: 'start',
+        params: { commandTimeout, introMessage }
+    });
+    let commandResolve = /* istanbul ignore next */ () => { };
+    process.on('message', (m) => {
+        if (m.origin !== 'debugger') {
+            return;
+        }
+        if (m.name === 'stop') {
+            process._debugEnd(process.pid);
+            return commandResolve();
+        }
+        /* istanbul ignore if */
+        if (m.name === 'eval') {
+            repl.eval(m.content.cmd, global, undefined, (err, result) => {
+                if (typeof process.send !== 'function') {
+                    return;
+                }
+                if (err) {
+                    process.send({
+                        origin: 'debugger',
+                        name: 'result',
+                        params: {
+                            error: true,
+                            ...(0, serialize_error_1.serializeError)(err)
+                        }
+                    });
+                }
+                /**
+                 * try to do some smart serializations
+                 */
+                if (typeof result === 'function') {
+                    result = `[Function: ${result.name}]`;
+                }
+                process.send({
+                    origin: 'debugger',
+                    name: 'result',
+                    params: { result }
+                });
+            });
+        }
+    });
+    return new Promise((resolve) => (commandResolve = resolve));
+}
+exports.default = debug;

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

@@ -0,0 +1,45 @@
+/**
+ *
+ * Delete cookies visible to the current page. By providing a cookie name it just removes the single cookie or more when multiple names are passed.
+ *
+ * <example>
+    :deleteCookie.js
+    it('should delete cookies', async () => {
+        await browser.setCookies([
+            {name: 'test', value: '123'},
+            {name: 'test2', value: '456'},
+            {name: 'test3', value: '789'}
+        ])
+
+        let cookies = await browser.getCookies()
+        console.log(cookies)
+        // outputs:
+        // [
+        //     { name: 'test', value: '123' },
+        //     { name: 'test2', value: '456' }
+        //     { name: 'test3', value: '789' }
+        // ]
+
+        await browser.deleteCookies(['test3'])
+        cookies = await browser.getCookies()
+        console.log(cookies)
+        // outputs:
+        // [
+        //     { name: 'test', value: '123' },
+        //     { name: 'test2', value: '456' }
+        // ]
+
+        await browser.deleteCookies()
+        cookies = await browser.getCookies()
+        console.log(cookies) // outputs: []
+    })
+ * </example>
+ *
+ * @alias browser.deleteCookies
+ * @param {String=|String[]=} names  names of cookies to be deleted
+ * @uses webdriver/deleteAllCookies,webdriver/deleteCookie
+ * @type cookie
+ *
+ */
+export default function deleteCookies(this: WebdriverIO.Browser, names?: string | string[]): Promise<void> | Promise<void[]>;
+//# sourceMappingURL=deleteCookies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deleteCookies.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/deleteCookies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CACjC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,mCAa5B"}

package/build/commands/browser/deleteCookies.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ * Delete cookies visible to the current page. By providing a cookie name it just removes the single cookie or more when multiple names are passed.
+ *
+ * <example>
+    :deleteCookie.js
+    it('should delete cookies', async () => {
+        await browser.setCookies([
+            {name: 'test', value: '123'},
+            {name: 'test2', value: '456'},
+            {name: 'test3', value: '789'}
+        ])
+
+        let cookies = await browser.getCookies()
+        console.log(cookies)
+        // outputs:
+        // [
+        //     { name: 'test', value: '123' },
+        //     { name: 'test2', value: '456' }
+        //     { name: 'test3', value: '789' }
+        // ]
+
+        await browser.deleteCookies(['test3'])
+        cookies = await browser.getCookies()
+        console.log(cookies)
+        // outputs:
+        // [
+        //     { name: 'test', value: '123' },
+        //     { name: 'test2', value: '456' }
+        // ]
+
+        await browser.deleteCookies()
+        cookies = await browser.getCookies()
+        console.log(cookies) // outputs: []
+    })
+ * </example>
+ *
+ * @alias browser.deleteCookies
+ * @param {String=|String[]=} names  names of cookies to be deleted
+ * @uses webdriver/deleteAllCookies,webdriver/deleteCookie
+ * @type cookie
+ *
+ */
+function deleteCookies(names) {
+    if (names === undefined) {
+        return this.deleteAllCookies();
+    }
+    const namesList = Array.isArray(names) ? names : [names];
+    if (namesList.every(obj => typeof obj !== 'string')) {
+        return Promise.reject(new Error('Invalid input (see https://webdriver.io/docs/api/browser/deleteCookies for documentation)'));
+    }
+    return Promise.all(namesList.map(name => this.deleteCookie(name)));
+}
+exports.default = deleteCookies;

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

@@ -0,0 +1,37 @@
+/**
+ *
+ * Inject a snippet of JavaScript into the page for execution in the context of the currently selected frame.
+ * The executed script is assumed to be synchronous and the result of evaluating the script is returned to
+ * the client.
+ *
+ * The script argument defines the script to execute in the form of a function body. The value returned by
+ * that function will be returned to the client. The function will be invoked with the provided args array
+ * and the values may be accessed via the arguments object in the order specified.
+ *
+ * Arguments may be any JSON-primitive, array, or JSON object. JSON objects that define a WebElement
+ * reference will be converted to the corresponding DOM element. Likewise, any WebElements in the script
+ * result will be returned to the client as WebElement JSON objects.
+ *
+ * <example>
+    :execute.js
+    it('should inject javascript on the page', async () => {
+        const result = await browser.execute((a, b, c, d) => {
+            // browser context - you may not access client or console
+            return a + b + c + d
+        }, 1, 2, 3, 4)
+        // node.js context - client and console are available
+        console.log(result) // outputs: 10
+    });
+ * </example>
+ *
+ * @param {String|Function} script                     The script to execute.
+ * @param {*=}               arguments  script arguments
+ *
+ * @return {*}             The script result.
+ *
+ * @see  https://w3c.github.io/webdriver/webdriver-spec.html#dfn-execute-script
+ * @type protocol
+ *
+ */
+export default function execute<ReturnValue, InnerArguments extends any[]>(this: WebdriverIO.Browser | WebdriverIO.Element, script: string | ((...innerArgs: InnerArguments) => ReturnValue), ...args: InnerArguments): Promise<ReturnValue>;
+//# sourceMappingURL=execute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/execute.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,WAAW,EAAE,cAAc,SAAS,GAAG,EAAE,EACrE,IAAI,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,EAC/C,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,cAAc,KAAK,WAAW,CAAC,EAChE,GAAG,IAAI,EAAE,cAAc,GACxB,OAAO,CAAC,WAAW,CAAC,CAiBtB"}

package/build/commands/browser/execute.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+/**
+ *
+ * Inject a snippet of JavaScript into the page for execution in the context of the currently selected frame.
+ * The executed script is assumed to be synchronous and the result of evaluating the script is returned to
+ * the client.
+ *
+ * The script argument defines the script to execute in the form of a function body. The value returned by
+ * that function will be returned to the client. The function will be invoked with the provided args array
+ * and the values may be accessed via the arguments object in the order specified.
+ *
+ * Arguments may be any JSON-primitive, array, or JSON object. JSON objects that define a WebElement
+ * reference will be converted to the corresponding DOM element. Likewise, any WebElements in the script
+ * result will be returned to the client as WebElement JSON objects.
+ *
+ * <example>
+    :execute.js
+    it('should inject javascript on the page', async () => {
+        const result = await browser.execute((a, b, c, d) => {
+            // browser context - you may not access client or console
+            return a + b + c + d
+        }, 1, 2, 3, 4)
+        // node.js context - client and console are available
+        console.log(result) // outputs: 10
+    });
+ * </example>
+ *
+ * @param {String|Function} script                     The script to execute.
+ * @param {*=}               arguments  script arguments
+ *
+ * @return {*}             The script result.
+ *
+ * @see  https://w3c.github.io/webdriver/webdriver-spec.html#dfn-execute-script
+ * @type protocol
+ *
+ */
+function execute(script, ...args) {
+    /**
+     * parameter check
+     */
+    if ((typeof script !== 'string' && typeof script !== 'function')) {
+        throw new Error('number or type of arguments don\'t agree with execute protocol command');
+    }
+    /**
+     * instances started as multibrowserinstance can't getting called with
+     * a function parameter, therefore we need to check if it starts with "function () {"
+     */
+    if (typeof script === 'function') {
+        script = `return (${script}).apply(null, arguments)`;
+    }
+    return this.executeScript(script, (0, utils_1.verifyArgsAndStripIfElement)(args));
+}
+exports.default = execute;

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

@@ -0,0 +1,45 @@
+/**
+ *
+ * Inject a snippet of JavaScript into the page for execution in the context of the currently selected
+ * frame. The executed script is assumed to be asynchronous and must signal that is done by invoking
+ * the provided callback, which is always provided as the final argument to the function. The value
+ * to this callback will be returned to the client.
+ *
+ * Asynchronous script commands may not span page loads. If an unload event is fired while waiting
+ * for a script result, an error should be returned to the client.
+ *
+ * The script argument defines the script to execute in the form of a function body. The function will
+ * be invoked with the provided args array and the values may be accessed via the arguments object
+ * in the order specified. The final argument will always be a callback function that must be invoked
+ * to signal that the script has finished.
+ *
+ * Arguments may be any JSON-primitive, array, or JSON object. JSON objects that define a WebElement
+ * reference will be converted to the corresponding DOM element. Likewise, any WebElements in the script
+ * result will be returned to the client as WebElement JSON objects.
+ *
+ * <example>
+    :executeAsync.js
+    it('should execute async JavaScript on the page', async () => {
+        await browser.setTimeout({ script: 5000 })
+        const result = await browser.executeAsync(function(a, b, c, d, done) {
+            // browser context - you may not access client or console
+            setTimeout(() => {
+                done(a + b + c + d)
+            }, 3000);
+        }, 1, 2, 3, 4)
+        // node.js context - client and console are available
+        console.log(result) // outputs: 10
+    });
+ * </example>
+ *
+ * @param {String|Function} script     The script to execute.
+ * @param {*=}               arguments  script arguments
+ *
+ * @return {*}             The script result.
+ *
+ * @see  https://w3c.github.io/webdriver/webdriver-spec.html#dfn-execute-async-script
+ * @type protocol
+ *
+ */
+export default function executeAsync<ReturnValue, InnerArguments extends any[]>(this: WebdriverIO.Browser | WebdriverIO.Element, script: string | ((...args: [...innerArgs: InnerArguments, callback: (result?: ReturnValue) => void]) => void), ...args: InnerArguments): Promise<ReturnValue>;
+//# sourceMappingURL=executeAsync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"executeAsync.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/executeAsync.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,WAAW,EAAE,cAAc,SAAS,GAAG,EAAE,EAC1E,IAAI,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,EAC/C,MAAM,EACF,MAAM,GACN,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC,KAAK,IAAI,CAAC,EACjG,GAAG,IAAI,EAAE,cAAc,GACxB,OAAO,CAAC,WAAW,CAAC,CAiBtB"}

package/build/commands/browser/executeAsync.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+/**
+ *
+ * Inject a snippet of JavaScript into the page for execution in the context of the currently selected
+ * frame. The executed script is assumed to be asynchronous and must signal that is done by invoking
+ * the provided callback, which is always provided as the final argument to the function. The value
+ * to this callback will be returned to the client.
+ *
+ * Asynchronous script commands may not span page loads. If an unload event is fired while waiting
+ * for a script result, an error should be returned to the client.
+ *
+ * The script argument defines the script to execute in the form of a function body. The function will
+ * be invoked with the provided args array and the values may be accessed via the arguments object
+ * in the order specified. The final argument will always be a callback function that must be invoked
+ * to signal that the script has finished.
+ *
+ * Arguments may be any JSON-primitive, array, or JSON object. JSON objects that define a WebElement
+ * reference will be converted to the corresponding DOM element. Likewise, any WebElements in the script
+ * result will be returned to the client as WebElement JSON objects.
+ *
+ * <example>
+    :executeAsync.js
+    it('should execute async JavaScript on the page', async () => {
+        await browser.setTimeout({ script: 5000 })
+        const result = await browser.executeAsync(function(a, b, c, d, done) {
+            // browser context - you may not access client or console
+            setTimeout(() => {
+                done(a + b + c + d)
+            }, 3000);
+        }, 1, 2, 3, 4)
+        // node.js context - client and console are available
+        console.log(result) // outputs: 10
+    });
+ * </example>
+ *
+ * @param {String|Function} script     The script to execute.
+ * @param {*=}               arguments  script arguments
+ *
+ * @return {*}             The script result.
+ *
+ * @see  https://w3c.github.io/webdriver/webdriver-spec.html#dfn-execute-async-script
+ * @type protocol
+ *
+ */
+function executeAsync(script, ...args) {
+    /**
+     * parameter check
+     */
+    if ((typeof script !== 'string' && typeof script !== 'function')) {
+        throw new Error('number or type of arguments don\'t agree with execute protocol command');
+    }
+    /**
+     * instances started as multibrowserinstance can't getting called with
+     * a function parameter, therefore we need to check if it starts with "function () {"
+     */
+    if (typeof script === 'function') {
+        script = `return (${script}).apply(null, arguments)`;
+    }
+    return this.executeAsyncScript(script, (0, utils_1.verifyArgsAndStripIfElement)(args));
+}
+exports.default = executeAsync;

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

@@ -0,0 +1,34 @@
+/**
+ *
+ * Retrieve a [cookie](https://w3c.github.io/webdriver/webdriver-spec.html#cookies)
+ * visible to the current page. You can query a specific cookie by providing the cookie name or
+ * retrieve all.
+ *
+ * <example>
+    :getCookies.js
+    it('should return a cookie for me', async () => {
+        await browser.setCookies([
+            {name: 'test', value: '123'},
+            {name: 'test2', value: '456'}
+        ])
+        const testCookie = await browser.getCookies(['test'])
+        console.log(testCookie); // outputs: [{ name: 'test', value: '123' }]
+
+        const allCookies = await browser.getCookies()
+        console.log(allCookies);
+        // outputs:
+        // [
+        //    { name: 'test', value: '123' },
+        //    { name: 'test2', value: '456' }
+        // ]
+    })
+ * </example>
+ *
+ * @alias browser.getCookies
+ * @param {String[]=|String=}   names  names of requested cookies (if omitted, all cookies will be returned)
+ * @return {WebDriver.Cookie[]}        requested cookies if existing
+ * @uses webdriver/getAllCookies
+ *
+ */
+export default function getCookies(this: WebdriverIO.Browser, names?: string | string[]): Promise<import("@wdio/protocols").Cookie[]>;
+//# sourceMappingURL=getCookies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getCookies.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/getCookies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAA8B,UAAU,CACpC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,+CAc5B"}

package/build/commands/browser/getCookies.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ * Retrieve a [cookie](https://w3c.github.io/webdriver/webdriver-spec.html#cookies)
+ * visible to the current page. You can query a specific cookie by providing the cookie name or
+ * retrieve all.
+ *
+ * <example>
+    :getCookies.js
+    it('should return a cookie for me', async () => {
+        await browser.setCookies([
+            {name: 'test', value: '123'},
+            {name: 'test2', value: '456'}
+        ])
+        const testCookie = await browser.getCookies(['test'])
+        console.log(testCookie); // outputs: [{ name: 'test', value: '123' }]
+
+        const allCookies = await browser.getCookies()
+        console.log(allCookies);
+        // outputs:
+        // [
+        //    { name: 'test', value: '123' },
+        //    { name: 'test2', value: '456' }
+        // ]
+    })
+ * </example>
+ *
+ * @alias browser.getCookies
+ * @param {String[]=|String=}   names  names of requested cookies (if omitted, all cookies will be returned)
+ * @return {WebDriver.Cookie[]}        requested cookies if existing
+ * @uses webdriver/getAllCookies
+ *
+ */
+async function getCookies(names) {
+    if (names === undefined) {
+        return this.getAllCookies();
+    }
+    const namesList = Array.isArray(names) ? names : [names];
+    if (namesList.every(obj => typeof obj !== 'string')) {
+        throw new Error('Invalid input (see https://webdriver.io/docs/api/browser/getCookies for documentation)');
+    }
+    const allCookies = await this.getAllCookies();
+    return allCookies.filter(cookie => namesList.includes(cookie.name));
+}
+exports.default = getCookies;

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

@@ -0,0 +1,38 @@
+import { Browser as PuppeteerBrowser } from 'puppeteer-core/lib/cjs/puppeteer/common/Browser';
+/**
+ * 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
+ */
+export default function getPuppeteer(this: WebdriverIO.Browser): Promise<PuppeteerBrowser>;
+//# sourceMappingURL=getPuppeteer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPuppeteer.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/getPuppeteer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,iDAAiD,CAAA;AAM7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAA8B,YAAY,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,6BAiFpE"}