@applitools/core 4.61.0 → 4.61.1-debug.0

package/dist/universal/history.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withHistory = void 0;
+//TODO Design a better history tracker
+function withHistory(socket) {
+    const history = {
+        managers: new Map(),
+        eyes: new Map(),
+        startedAt: new Date().toISOString(),
+        unknownEvents: [],
+    };
+    const originalCommand = socket.command;
+    socket.command = function command(name, fn) {
+        return originalCommand(name, async (payload) => {
+            let result, error;
+            try {
+                result = await fn(payload);
+                return result;
+            }
+            catch (err) {
+                error = err;
+                throw error;
+            }
+            finally {
+                if (name === 'Core.makeManager') {
+                    const managerRef = result;
+                    history.managers.set(extractRefId(managerRef), { ...payload, manager: result, eyes: [] });
+                }
+                else if (name.startsWith('EyesManager.')) {
+                    const managerRef = payload.manager;
+                    const managerHistory = history.managers.get(extractRefId(managerRef));
+                    if (managerHistory) {
+                        if (name === 'EyesManager.openEyes') {
+                            if (error) {
+                                managerHistory.eyes.push({ ...payload, error });
+                            }
+                            else {
+                                const eyesRef = result;
+                                managerHistory.eyes.push(eyesRef);
+                                history.eyes.set(extractRefId(eyesRef), { ...payload, eyes: eyesRef, commands: [] });
+                            }
+                        }
+                    }
+                }
+                else if (name.startsWith('Eyes.')) {
+                    const eyesRef = payload.eyes;
+                    const eyesHistory = history.eyes.get(extractRefId(eyesRef));
+                    if (eyesHistory) {
+                        if (name === 'Eyes.check') {
+                            const command = { name, ...payload };
+                            if (error)
+                                command.error = error;
+                            else
+                                command.result = result;
+                            eyesHistory.commands.push(command);
+                        }
+                        else if (name === 'Eyes.close') {
+                            eyesHistory.closed = true;
+                        }
+                        else if (name === 'Eyes.abort') {
+                            eyesHistory.aborted = true;
+                        }
+                        else if (name === 'Eyes.getResults') {
+                            eyesHistory.result = error !== null && error !== void 0 ? error : result;
+                        }
+                    }
+                }
+                else {
+                    history.unknownEvents.push({ name, payload });
+                }
+            }
+        });
+    };
+    return function getHistory() {
+        return {
+            managers: Array.from(history.managers.values(), managerMeta => ({
+                ...managerMeta,
+                eyes: managerMeta.eyes.map(eyesRefOrError => {
+                    return eyesRefOrError instanceof Error ? eyesRefOrError : history.eyes.get(extractRefId(eyesRefOrError));
+                }),
+            })),
+            startedAt: history.startedAt,
+            requestedAt: new Date().toISOString(),
+        };
+    };
+    function extractRefId(ref) {
+        return ref['applitools-ref-id'];
+    }
+}
+exports.withHistory = withHistory;

package/dist/universal/refer.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRefer = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const REF_ID = 'applitools-ref-id';
+function makeRefer() {
+    const store = new Map();
+    const relation = new Map();
+    return { isRef, ref, deref, destroy };
+    function isRef(ref) {
+        return Boolean(ref[REF_ID]);
+    }
+    function ref(value, parentRef) {
+        const ref = utils.general.guid();
+        store.set(ref, value);
+        if (parentRef) {
+            let childRefs = relation.get(parentRef[REF_ID]);
+            if (!childRefs) {
+                childRefs = new Set();
+                relation.set(parentRef[REF_ID], childRefs);
+            }
+            childRefs.add({ [REF_ID]: ref });
+        }
+        return { [REF_ID]: ref };
+    }
+    function deref(ref) {
+        if (isRef(ref)) {
+            return store.get(ref[REF_ID]);
+        }
+        else {
+            return ref;
+        }
+    }
+    function destroy(ref) {
+        if (!isRef(ref))
+            return;
+        const childRefs = relation.get(ref[REF_ID]);
+        if (childRefs) {
+            childRefs.forEach(childRef => destroy(childRef));
+        }
+        store.delete(ref[REF_ID]);
+    }
+}
+exports.makeRefer = makeRefer;

