@testring/plugin-selenium-driver 0.5.36 → 0.6.1

package/dist/index.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
-// eslint-disable-next-line import/no-default-export
-function default_1(pluginAPI, userConfig) {
+function seleniumPlugin(pluginAPI, userConfig) {
     const pluginPath = path.join(__dirname, './plugin');
     const browserProxy = pluginAPI.getBrowserProxy();
     browserProxy.proxyPlugin(pluginPath, userConfig || {});
 }
-exports.default = default_1;
+exports.default = seleniumPlugin;

package/dist/plugin/index.js

@@ -27,6 +27,7 @@ const DEFAULT_CONFIG = {
     capabilities: {
         browserName: 'chrome',
         'goog:chromeOptions': {
+            // for local ChromeDriver
             args: [],
         },
     },
@@ -63,25 +64,63 @@ class SeleniumPlugin {
         return {
             capabilities: {
                 'goog:chromeOptions': {
-                    args: [
-                        `load-extension=${devtool_extension_1.absoluteExtensionPath}`,
-                    ],
+                    args: [`load-extension=${devtool_extension_1.absoluteExtensionPath}`],
                 },
             },
         };
     }
+    // eslint-disable-next-line sonarjs/cognitive-complexity
     createConfig(config) {
-        let mergedConfig = deepmerge.all([
-            DEFAULT_CONFIG,
-            config,
-        ], {
+        let mergedConfig = deepmerge.all([DEFAULT_CONFIG, config], {
             clone: true,
         });
         if (mergedConfig.recorderExtension) {
-            mergedConfig = deepmerge.all([
-                mergedConfig,
-                this.getDevelopmentConfigAdditions(),
-            ]);
+            mergedConfig = deepmerge.all([mergedConfig, this.getDevelopmentConfigAdditions()], {
+                customMerge: (mergeKey) => {
+                    if (mergeKey === 'goog:chromeOptions') {
+                        return (itemA, itemB) => {
+                            if (!itemA.args || !itemB.args) {
+                                return deepmerge(itemA, itemB);
+                            }
+                            const res = {};
+                            res.args = deepmerge(itemA.args, itemB.args);
+                            let ext = res.args.filter((argItem) => argItem.startsWith('load-extension'));
+                            if (ext.length === 2) {
+                                ext = [
+                                    `load-extension=${ext[0]
+                                        .split('=', 2)
+                                        .pop()},${ext[1]
+                                        .split('=', 2)
+                                        .pop()}`,
+                                ];
+                            }
+                            res.args = [
+                                ...ext,
+                                ...res.args.filter((argItem) => !argItem.startsWith('load-extension')),
+                            ];
+                            Object.keys(itemA).forEach((key) => {
+                                if (key === 'args') {
+                                    return;
+                                }
+                                if (itemB[key] !== undefined) {
+                                    res[key] = deepmerge(itemA[key], itemB[key]);
+                                }
+                                else {
+                                    res[key] = itemA[key];
+                                }
+                            });
+                            Object.keys(itemB).forEach((key) => {
+                                if (key === 'args' ||
+                                    res[key] !== undefined) {
+                                    return;
+                                }
+                                res[key] = itemB[key];
+                            });
+                            return res;
+                        };
+                    }
+                },
+            });
         }
         if (!mergedConfig.hostname && mergedConfig.host) {
             mergedConfig.hostname = mergedConfig.host;
@@ -100,8 +139,8 @@ class SeleniumPlugin {
         });
     }
     stopAllSessions() {
-        let clientsRequests = [];
-        for (let [applicant] of this.browserClients) {
+        const clientsRequests = [];
+        for (const [applicant] of this.browserClients) {
             this.logger.debug(`Stopping sessions before process exit for applicant ${applicant}.`);
             clientsRequests.push(this.end(applicant).catch((err) => {
                 this.logger.error(`Session stop before process exit error for applicant ${applicant}: \n`, err);
@@ -125,10 +164,12 @@ class SeleniumPlugin {
             const seleniumJarPath = seleniumServer.path;
             this.logger.debug('Init local selenium server');
             try {
-                this.localSelenium = child_process_1.spawn('java', [
+                this.localSelenium = (0, child_process_1.spawn)('java', [
                     ...this.getChromeDriverArgs(),
-                    '-jar', seleniumJarPath,
-                    '-port', this.config.port,
+                    '-jar',
+                    seleniumJarPath,
+                    '-port',
+                    this.config.port,
                 ]);
                 this.waitForReadyState = new Promise((resolve, reject) => {
                     if (this.localSelenium.stderr) {
@@ -151,7 +192,7 @@ class SeleniumPlugin {
         });
     }
     getApplicantSessionId(applicant) {
-        let item = this.browserClients.get(applicant);
+        const item = this.browserClients.get(applicant);
         if (item) {
             return item.sessionId;
         }
@@ -160,7 +201,7 @@ class SeleniumPlugin {
         return this.browserClients.has(applicant);
     }
     getBrowserClient(applicant) {
-        let item = this.browserClients.get(applicant);
+        const item = this.browserClients.get(applicant);
         if (item) {
             return item.client;
         }
@@ -168,18 +209,20 @@ class SeleniumPlugin {
     }
     pingClients() {
         return __awaiter(this, void 0, void 0, function* () {
-            for (let [applicant] of this.browserClients) {
+            for (const [applicant] of this.browserClients) {
                 try {
                     yield this.execute(applicant, '(function () {})()', []);
                 }
-                catch (e) { /* ignore */ }
+                catch (e) {
+                    /* ignore */
+                }
             }
         });
     }
     closeExpiredClients() {
         return __awaiter(this, void 0, void 0, function* () {
             const timeLimit = Date.now() - this.config.clientTimeout;
-            for (let [applicant, clientData] of this.browserClients) {
+            for (const [applicant, clientData] of this.browserClients) {
                 if (clientData.initTime < timeLimit) {
                     this.logger.warn(`Session applicant ${applicant} marked as expired`);
                     try {
@@ -214,7 +257,7 @@ class SeleniumPlugin {
             if (this.expiredBrowserClients.has(applicant)) {
                 throw Error(`This session expired in ${this.config.clientTimeout}ms`);
             }
-            const client = yield webdriverio_1.remote(this.config);
+            const client = yield (0, webdriverio_1.remote)(this.config);
             let sessionId;
             if (client.sessionId) {
                 sessionId = client.sessionId;
@@ -235,10 +278,10 @@ class SeleniumPlugin {
         // Creating our delete selenium session to be able to close
         // session if it's id is changed while we are running test
         client.addCommand('deleteSessionId', function (sessionId) {
-            const { w3cCaps, jsonwpCaps } = this.options.requestedCapabilities;
+            const { w3cCaps, jsonwpCaps, } = this.options.requestedCapabilities;
             const sessionDeleteRequest = new WebDriverRequest('DELETE', '/session/:sessionId', {
                 capabilities: w3cCaps,
-                desiredCapabilities: jsonwpCaps,
+                desiredCapabilities: jsonwpCaps, // JSONWP compliant
             });
             return sessionDeleteRequest.makeRequest(this.options, sessionId);
         }, false);
@@ -255,7 +298,9 @@ class SeleniumPlugin {
             try {
                 yield this.alertDismiss(applicant);
             }
-            catch ( /* ignore */_a) { /* ignore */ }
+            catch (_a) {
+                /* ignore */
+            }
             const startingSessionID = this.getApplicantSessionId(applicant);
             const sessionID = client.sessionId;
             if (startingSessionID === sessionID) {
@@ -263,8 +308,8 @@ class SeleniumPlugin {
                 yield client.deleteSession();
             }
             else {
-                yield this.logger.stepWarning(`Stopping sessions for applicant warning ${applicant}. `
-                    + `Session ids are not equal, started with - ${startingSessionID}, ended with - ${sessionID}`, () => __awaiter(this, void 0, void 0, function* () {
+                yield this.logger.stepWarning(`Stopping sessions for applicant warning ${applicant}. ` +
+                    `Session ids are not equal, started with - ${startingSessionID}, ended with - ${sessionID}`, () => __awaiter(this, void 0, void 0, function* () {
                     try {
                         if (startingSessionID) {
                             yield client.deleteSessionId(startingSessionID);
@@ -342,7 +387,10 @@ class SeleniumPlugin {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
             const args = stringifyWindowFeatures(windowFeatures);
-            return client.newWindow(val, windowName || this.generateWinId(), args);
+            return client.newWindow(val, {
+                windowName: windowName || this.generateWinId(),
+                windowFeatures: args,
+            });
         });
     }
     waitForExist(applicant, xpath, timeout) {
@@ -350,7 +398,7 @@ class SeleniumPlugin {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
             const selector = yield client.$(xpath);
-            return selector.waitForExist(timeout);
+            return selector.waitForExist({ timeout });
         });
     }
     waitForVisible(applicant, xpath, timeout) {
@@ -358,7 +406,7 @@ class SeleniumPlugin {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
             const selector = yield client.$(xpath);
-            return selector.waitForDisplayed(timeout);
+            return selector.waitForDisplayed({ timeout });
         });
     }
     isVisible(applicant, xpath) {
@@ -369,12 +417,12 @@ class SeleniumPlugin {
             return selector.isDisplayed();
         });
     }
-    moveToObject(applicant, xpath, x, y) {
+    moveToObject(applicant, xpath, xOffset = 0, yOffset = 0) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
             const selector = yield client.$(xpath);
-            return selector.moveTo(x || 0, y || 0);
+            return selector.moveTo({ xOffset, yOffset });
         });
     }
     execute(applicant, fn, args) {
@@ -424,10 +472,10 @@ class SeleniumPlugin {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
-            const elements = yield client.findElements('xpath', xpath);
+            const elements = (yield client.findElements('xpath', xpath));
             return elements.map((o) => {
                 const keys = Object.keys(o);
-                return { 'ELEMENT': o[keys[0]] };
+                return { ELEMENT: o[keys[0]] };
             });
         });
     }
@@ -508,13 +556,13 @@ class SeleniumPlugin {
             return selector.isEnabled();
         });
     }
-    scroll(applicant, xpath, x, y) {
+    scroll(applicant, xpath, xOffset, yOffset) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
             const element = yield client.$(xpath);
             yield element.scrollIntoView();
-            return element.moveTo(x, y);
+            return element.moveTo({ xOffset, yOffset });
         });
     }
     scrollIntoView(applicant, xpath, scrollIntoViewOptions) {
@@ -646,7 +694,7 @@ class SeleniumPlugin {
             const client = this.getBrowserClient(applicant);
             const result = yield client.switchToWindow(tabId);
             const body = yield client.$('body');
-            yield client.waitUntil(() => __awaiter(this, void 0, void 0, function* () { return body.isExisting(); }), 10000);
+            yield client.waitUntil(() => __awaiter(this, void 0, void 0, function* () { return body.isExisting(); }), { timeout: 10000 });
             return result;
         });
     }
@@ -738,7 +786,7 @@ class SeleniumPlugin {
             return client.waitUntil(() => __awaiter(this, void 0, void 0, function* () {
                 const elemValue = yield (yield client.$(xpath)).getValue();
                 return reverse ? !elemValue : !!elemValue;
-            }), timeout);
+            }), { timeout });
         });
     }
     waitForSelected(applicant, xpath, timeout, reverse) {
@@ -748,14 +796,14 @@ class SeleniumPlugin {
             return client.waitUntil(() => __awaiter(this, void 0, void 0, function* () {
                 const isSelected = yield (yield client.$(xpath)).isSelected();
                 return reverse ? !isSelected : isSelected;
-            }), timeout);
+            }), { timeout });
         });
     }
     waitUntil(applicant, condition, timeout, timeoutMsg, interval) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
-            return client.waitUntil(condition, timeout, timeoutMsg, interval);
+            return client.waitUntil(condition, { timeout, timeoutMsg, interval });
         });
     }
     selectByAttribute(applicant, xpath, attribute, value) {
@@ -766,6 +814,7 @@ class SeleniumPlugin {
             return selector.selectByAttribute(attribute, value);
         });
     }
+    // @deprecated WAT-1872
     gridProxyDetails(applicant) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createClient(applicant);
@@ -778,6 +827,7 @@ class SeleniumPlugin {
             return client.gridProxyDetails(client.sessionId);
         });
     }
+    // @deprecated WAT-1872
     gridTestSession(applicant) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createClient(applicant);
@@ -790,12 +840,13 @@ class SeleniumPlugin {
             return client.gridTestSession(client.sessionId);
         });
     }
+    // @deprecated WAT-1872
     getGridNodeDetails(applicant) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createClient(applicant);
             const client = this.getBrowserClient(applicant);
             const testSession = yield this.gridTestSession(applicant);
-            if (!testSession.localSelenium) {
+            if (testSession && !testSession.localSelenium) {
                 const proxyDetails = yield client.gridProxyDetails(applicant);
                 delete testSession.msg;
                 delete testSession.success;
@@ -807,9 +858,52 @@ class SeleniumPlugin {
             return testSession;
         });
     }
+    /**
+     * @param overwrites should NOT be an arrow function, Otherwise it would throw an error
+     */
+    mock(applicant, url, overwrites, filterOptions, mockResponseParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createClient(applicant);
+            const client = this.getBrowserClient(applicant);
+            const mock = yield client.mock(url, filterOptions);
+            if (typeof overwrites === 'function') {
+                mock.respond((res) => {
+                    overwrites(res);
+                    this.setMockData(applicant, url, res);
+                    return res.body;
+                }, mockResponseParams);
+            }
+            else {
+                mock.respond(overwrites);
+            }
+        });
+    }
+    setMockData(applicant, url, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createClient(applicant);
+            const client = this.getBrowserClient(applicant);
+            client.mockData = client.mockData || {};
+            if (client.mockData[url]) {
+                client.mockData[url].push(data);
+            }
+            else {
+                client.mockData[url] = [data];
+            }
+            return true;
+        });
+    }
+    getMockData(applicant, url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createClient(applicant);
+            const client = this.getBrowserClient(applicant);
+            if (url) {
+                return client.mockData[url];
+            }
+            return client.mockData;
+        });
+    }
 }
 exports.SeleniumPlugin = SeleniumPlugin;
-// eslint-disable-next-line import/no-default-export
 function seleniumProxy(config) {
     return new SeleniumPlugin(config);
 }

package/index.d.ts

@@ -0,0 +1,15 @@
+interface FormDataEvent extends Event {
+    readonly formData: FormData;
+}
+
+interface SubmitEvent extends Event {
+    readonly submitter: HTMLElement | null;
+}
+
+interface ElementInternals {
+    readonly [key: string]: any;
+}
+
+interface GetAnimationsOptions {
+    readonly [key: string]: any;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testring/plugin-selenium-driver",
-  "version": "0.5.36",
+  "version": "0.6.1",
   "main": "./dist/index.js",
   "typings": "./src/index.ts",
   "repository": {
@@ -10,19 +10,16 @@
   "author": "RingCentral",
   "license": "MIT",
   "dependencies": {
-    "@testring/child-process": "0.5.36",
-    "@testring/devtool-extension": "0.5.36",
-    "@testring/logger": "0.5.36",
-    "@testring/plugin-api": "0.5.36",
-    "@testring/types": "0.5.36",
+    "@testring/child-process": "0.6.1",
+    "@testring/devtool-extension": "0.6.1",
+    "@testring/logger": "0.6.1",
+    "@testring/plugin-api": "0.6.1",
+    "@testring/types": "0.6.1",
     "@types/deepmerge": "2.2.0",
-    "@types/node": "14.6.0",
-    "@types/puppeteer-core": "2.0.0",
+    "@types/node": "18.11.18",
     "chromedriver": "*",
     "deepmerge": "4.2.2",
-    "puppeteer-core": "5.2.1",
     "selenium-server": "3.141.59",
-    "v8-to-istanbul": "4.1.4",
-    "webdriverio": "5.22.3"
+    "webdriverio": "7.20.7"
   }
 }

package/src/index.ts

@@ -1,9 +1,11 @@
 import * as path from 'path';
-import { SeleniumPluginConfig } from './types';
-import { PluginAPI } from '@testring/plugin-api';
+import {SeleniumPluginConfig} from './types';
+import {PluginAPI} from '@testring/plugin-api';
 
-// eslint-disable-next-line import/no-default-export
-export default function (pluginAPI: PluginAPI, userConfig: SeleniumPluginConfig) {
+export default function seleniumPlugin(
+    pluginAPI: PluginAPI,
+    userConfig: SeleniumPluginConfig,
+): void {
     const pluginPath = path.join(__dirname, './plugin');
     const browserProxy = pluginAPI.getBrowserProxy();
 

package/src/plugin/index.ts

@@ -1,25 +1,32 @@
-import { SeleniumPluginConfig } from '../types';
-import { IBrowserProxyPlugin, WindowFeaturesConfig } from '@testring/types';
+import {SeleniumPluginConfig} from '../types';
+import {IBrowserProxyPlugin, WindowFeaturesConfig} from '@testring/types';
 
-import { ChildProcess } from 'child_process';
+import {ChildProcess} from 'child_process';
 
-import { Config, BrowserObject, remote } from 'webdriverio';
+import {remote} from 'webdriverio';
 import * as deepmerge from 'deepmerge';
 
-import { spawn } from '@testring/child-process';
-import { loggerClient } from '@testring/logger';
-import { absoluteExtensionPath } from '@testring/devtool-extension';
+import {spawn} from '@testring/child-process';
+import {loggerClient} from '@testring/logger';
+import {absoluteExtensionPath} from '@testring/devtool-extension';
 
-import Cookie = WebdriverIO.Cookie;
-import ClickOptions = WebdriverIO.ClickOptions;
+import type {Cookie} from '@wdio/protocols';
+import type {
+    ClickOptions,
+    MockFilterOptions,
+    MockResponseParams,
+    Matches,
+} from 'webdriverio';
 
 // Stupidly needed thing for making our own requests
 const _webdriverReq = require('webdriver/build/request');
 const WebDriverRequest = _webdriverReq.default;
 
-type BrowserObjectCustom = BrowserObject & {
+type BrowserObjectCustom = WebdriverIO.Browser & {
+    sessionId: string;
     deleteSessionId: (sessionId: string) => Promise<void>;
-}
+    mockData: Record<string, Matches[]>;
+};
 
 type browserClientItem = {
     client: BrowserObjectCustom;
@@ -35,7 +42,8 @@ const DEFAULT_CONFIG: SeleniumPluginConfig = {
     logLevel: 'warn',
     capabilities: {
         browserName: 'chrome',
-        'goog:chromeOptions': { // for local ChromeDriver
+        'goog:chromeOptions': {
+            // for local ChromeDriver
             args: [] as string[],
         },
     },
@@ -57,7 +65,6 @@ function stringifyWindowFeatures(windowFeatures: WindowFeaturesConfig) {
     return result;
 }
 
-
 export class SeleniumPlugin implements IBrowserProxyPlugin {
     private logger = loggerClient.withPrefix('[selenium-browser-process]');
 
@@ -73,7 +80,7 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
 
     private config: SeleniumPluginConfig;
 
-    private incrementWinId: number = 0;
+    private incrementWinId = 0;
 
     constructor(config: Partial<SeleniumPluginConfig> = {}) {
         this.config = this.createConfig(config);
@@ -89,27 +96,86 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return {
             capabilities: {
                 'goog:chromeOptions': {
-                    args: [
-                        `load-extension=${absoluteExtensionPath}`,
-                    ],
+                    args: [`load-extension=${absoluteExtensionPath}`],
                 },
             },
         } as any;
     }
 
-    private createConfig(config: Partial<SeleniumPluginConfig>): SeleniumPluginConfig {
-        let mergedConfig = deepmerge.all<SeleniumPluginConfig>([
-            DEFAULT_CONFIG,
-            config,
-        ], {
-            clone: true,
-        });
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    private createConfig(
+        config: Partial<SeleniumPluginConfig>,
+    ): SeleniumPluginConfig {
+        let mergedConfig = deepmerge.all<SeleniumPluginConfig>(
+            [DEFAULT_CONFIG, config],
+            {
+                clone: true,
+            },
+        );
 
         if (mergedConfig.recorderExtension) {
-            mergedConfig = deepmerge.all<SeleniumPluginConfig>([
-                mergedConfig,
-                this.getDevelopmentConfigAdditions(),
-            ]);
+            mergedConfig = deepmerge.all<SeleniumPluginConfig>(
+                [mergedConfig, this.getDevelopmentConfigAdditions()],
+                {
+                    customMerge: (mergeKey) => {
+                        if (mergeKey === 'goog:chromeOptions') {
+                            return (itemA, itemB) => {
+                                if (!itemA.args || !itemB.args) {
+                                    return deepmerge(itemA, itemB);
+                                }
+                                const res: Record<string, any> = {};
+                                res.args = deepmerge(itemA.args, itemB.args);
+                                let ext: string[] = res.args.filter(
+                                    (argItem: string) =>
+                                        argItem.startsWith('load-extension'),
+                                );
+                                if (ext.length === 2) {
+                                    ext = [
+                                        `load-extension=${ext[0]
+                                            .split('=', 2)
+                                            .pop()},${ext[1]
+                                            .split('=', 2)
+                                            .pop()}`,
+                                    ];
+                                }
+                                res.args = [
+                                    ...ext,
+                                    ...res.args.filter(
+                                        (argItem: string) =>
+                                            !argItem.startsWith(
+                                                'load-extension',
+                                            ),
+                                    ),
+                                ];
+                                Object.keys(itemA).forEach((key) => {
+                                    if (key === 'args') {
+                                        return;
+                                    }
+                                    if (itemB[key] !== undefined) {
+                                        res[key] = deepmerge(
+                                            itemA[key],
+                                            itemB[key],
+                                        );
+                                    } else {
+                                        res[key] = itemA[key];
+                                    }
+                                });
+                                Object.keys(itemB).forEach((key) => {
+                                    if (
+                                        key === 'args' ||
+                                        res[key] !== undefined
+                                    ) {
+                                        return;
+                                    }
+
+                                    res[key] = itemB[key];
+                                });
+                                return res;
+                            };
+                        }
+                    },
+                },
+            );
         }
 
         if (!mergedConfig.hostname && mergedConfig.host) {
@@ -136,13 +202,20 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
     }
 
     private stopAllSessions() {
-        let clientsRequests: Promise<any>[] = [];
+        const clientsRequests: Promise<any>[] = [];
 
-        for (let [applicant] of this.browserClients) {
-            this.logger.debug(`Stopping sessions before process exit for applicant ${applicant}.`);
-            clientsRequests.push(this.end(applicant).catch((err) => {
-                this.logger.error(`Session stop before process exit error for applicant ${applicant}: \n`, err);
-            }));
+        for (const [applicant] of this.browserClients) {
+            this.logger.debug(
+                `Stopping sessions before process exit for applicant ${applicant}.`,
+            );
+            clientsRequests.push(
+                this.end(applicant).catch((err) => {
+                    this.logger.error(
+                        `Session stop before process exit error for applicant ${applicant}: \n`,
+                        err,
+                    );
+                }),
+            );
         }
 
         return Promise.all(clientsRequests);
@@ -168,8 +241,10 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         try {
             this.localSelenium = spawn('java', [
                 ...this.getChromeDriverArgs(),
-                '-jar', seleniumJarPath,
-                '-port', this.config.port,
+                '-jar',
+                seleniumJarPath,
+                '-port',
+                this.config.port,
             ]);
 
             this.waitForReadyState = new Promise((resolve, reject) => {
@@ -193,7 +268,7 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
     }
 
     private getApplicantSessionId(applicant): string | undefined {
-        let item = this.browserClients.get(applicant);
+        const item = this.browserClients.get(applicant);
 
         if (item) {
             return item.sessionId;
@@ -205,7 +280,7 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
     }
 
     private getBrowserClient(applicant): BrowserObjectCustom {
-        let item = this.browserClients.get(applicant);
+        const item = this.browserClients.get(applicant);
 
         if (item) {
             return item.client;
@@ -215,23 +290,30 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
     }
 
     private async pingClients() {
-        for (let [applicant] of this.browserClients) {
+        for (const [applicant] of this.browserClients) {
             try {
                 await this.execute(applicant, '(function () {})()', []);
-            } catch (e) { /* ignore */ }
+            } catch (e) {
+                /* ignore */
+            }
         }
     }
 
     private async closeExpiredClients() {
         const timeLimit = Date.now() - this.config.clientTimeout;
 
-        for (let [applicant, clientData] of this.browserClients) {
+        for (const [applicant, clientData] of this.browserClients) {
             if (clientData.initTime < timeLimit) {
-                this.logger.warn(`Session applicant ${applicant} marked as expired`);
+                this.logger.warn(
+                    `Session applicant ${applicant} marked as expired`,
+                );
                 try {
                     await this.end(applicant);
                 } catch (e) {
-                    this.logger.error(`Session applicant ${applicant} failed to stop`, e);
+                    this.logger.error(
+                        `Session applicant ${applicant} failed to stop`,
+                        e,
+                    );
                 }
                 this.expiredBrowserClients.add(applicant);
             }
@@ -260,7 +342,9 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         }
 
         if (this.expiredBrowserClients.has(applicant)) {
-            throw Error(`This session expired in ${this.config.clientTimeout}ms`);
+            throw Error(
+                `This session expired in ${this.config.clientTimeout}ms`,
+            );
         }
 
         const client = await remote(this.config);
@@ -272,7 +356,9 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
             throw Error('Session can not be null');
         }
 
-        const customClient = this.addCustromMethods(client);
+        const customClient = this.addCustromMethods(
+            client as BrowserObjectCustom,
+        );
 
         this.browserClients.set(applicant, {
             client: customClient,
@@ -280,32 +366,45 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
             initTime: Date.now(),
         });
 
-        this.logger.debug(`Started session for applicant: ${applicant}. Session id: ${sessionId}`);
+        this.logger.debug(
+            `Started session for applicant: ${applicant}. Session id: ${sessionId}`,
+        );
     }
 
-    protected addCustromMethods(client: BrowserObject): BrowserObjectCustom {
+    protected addCustromMethods(
+        client: BrowserObjectCustom,
+    ): BrowserObjectCustom {
         // Creating our delete selenium session to be able to close
         // session if it's id is changed while we are running test
-        client.addCommand('deleteSessionId', function (sessionId) {
-            const { w3cCaps, jsonwpCaps } = this.options.requestedCapabilities;
-
-            const sessionDeleteRequest = new WebDriverRequest(
-                'DELETE',
-                '/session/:sessionId',
-                {
-                    capabilities: w3cCaps, // W3C compliant
-                    desiredCapabilities: jsonwpCaps, // JSONWP compliant
-                },
-            );
-
-            return sessionDeleteRequest.makeRequest(this.options, sessionId);
-        }, false);
+        client.addCommand(
+            'deleteSessionId',
+            function (sessionId) {
+                const {
+                    w3cCaps,
+                    jsonwpCaps,
+                } = this.options.requestedCapabilities;
+
+                const sessionDeleteRequest = new WebDriverRequest(
+                    'DELETE',
+                    '/session/:sessionId',
+                    {
+                        capabilities: w3cCaps, // W3C compliant
+                        desiredCapabilities: jsonwpCaps, // JSONWP compliant
+                    },
+                );
+
+                return sessionDeleteRequest.makeRequest(
+                    this.options,
+                    sessionId,
+                );
+            },
+            false,
+        );
 
         return client as BrowserObjectCustom;
     }
 
     public async end(applicant: string) {
-
         await this.waitForReadyState;
 
         if (!this.hasBrowserClient(applicant)) {
@@ -317,33 +416,44 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
 
         try {
             await this.alertDismiss(applicant);
-        } catch { /* ignore */ }
+        } catch {
+            /* ignore */
+        }
 
         const startingSessionID = this.getApplicantSessionId(applicant);
         const sessionID = client.sessionId;
 
         if (startingSessionID === sessionID) {
-            this.logger.debug(`Stopping sessions for applicant ${applicant}. Session id: ${sessionID}`);
+            this.logger.debug(
+                `Stopping sessions for applicant ${applicant}. Session id: ${sessionID}`,
+            );
             await client.deleteSession();
         } else {
             await this.logger.stepWarning(
-                `Stopping sessions for applicant warning ${applicant}. `
-                    + `Session ids are not equal, started with - ${startingSessionID}, ended with - ${sessionID}`,
+                `Stopping sessions for applicant warning ${applicant}. ` +
+                    `Session ids are not equal, started with - ${startingSessionID}, ended with - ${sessionID}`,
                 async () => {
                     try {
                         if (startingSessionID) {
                             await client.deleteSessionId(startingSessionID);
                         }
                     } catch (err) {
-                        this.logger.error(`Old session ${startingSessionID} delete error`, err);
+                        this.logger.error(
+                            `Old session ${startingSessionID} delete error`,
+                            err,
+                        );
                     }
 
                     try {
                         await client.deleteSession();
                     } catch (err) {
-                        this.logger.error(`New session ${client.sessionId} delete error`, err);
+                        this.logger.error(
+                            `New session ${client.sessionId} delete error`,
+                            err,
+                        );
                     }
-                });
+                },
+            );
         }
 
         this.browserClients.delete(applicant);
@@ -371,7 +481,11 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return client.refresh();
     }
 
-    public async click(applicant: string, selector: string, options?: ClickOptions) {
+    public async click(
+        applicant: string,
+        selector: string,
+        options?: ClickOptions,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
@@ -405,28 +519,44 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return `window-${this.incrementWinId}`;
     }
 
-    public async newWindow(applicant: string, val: string, windowName: string, windowFeatures: WindowFeaturesConfig = {}) {
+    public async newWindow(
+        applicant: string,
+        val: string,
+        windowName: string,
+        windowFeatures: WindowFeaturesConfig = {},
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
         const args = stringifyWindowFeatures(windowFeatures);
 
-        return client.newWindow(val, windowName || this.generateWinId(), args);
+        return client.newWindow(val, {
+            windowName: windowName || this.generateWinId(),
+            windowFeatures: args,
+        });
     }
 
-    public async waitForExist(applicant: string, xpath: string, timeout: number) {
+    public async waitForExist(
+        applicant: string,
+        xpath: string,
+        timeout: number,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
         const selector = await client.$(xpath);
-        return selector.waitForExist(timeout);
+        return selector.waitForExist({timeout});
     }
 
-    public async waitForVisible(applicant: string, xpath: string, timeout: number) {
+    public async waitForVisible(
+        applicant: string,
+        xpath: string,
+        timeout: number,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
         const selector = await client.$(xpath);
-        return selector.waitForDisplayed(timeout);
+        return selector.waitForDisplayed({timeout});
     }
 
     public async isVisible(applicant: string, xpath: string) {
@@ -437,12 +567,17 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return selector.isDisplayed();
     }
 
-    public async moveToObject(applicant: string, xpath: string, x: number, y: number) {
+    public async moveToObject(
+        applicant: string,
+        xpath: string,
+        xOffset = 0,
+        yOffset = 0,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
         const selector = await client.$(xpath);
-        return selector.moveTo(x || 0, y || 0);
+        return selector.moveTo({xOffset, yOffset});
     }
 
     public async execute(applicant: string, fn: any, args: Array<any>) {
@@ -492,14 +627,14 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
-        const elements = await client.findElements('xpath', xpath) as unknown;
+        const elements = (await client.findElements('xpath', xpath)) as unknown;
         return (elements as Array<Record<string, string>>).map((o) => {
             const keys = Object.keys(o);
-            return { 'ELEMENT': o[keys[0]] };
+            return {ELEMENT: o[keys[0]]};
         });
     }
 
-    public async frame(applicant: string, frameID: string) {
+    public async frame(applicant: string, frameID: number) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
@@ -545,7 +680,11 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return selector.selectByAttribute('value', value);
     }
 
-    public async selectByVisibleText(applicant: string, xpath: string, str: string) {
+    public async selectByVisibleText(
+        applicant: string,
+        xpath: string,
+        str: string,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
@@ -553,7 +692,11 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return selector.selectByVisibleText(str);
     }
 
-    public async getAttribute(applicant: string, xpath: string, attr: string): Promise<any> {
+    public async getAttribute(
+        applicant: string,
+        xpath: string,
+        attr: string,
+    ): Promise<any> {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
@@ -576,21 +719,32 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return selector.isEnabled();
     }
 
-    public async scroll(applicant: string, xpath: string, x: number, y: number) {
+    public async scroll(
+        applicant: string,
+        xpath: string,
+        xOffset: number,
+        yOffset: number,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
         const element = await client.$(xpath);
         await element.scrollIntoView();
-        return element.moveTo(x, y);
+        return element.moveTo({xOffset, yOffset});
     }
 
-    public async scrollIntoView(applicant: string, xpath: string, scrollIntoViewOptions?: boolean | null) {
+    public async scrollIntoView(
+        applicant: string,
+        xpath: string,
+        scrollIntoViewOptions?: boolean | null,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
         const element = await client.$(xpath);
-        await element.scrollIntoView(scrollIntoViewOptions !== null ? scrollIntoViewOptions : undefined);
+        await element.scrollIntoView(
+            scrollIntoViewOptions !== null ? scrollIntoViewOptions : undefined,
+        );
     }
 
     public async isAlertOpen(applicant: string) {
@@ -633,7 +787,11 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         throw Error('There is no open alert');
     }
 
-    public async dragAndDrop(applicant: string, xpathSource: string, xpathDestination: string) {
+    public async dragAndDrop(
+        applicant: string,
+        xpathSource: string,
+        xpathDestination: string,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
@@ -715,7 +873,7 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
 
         const result = await client.switchToWindow(tabId);
         const body = await client.$('body');
-        await client.waitUntil(async () => body.isExisting(), 10000);
+        await client.waitUntil(async () => body.isExisting(), {timeout: 10000});
 
         return result;
     }
@@ -732,10 +890,8 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         await client.switchToWindow(tabId);
 
         return client.closeWindow();
-
     }
 
-
     public async getTagName(applicant: string, xpath: string) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
@@ -774,14 +930,21 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return client.takeScreenshot();
     }
 
-    public async uploadFile(applicant: string, filePath: string): Promise<string | void> {
+    public async uploadFile(
+        applicant: string,
+        filePath: string,
+    ): Promise<string | void> {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
         return client.uploadFile(filePath);
     }
 
-    public async getCssProperty(applicant: string, xpath: string, cssProperty: string): Promise<any> {
+    public async getCssProperty(
+        applicant: string,
+        xpath: string,
+        cssProperty: string,
+    ): Promise<any> {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
@@ -805,24 +968,40 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return selector.isExisting();
     }
 
-    public async waitForValue(applicant: string, xpath: string, timeout: number, reverse: boolean) {
+    public async waitForValue(
+        applicant: string,
+        xpath: string,
+        timeout: number,
+        reverse: boolean,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
-        return client.waitUntil(async () => {
-            const elemValue = await (await client.$(xpath)).getValue();
-            return reverse ? !elemValue : !!elemValue;
-        }, timeout);
+        return client.waitUntil(
+            async () => {
+                const elemValue = await (await client.$(xpath)).getValue();
+                return reverse ? !elemValue : !!elemValue;
+            },
+            {timeout},
+        );
     }
 
-    public async waitForSelected(applicant: string, xpath: string, timeout: number, reverse: boolean) {
+    public async waitForSelected(
+        applicant: string,
+        xpath: string,
+        timeout: number,
+        reverse: boolean,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
-        return client.waitUntil(async () => {
-            const isSelected = await (await client.$(xpath)).isSelected();
-            return reverse ? !isSelected : isSelected;
-        }, timeout);
+        return client.waitUntil(
+            async () => {
+                const isSelected = await (await client.$(xpath)).isSelected();
+                return reverse ? !isSelected : isSelected;
+            },
+            {timeout},
+        );
     }
 
     public async waitUntil(
@@ -832,14 +1011,18 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         timeoutMsg?: string,
         interval?: number,
     ) {
-
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
-        return client.waitUntil(condition, timeout, timeoutMsg, interval);
+        return client.waitUntil(condition, {timeout, timeoutMsg, interval});
     }
 
-    public async selectByAttribute(applicant: string, xpath: string, attribute: string, value: string) {
+    public async selectByAttribute(
+        applicant: string,
+        xpath: string,
+        attribute: string,
+        value: string,
+    ) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
@@ -847,6 +1030,7 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return selector.selectByAttribute(attribute, value);
     }
 
+    // @deprecated WAT-1872
     public async gridProxyDetails(applicant: string) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
@@ -860,6 +1044,7 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return client.gridProxyDetails(client.sessionId);
     }
 
+    // @deprecated WAT-1872
     public async gridTestSession(applicant: string) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
@@ -873,13 +1058,14 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
         return client.gridTestSession(client.sessionId);
     }
 
+    // @deprecated WAT-1872
     public async getGridNodeDetails(applicant: string) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
 
         const testSession = await this.gridTestSession(applicant);
 
-        if (!testSession.localSelenium) {
+        if (testSession && !testSession.localSelenium) {
             const proxyDetails = await client.gridProxyDetails(applicant);
 
             delete testSession.msg;
@@ -889,14 +1075,61 @@ export class SeleniumPlugin implements IBrowserProxyPlugin {
             delete proxyDetails.success;
             delete proxyDetails.id;
 
-            return { ...testSession, ...proxyDetails };
+            return {...testSession, ...proxyDetails};
         }
 
         return testSession;
     }
+
+    /**
+     * @param overwrites should NOT be an arrow function, Otherwise it would throw an error
+     */
+    public async mock(
+        applicant: string,
+        url: string,
+        overwrites: ((res: Matches) => void) | Object | string,
+        filterOptions?: MockFilterOptions,
+        mockResponseParams?: MockResponseParams,
+    ) {
+        await this.createClient(applicant);
+        const client = this.getBrowserClient(applicant);
+
+        const mock = await client.mock(url, filterOptions);
+        if (typeof overwrites === 'function') {
+            mock.respond((res) => {
+                overwrites(res);
+                this.setMockData(applicant, url, res);
+                return res.body;
+            }, mockResponseParams);
+        } else {
+            mock.respond(overwrites);
+        }
+    }
+
+    public async setMockData(applicant: string, url: string, data: Matches) {
+        await this.createClient(applicant);
+        const client = this.getBrowserClient(applicant);
+
+        client.mockData = client.mockData || {};
+        if (client.mockData[url]) {
+            client.mockData[url].push(data);
+        } else {
+            client.mockData[url] = [data];
+        }
+        return true;
+    }
+
+    public async getMockData(applicant: string, url: string) {
+        await this.createClient(applicant);
+        const client = this.getBrowserClient(applicant);
+
+        if (url) {
+            return client.mockData[url];
+        }
+        return client.mockData;
+    }
 }
 
-// eslint-disable-next-line import/no-default-export
-export default function seleniumProxy(config: Config) {
+export default function seleniumProxy(config: SeleniumPluginConfig) {
     return new SeleniumPlugin(config);
 }

package/src/types.ts

@@ -1,6 +1,6 @@
-import { Config } from 'webdriverio';
+import {RemoteOptions} from 'webdriverio';
 
-export type SeleniumPluginConfig = WebdriverIO.RemoteOptions & Config & {
+export type SeleniumPluginConfig = RemoteOptions & {
     chromeDriverPath?: string;
     recorderExtension: boolean;
     clientCheckInterval: number;