@wdio/webdriver-mock-service 7.17.0 → 7.18.0

package/build/WebDriverMock.d.ts

@@ -0,0 +1,20 @@
+import nock from 'nock';
+export interface CommandMock {
+    [commandName: string]: (...args: any[]) => nock.Interceptor;
+}
+export default class WebDriverMock {
+    path: string;
+    command: CommandMock;
+    scope: nock.Scope;
+    constructor(host?: string, port?: number, path?: string);
+    /**
+     * To allow random session IDs in url paths we have to set up a custom
+     * matcher that strips out the sessionID part from the expected url
+     * and actual url and replaces it with a constant session id
+     * @param   {String}   expectedPath path to match against
+     * @returns {Function}              to be called by Nock to match actual path
+     */
+    static pathMatcher(expectedPath: string): (path: string) => boolean;
+    get(obj: any, commandName: string): (...args: any[]) => nock.Interceptor;
+}
+//# sourceMappingURL=WebDriverMock.d.ts.map

package/build/WebDriverMock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebDriverMock.d.ts","sourceRoot":"","sources":["../src/WebDriverMock.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AAmBvB,MAAM,WAAW,WAAW;IACxB,CAAC,WAAW,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC,WAAW,CAAA;CAC9D;AAUD,MAAM,CAAC,OAAO,OAAO,aAAa;IAGsC,IAAI,EAAE,MAAM;IAFhF,OAAO,EAAE,WAAW,CAAA;IACpB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAA;gBACL,IAAI,GAAE,MAAoB,EAAE,IAAI,GAAE,MAAa,EAAS,IAAI,GAAE,MAAY;IAKtF;;;;;;OAMG;IACH,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,CAAC,IAAI,EAAC,MAAM,KAAI,OAAO;IAqBjE,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,aAIZ,GAAG,EAAE;CAoC7B"}

package/build/WebDriverMock.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock_1 = __importDefault(require("nock"));
+const protocols_1 = require("@wdio/protocols");
+const REGEXP_SESSION_ID = /\/[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}/;
+const SESSION_ID = 'XXX';
+const protocols = [
+    protocols_1.JsonWProtocol, protocols_1.WebDriverProtocol, protocols_1.MJsonWProtocol, protocols_1.AppiumProtocol,
+    protocols_1.ChromiumProtocol, protocols_1.SauceLabsProtocol, protocols_1.SeleniumProtocol
+];
+const protocolFlattened = new Map();
+for (const protocol of protocols) {
+    for (const [endpoint, methods] of Object.entries(protocol)) {
+        for (const [method, commandData] of Object.entries(methods)) {
+            protocolFlattened.set(commandData.command, { method, endpoint, commandData });
+        }
+    }
+}
+class WebDriverMock {
+    constructor(host = 'localhost', port = 4444, path = '/') {
+        this.path = path;
+        this.scope = (0, nock_1.default)(`http://${host}:${port}`, { 'encodedQueryParams': true });
+        this.command = new Proxy({}, { get: this.get.bind(this) });
+    }
+    /**
+     * To allow random session IDs in url paths we have to set up a custom
+     * matcher that strips out the sessionID part from the expected url
+     * and actual url and replaces it with a constant session id
+     * @param   {String}   expectedPath path to match against
+     * @returns {Function}              to be called by Nock to match actual path
+     */
+    static pathMatcher(expectedPath) {
+        return (path) => {
+            const sessionId = path.match(REGEXP_SESSION_ID);
+            /**
+             * no session ID found so we can check against expected path directly
+             */
+            if (!sessionId) {
+                return path === expectedPath;
+            }
+            /**
+             * remove the session ID from expected and actual path
+             * to only compare non arbitrary parts
+             */
+            expectedPath = expectedPath.replace(':sessionId', SESSION_ID);
+            path = path.replace(`${sessionId[0].slice(1)}`, SESSION_ID);
+            return path === expectedPath;
+        };
+    }
+    get(obj, commandName) {
+        const { method, endpoint, commandData } = protocolFlattened.get(commandName);
+        return (...args) => {
+            let urlPath = endpoint;
+            for (const [i, param] of Object.entries(commandData.variables || [])) {
+                urlPath = urlPath.replace(`:${param.name}`, args[parseInt(i)]);
+            }
+            if (method === 'POST') {
+                const reqMethod = method.toLowerCase();
+                return this.scope[reqMethod](WebDriverMock.pathMatcher(urlPath), (body) => {
+                    for (const param of commandData.parameters) {
+                        /**
+                         * check if parameter was set
+                         */
+                        if (!body[param.name]) {
+                            return false;
+                        }
+                        /**
+                         * check if parameter has correct type
+                         */
+                        if (param.required && typeof body[param.name] === 'undefined') {
+                            return false;
+                        }
+                    }
+                    /**
+                     * all parameters are valid
+                     */
+                    return true;
+                });
+            }
+            const reqMethod = method.toLowerCase();
+            return this.scope[reqMethod](WebDriverMock.pathMatcher(urlPath));
+        };
+    }
+}
+exports.default = WebDriverMock;