package/dist/universal/spec-driver.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSpec = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function makeSpec({ socket, spec, }) {
+    const commands = {
+        isDriver(driver) {
+            return utils.types.has(driver, 'applitools-ref-id');
+        },
+        isContext(context) {
+            return utils.types.has(context, 'applitools-ref-id');
+        },
+        isElement(element) {
+            return utils.types.has(element, ['applitools-ref-id', 'type']) && element.type === 'element';
+        },
+        isSelector(selector) {
+            return ((utils.types.has(selector, ['applitools-ref-id', 'type']) && selector.type === 'selector') ||
+                utils.types.isString(selector) ||
+                (utils.types.isPlainObject(selector) &&
+                    utils.types.has(selector, 'selector') &&
+                    (utils.types.isString(selector.selector) || utils.types.has(selector, 'applitools-ref-id'))));
+        },
+        async isEqualElements(context, element1, element2) {
+            return socket.request('Driver.isEqualElements', { context, element1, element2 });
+        },
+        isStaleElementError(error) {
+            return error === null || error === void 0 ? void 0 : error.isStaleElementError;
+        },
+        extractContext(driver) {
+            return driver.context;
+        },
+        extractSelector(element) {
+            return element.selector;
+        },
+        async executeScript(context, script, arg) {
+            return socket.request('Driver.executeScript', { context, script: script.toString(), arg });
+        },
+        async findElement(context, selector, parent) {
+            return socket.request('Driver.findElement', { context, selector, parent });
+        },
+        async findElements(context, selector, parent) {
+            return socket.request('Driver.findElements', { context, selector, parent });
+        },
+        async waitForSelector(context, selector, parent, options) {
+            return socket.request('Driver.waitForSelector', { context, selector, parent, options });
+        },
+        async getElementText(context, element) {
+            return socket.request('Driver.getElementText', { context, element });
+        },
+        async setElementText(context, element, text) {
+            return socket.request('Driver.setElementText', { context, element, text });
+        },
+        async getElementRegion(context, element) {
+            return socket.request('Driver.getElementRegion', { context, element });
+        },
+        async getElementAttribute(context, element, attr) {
+            return socket.request('Driver.getElementAttribute', { context, element, attr });
+        },
+        async hover(context, element) {
+            return socket.request('Driver.hover', { context, element });
+        },
+        async click(context, element) {
+            return socket.request('Driver.click', { context, element });
+        },
+        async mainContext(context) {
+            return socket.request('Driver.mainContext', { context });
+        },
+        async parentContext(context) {
+            return socket.request('Driver.parentContext', { context });
+        },
+        async childContext(context, element) {
+            return socket.request('Driver.childContext', { context, element });
+        },
+        async getCapabilities(driver) {
+            return socket.request('Driver.getCapabilities', { driver });
+        },
+        async getDriverInfo(driver) {
+            return socket.request('Driver.getDriverInfo', { driver });
+        },
+        async getWindowSize(driver) {
+            return socket.request('Driver.getWindowSize', { driver });
+        },
+        async setWindowSize(driver, size) {
+            return socket.request('Driver.setWindowSize', { driver, size });
+        },
+        async getViewportSize(driver) {
+            return socket.request('Driver.getViewportSize', { driver });
+        },
+        async setViewportSize(driver, size) {
+            return socket.request('Driver.setViewportSize', { driver, size });
+        },
+        async getSystemBars(driver) {
+            return socket.request('Driver.getSystemBars', { driver });
+        },
+        async getOrientation(driver) {
+            return socket.request('Driver.getOrientation', { driver });
+        },
+        async setOrientation(driver, orientation) {
+            return socket.request('Driver.setOrientation', { driver, orientation });
+        },
+        async getCookies(driver, context) {
+            return socket.request('Driver.getCookies', { driver, context });
+        },
+        async getTitle(driver) {
+            return socket.request('Driver.getTitle', { driver });
+        },
+        async getUrl(driver) {
+            return socket.request('Driver.getUrl', { driver });
+        },
+        async takeScreenshot(driver) {
+            return socket.request('Driver.takeScreenshot', { driver });
+        },
+        async performAction(driver, steps) {
+            return socket.request('Driver.performAction', { driver, steps });
+        },
+        async visit(driver, url) {
+            return socket.request('Driver.visit', { driver, url });
+        },
+        async getCurrentWorld(driver) {
+            return socket.request('Driver.getCurrentWorld', { driver });
+        },
+        async getWorlds(driver) {
+            return socket.request('Driver.getWorlds', { driver });
+        },
+        async switchWorld(driver, name) {
+            return socket.request('Driver.switchWorld', { driver, name });
+        },
+        async reload(driver) {
+            return socket.request('Driver.reload', { driver });
+        },
+        async isUserFunction(ref) {
+            return utils.types.has(ref, 'applitools-ref-id');
+        },
+        async executeUserFunction(userFunction) {
+            return socket.request('Driver.executeUserFunction', userFunction);
+        },
+        async executeBrowserCommands(driver, commands) {
+            return socket.request('Driver.executeBrowserCommands', { driver, commands });
+        },
+        async bringToFront(driver) {
+            return socket.request('Driver.bringToFront', { driver });
+        },
+    };
+    // add default commands to spec (if not already there) such as `isUserFunction`
+    spec = addDefaultCommands(spec);
+    return spec.reduce((spec, name) => {
+        return Object.assign(spec, { [name]: commands[name] });
+    }, {});
+}
+exports.makeSpec = makeSpec;
+// returns a new clone of the spec commands array with additional commands universal can support even if the spec doesn't
+function addDefaultCommands(spec) {
+    const defaultCommands = [
+        {
+            command: 'isUserFunction',
+            dependsOn: ['executeUserFunction'],
+        },
+    ];
+    const commands = spec.slice();
+    defaultCommands.forEach(({ command, dependsOn }) => {
+        if (!commands.includes(command) && dependsOn.every(dep => commands.includes(dep))) {
+            commands.push(command);
+        }
+    });
+    return commands;
+}