package/build/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const NO_SUCH_ELEMENT: {
+    value: {
+        error: string;
+        message: string;
+        stacktrace: string;
+    };
+};
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;CAM3B,CAAA"}

package/build/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_SUCH_ELEMENT = void 0;
+exports.NO_SUCH_ELEMENT = {
+    value: {
+        error: 'no such element',
+        message: 'Unable to locate element: bodys',
+        stacktrace: 'WebDriverError@chrome://marionette/content/error.js:179:5\nNoSuchElementError@chrome://marionette/content/error.js:389:5\nelement.find/</<@chrome://marionette/content/element.js:339:16\n'
+    }
+};

package/build/index.d.ts

@@ -0,0 +1,30 @@
+import type { Services } from '@wdio/types';
+import type { Browser, MultiRemoteBrowser } from 'webdriverio';
+import WebDriverMock from './WebDriverMock';
+export default class WebdriverMockService implements Services.ServiceInstance {
+    private _browser?;
+    private _mock;
+    constructor();
+    init(): void;
+    before(caps: unknown, specs: unknown, browser: Browser<'async'> | MultiRemoteBrowser<'async'>): void;
+    clickScenario(): void;
+    isExistingScenario(): void;
+    isNotExistingScenario(): void;
+    waitForElementScenario(): void;
+    isNeverDisplayedScenario(): void;
+    isEventuallyDisplayedScenario(): void;
+    staleElementRefetchScenario(): void;
+    asyncIterationScenario(): string[];
+    parentNextPreviousElementChaining(): void;
+    multiremoteFetch(): void;
+    customCommandScenario(times?: number): void;
+    customSelectorScenario(): void;
+    waitForDisplayedScenario(): void;
+    cucumberScenario(): void;
+    nockReset(): void;
+}
+/**
+ * export for 3rd party usage
+ */
+export { WebDriverMock };
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAE9D,OAAO,aAAa,MAAM,iBAAiB,CAAA;AAW3C,MAAM,CAAC,OAAO,OAAO,oBAAqB,YAAW,QAAQ,CAAC,eAAe;IACzE,OAAO,CAAC,QAAQ,CAAC,CAAgD;IACjE,OAAO,CAAC,KAAK,CAAsB;;IAMnC,IAAI;IAgBJ,MAAM,CACF,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,kBAAkB,CAAC,OAAO,CAAC;IAuB3D,aAAa;IAQb,kBAAkB;IASlB,qBAAqB;IAKrB,sBAAsB;IAYtB,wBAAwB;IAUxB,6BAA6B;IAU7B,2BAA2B;IA+B3B,sBAAsB;IAOtB,iCAAiC;IAQjC,gBAAgB;IAShB,qBAAqB,CAAC,KAAK,SAAI;IAa/B,sBAAsB;IAUtB,wBAAwB;IASxB,gBAAgB;IAShB,SAAS;CAIZ;AAED;;GAEG;AACH,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/build/index.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDriverMock = void 0;
+const nock_1 = __importDefault(require("nock"));
+const uuid_1 = require("uuid");
+const WebDriverMock_1 = __importDefault(require("./WebDriverMock"));
+exports.WebDriverMock = WebDriverMock_1.default;
+const constants_1 = require("./constants");
+const newSession_1 = require("./mocks/newSession");
+const ELEMENT_ID = '401c0039-3306-6a46-a98d-f5939870a249';
+const ELEMENT_REFETCHED = '80d860d0-b829-f540-812e-7078eb983795';
+const ELEMENT_ALT = '8bf4d107-a363-40d1-b823-d94bdbc58afb';
+const ELEM_PROP = 'element-6066-11e4-a52e-4f735466cecf';
+class WebdriverMockService {
+    constructor() {
+        this._mock = new WebDriverMock_1.default();
+        this.init();
+    }
+    init() {
+        // define required responses
+        this._mock.command.status().times(Infinity).reply(200, { value: {} });
+        this._mock.command.newSession().times(Infinity).reply(200, () => {
+            newSession_1.newSession.value.sessionId = (0, uuid_1.v4)();
+            return newSession_1.newSession;
+        });
+        this._mock.command.deleteSession().times(2).reply(200, newSession_1.deleteSession);
+        this._mock.command.getTitle().times(Infinity).reply(200, { value: 'Mock Page Title' });
+        this._mock.command.getUrl().times(Infinity).reply(200, { value: 'https://mymockpage.com' });
+        this._mock.command.getElementRect(ELEMENT_ID).times(2).reply(200, { value: { width: 1, height: 2, x: 3, y: 4 } });
+        this._mock.command.getElementRect(ELEMENT_ALT).times(3).reply(200, { value: { width: 10, height: 20, x: 30, y: 40 } });
+        this._mock.command.getElementRect(ELEMENT_REFETCHED).times(1).reply(200, { value: { width: 1, height: 2, x: 3, y: 4 } });
+        this._mock.command.getLogTypes().reply(200, { value: [] });
+    }
+    before(caps, specs, browser) {
+        this._browser = browser;
+        /**
+         * register request interceptors for specific scenarios
+         */
+        this._browser.addCommand('waitForElementScenario', this.waitForElementScenario.bind(this));
+        this._browser.addCommand('isNeverDisplayedScenario', this.isNeverDisplayedScenario.bind(this));
+        this._browser.addCommand('isEventuallyDisplayedScenario', this.isEventuallyDisplayedScenario.bind(this));
+        this._browser.addCommand('staleElementRefetchScenario', this.staleElementRefetchScenario.bind(this));
+        this._browser.addCommand('customCommandScenario', this.customCommandScenario.bind(this));
+        this._browser.addCommand('customSelectorScenario', this.customSelectorScenario.bind(this));
+        this._browser.addCommand('waitForDisplayedScenario', this.waitForDisplayedScenario.bind(this));
+        this._browser.addCommand('cucumberScenario', this.cucumberScenario.bind(this));
+        this._browser.addCommand('clickScenario', this.clickScenario.bind(this));
+        this._browser.addCommand('isExistingScenario', this.isExistingScenario.bind(this));
+        this._browser.addCommand('isNotExistingScenario', this.isNotExistingScenario.bind(this));
+        this._browser.addCommand('multiremoteFetch', this.multiremoteFetch.bind(this));
+        this._browser.addCommand('asyncIterationScenario', this.asyncIterationScenario.bind(this));
+        this._browser.addCommand('parentElementChaining', this.parentNextPreviousElementChaining.bind(this));
+    }
+    clickScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        this._mock.command.findElement().times(2).reply(200, { value: elemResponse });
+        this._mock.command.elementClick(ELEMENT_ID).once().reply(200, { value: null });
+    }
+    isExistingScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        this._mock.command.findElement().times(1).reply(200, { value: elemResponse });
+        this._mock.command.findElementFromElement(ELEMENT_ID).times(2).reply(200, { value: elemResponse });
+        this._mock.command.findElementsFromElement(ELEMENT_ID).times(2).reply(200, { value: [elemResponse] });
+    }
+    isNotExistingScenario() {
+        this.nockReset();
+        this._mock.command.findElement().reply(404, constants_1.NO_SUCH_ELEMENT);
+    }
+    waitForElementScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        this._mock.command.findElement().once().reply(404, constants_1.NO_SUCH_ELEMENT);
+        this._mock.command.findElement().times(2).reply(200, { value: elemResponse });
+        this._mock.command.findElements().times(5).reply(200, { value: [] });
+        this._mock.command.findElements().reply(200, { value: [elemResponse] });
+        this._mock.command.elementClick(ELEMENT_ID).once().reply(200, { value: null });
+    }
+    isNeverDisplayedScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        this._mock.command.findElement().times(2).reply(404, constants_1.NO_SUCH_ELEMENT);
+        this._mock.command.findElement().times(2).reply(200, { value: elemResponse });
+        this._mock.command.isElementDisplayed(ELEMENT_ID).once().reply(200, { value: true });
+    }
+    isEventuallyDisplayedScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        this._mock.command.findElement().times(1).reply(404, constants_1.NO_SUCH_ELEMENT);
+        this._mock.command.findElement().times(2).reply(200, { value: elemResponse });
+        this._mock.command.isElementDisplayed(ELEMENT_ID).once().reply(200, { value: true });
+    }
+    staleElementRefetchScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        const elem2Response = { [ELEM_PROP]: ELEMENT_REFETCHED };
+        //Found initially
+        this._mock.command.findElement().once().reply(200, { value: elemResponse });
+        //Initiate refetch, but its not ready
+        this._mock.command.findElement().once().reply(404, constants_1.NO_SUCH_ELEMENT);
+        //Always return the new element after
+        this._mock.command.findElement().times(4).reply(200, { value: elem2Response });
+        //First click works
+        this._mock.command.elementClick(ELEMENT_ID).once().reply(200, { value: null });
+        //Additional clicks won't for the original element
+        this._mock.command.elementClick(ELEMENT_ID).times(4).reply(500, {
+            value: {
+                error: 'stale element reference',
+                message: 'element is not attached to the page document'
+            }
+        });
+        //Clicks on the new element are successful
+        this._mock.command.elementClick(ELEMENT_REFETCHED).times(4).reply(200, { value: null });
+        //Wait for it to exist - but 2 failed iterations
+        this._mock.command.findElements().times(2).reply(200, { value: [] });
+        //Always appears thereafter
+        this._mock.command.findElements().times(4).reply(200, { value: [elem2Response] });
+    }
+    asyncIterationScenario() {
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        const elem2Response = { [ELEM_PROP]: ELEMENT_REFETCHED };
+        this._mock.command.findElements().reply(200, { value: [elemResponse, elem2Response] });
+        return [ELEMENT_ID, ELEMENT_REFETCHED];
+    }
+    parentNextPreviousElementChaining() {
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        const elemParentResponse = { [ELEM_PROP]: ELEMENT_REFETCHED };
+        this._mock.command.findElement().reply(200, { value: elemResponse });
+        this._mock.command.executeScript().reply(200, { value: elemParentResponse });
+        this._mock.command.getElementText(ELEMENT_REFETCHED).reply(200, { value: 'some element text' });
+    }
+    multiremoteFetch() {
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        const elem2Response = { [ELEM_PROP]: ELEMENT_REFETCHED };
+        this._mock.command.findElement().twice().reply(200, { value: elemResponse });
+        this._mock.command.findElementFromElement(ELEMENT_ID).twice().reply(200, { value: elem2Response });
+        this._mock.command.elementClick(ELEMENT_REFETCHED).twice().reply(200, { value: null });
+    }
+    customCommandScenario(times = 1) {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        const elemAltResponse = { [ELEM_PROP]: ELEMENT_ALT };
+        this._mock.command.findElement().times(times).reply(200, { value: elemResponse });
+        this._mock.command.findElement().times(times).reply(200, { value: elemAltResponse });
+        this._mock.command.executeScript().times(times).reply(200, { value: '2' });
+        // overwrite
+        this._mock.command.deleteAllCookies().times(times).reply(200, { value: 'deleteAllCookies' });
+    }
+    customSelectorScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        const elemAltResponse = { [ELEM_PROP]: ELEMENT_ALT };
+        this._mock.command.findElement().reply(200, { value: elemResponse });
+        this._mock.command.executeScript().reply(200, { value: elemAltResponse });
+        this._mock.command.findElementFromElement(ELEMENT_ALT).reply(200, { value: elemResponse });
+    }
+    waitForDisplayedScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        this._mock.command.findElement().once().reply(200, { value: elemResponse });
+        this._mock.command.isElementDisplayed(ELEMENT_ID).times(4).reply(200, { value: false });
+        this._mock.command.isElementDisplayed(ELEMENT_ID).once().reply(200, { value: true });
+    }
+    cucumberScenario() {
+        this.nockReset();
+        const elemResponse = { [ELEM_PROP]: ELEMENT_ID };
+        this._mock.command.navigateTo().reply(200, { value: null });
+        this._mock.command.findElement().times(4).reply(200, { value: elemResponse });
+        this._mock.command.elementClick(ELEMENT_ID).reply(200, { value: null });
+    }
+    nockReset() {
+        nock_1.default.cleanAll();
+        this.init();
+    }
+}
+exports.default = WebdriverMockService;

package/build/mocks/newSession.d.ts

@@ -0,0 +1,29 @@
+export declare const newSession: {
+    value: {
+        sessionId: string;
+        capabilities: {
+            acceptInsecureCerts: boolean;
+            browserName: string;
+            browserVersion: number;
+            pageLoadStrategy: string;
+            platformName: string;
+            platformVersion: string;
+            rotatable: boolean;
+            setWindowRect: boolean;
+            timeouts: {}[];
+            unhandledPromptBehavior: string;
+            'moz:accessibilityChecks': boolean;
+            'moz:geckodriverVersion': string;
+            'moz:headless': boolean;
+            'moz:processID': number;
+            'moz:profile': string;
+            'moz:shutdownTimeout': number;
+            'moz:useNonSpecCompliantPointerOrigin': boolean;
+            'moz:webdriverClick': boolean;
+        };
+    };
+};
+export declare const deleteSession: {
+    value: null;
+};
+//# sourceMappingURL=newSession.d.ts.map

package/build/mocks/newSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newSession.d.ts","sourceRoot":"","sources":["../../src/mocks/newSession.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;CAwBtB,CAAA;AAED,eAAO,MAAM,aAAa;;CAEzB,CAAA"}

package/build/mocks/newSession.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSession = exports.newSession = void 0;
+exports.newSession = {
+    value: {
+        sessionId: 'undefined',
+        capabilities: {
+            acceptInsecureCerts: false,
+            browserName: 'firefox',
+            browserVersion: 64.0,
+            pageLoadStrategy: 'normal',
+            platformName: 'mac',
+            platformVersion: '17.7.0',
+            rotatable: false,
+            setWindowRect: true,
+            timeouts: [{}],
+            unhandledPromptBehavior: 'dismiss and notify',
+            'moz:accessibilityChecks': false,
+            'moz:geckodriverVersion': '0.23.0',
+            'moz:headless': false,
+            'moz:processID': 15867,
+            'moz:profile': '/var/folders/ns/8mj2mh0x27b_gsdddy1knnsm0000gn/T/rust_mozprofile.yUuH0ktcRJPN',
+            'moz:shutdownTimeout': 60000,
+            'moz:useNonSpecCompliantPointerOrigin': false,
+            'moz:webdriverClick': true
+        }
+    }
+};
+exports.deleteSession = {
+    value: null
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/webdriver-mock-service",
-  "version": "7.17.0",
+  "version": "7.18.0",
   "description": "A WebdriverIO service to stub all endpoints for internal testing purposes.",
   "author": "Christian Bromann <christian@saucelabs.com>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-webdriver-mock-service",
@@ -19,15 +19,15 @@
   },
   "dependencies": {
     "@types/uuid": "^8.3.0",
-    "@wdio/protocols": "7.16.7",
-    "@wdio/types": "7.16.14",
+    "@wdio/protocols": "7.17.3",
+    "@wdio/types": "7.18.0",
     "nock": "^13.0.0",
     "uuid": "^8.0.0",
-    "webdriverio": "7.17.0"
+    "webdriverio": "7.18.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "types": "./build/index.d.ts",
-  "gitHead": "e18d2cde6ff979758830bdff4c3bc82ca9818b24"
+  "gitHead": "44729cdd585af3ad69f2093f32377f297f5ac344"
 }