package/dist/universal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/universal/ws-server.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeServer = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const ws_1 = require("ws");
+const { name, version } = require('../../package.json');
+const TOKEN_HEADER = 'x-eyes-universal-token';
+const TOKEN = `${name}@${version}`;
+async function makeServer(options = {}, logger) {
+    const { port = 21077, singleton = true, debug = false, portResolutionMode = 'next', cert, key } = options;
+    const secure = Boolean(cert && key);
+    const http = secure ? new https_1.Server({ cert, key }) : new http_1.Server();
+    http.on('request', (request, response) => {
+        if (request.url === '/handshake') {
+            const token = debug ? request.headers[TOKEN_HEADER] : TOKEN;
+            if (request.headers[TOKEN_HEADER] === token) {
+                response.writeHead(200, { [TOKEN_HEADER]: token });
+            }
+            else {
+                response.writeHead(400);
+            }
+            response.end();
+        }
+    });
+    const hostName = process.env.APPLITOOLS_UNIVERSAL_HOST_NAME || 'localhost';
+    http.listen(port, hostName);
+    return new Promise((resolve, reject) => {
+        http.on('listening', () => {
+            const ws = new ws_1.Server({ server: http, path: '/eyes', maxPayload: 256 * 1024 * 1024 });
+            ws.on('close', () => {
+                logger.log('Core universal server is closed');
+                http.close();
+            });
+            ws.on('error', err => {
+                logger.log('Core universal server error', err);
+            });
+            resolve({ server: ws, port: http.address().port });
+        });
+        http.on('error', async (err) => {
+            if (portResolutionMode !== 'lazy' && err.code === 'EADDRINUSE') {
+                if (singleton && (await isHandshakable({ port, secure }))) {
+                    return resolve({ port });
+                }
+                else {
+                    return resolve(await makeServer({ ...options, port: portResolutionMode === 'next' ? port + 1 : 0 }, logger));
+                }
+            }
+            reject(err);
+        });
+    });
+}
+exports.makeServer = makeServer;
+async function isHandshakable({ port, secure }) {
+    const request = secure ? https_1.request : http_1.request;
+    return new Promise(resolve => {
+        const handshake = request(`${secure ? 'https' : 'http'}://localhost:${port}/handshake`, {
+            headers: { [TOKEN_HEADER]: TOKEN },
+        });
+        handshake.on('response', ({ statusCode, headers }) => {
+            resolve(statusCode === 200 && headers[TOKEN_HEADER] === TOKEN);
+        });
+        handshake.on('error', () => resolve(false));
+        handshake.end();
+    });
+}