@applitools/core 2.0.1 → 2.2.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Change Log
+
+## Unreleased
+
+## 2.2.0 - 2023/2/15
+
+### Features
+- Integrate universal protocol to run core via transport
+### Bug fixes
+
+## 2.0.2 - 2022/12/27
+
+### Features
+- Created
+### Bug fixes

package/dist/cli/cli.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_server_1 = require("../universal/core-server");
+const core_server_process_1 = require("../universal/core-server-process");
+const yargs_1 = __importDefault(require("yargs"));
+yargs_1.default
+    .example([
+    ['eyes universal', 'Run Eyes Universal server on default port (21077)'],
+    ['eyes universal --fork', 'Run Eyes Universal server in a forked process'],
+    ['eyes universal --port 8080', 'Run Eyes Universal server on port 8080'],
+    ['eyes universal --no-singleton', 'Run Eyes Universal server on a non-singleton mode'],
+    ['eyes universal --shutdown-mode stdin', 'Run Eyes Universal server which will close once stdin stream will end'],
+    ['eyes check-network', ''],
+])
+    .command({
+    command: 'universal',
+    builder: yargs => yargs.options({
+        port: {
+            description: 'run server on a specific port.',
+            type: 'number',
+            default: 21077,
+        },
+        singleton: {
+            description: 'runs server on a singleton mode. It will prevent the server to start in case the same server is already started.',
+            type: 'boolean',
+            default: true,
+        },
+        fork: {
+            description: 'runs server in a forked process.',
+            type: 'boolean',
+            default: false,
+        },
+        debug: {
+            description: 'runs server in a debug mode.',
+            type: 'boolean',
+            default: false,
+        },
+        'port-resolution-mode': {
+            describe: 'preferred algorithm to solve port collisions.\n"lazy" mode will not try find free port.\n"random" mode will run on a random port.\n"next" mode will run on next free port after the given one.',
+            alias: 'port-resolution',
+            type: 'string',
+            default: 'next',
+        },
+        'shutdown-mode': {
+            describe: 'preferred algorithm to automatically kill the process.\n"lazy" mode will end the process once the idle timeout ran out after the last client is disconnected from the server.\n"stdin" mode will end the process once its stdin stream got to its end.',
+            alias: 'shutdown',
+            type: 'string',
+            default: 'lazy',
+        },
+        'idle-timeout': {
+            description: 'time in minutes for server to stay responsible in case of idle.',
+            type: 'number',
+            default: 15,
+            coerce: value => value * 60 * 1000,
+        },
+        cert: {
+            description: 'path to the certificate file.',
+            alias: 'cert-path',
+            type: 'string',
+            implies: 'key',
+        },
+        key: {
+            description: 'path to the key file.',
+            alias: 'key-path',
+            type: 'string',
+            implies: 'cert',
+        },
+        config: {
+            description: 'json string to use instead of cli arguments',
+            type: 'string',
+            coerce: JSON.parse,
+        },
+    }),
+    handler: async (args) => {
+        if (args.fork) {
+            const { port } = await (0, core_server_process_1.makeCoreServerProcess)({ ...args, fork: false });
+            // eslint-disable-next-line no-console
+            console.log(port); // NOTE: this is a part of the generic protocol
+        }
+        else {
+            (0, core_server_1.makeCoreServer)({ ...args, ...args.config });
+        }
+    },
+})
+    .wrap(yargs_1.default.terminalWidth()).argv;

package/dist/index.js

@@ -29,6 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.takeDomSnapshots = exports.formatters = void 0;
 __exportStar(require("./types"), exports);
 __exportStar(require("./core"), exports);
+__exportStar(require("./universal/core-server"), exports);
+__exportStar(require("./universal/core-server-process"), exports);
 __exportStar(require("@applitools/driver/dist/debug"), exports);
 exports.formatters = __importStar(require("./utils/format-results"));
 var take_dom_snapshots_1 = require("./ufg/utils/take-dom-snapshots");

package/dist/make-manager.js

@@ -32,10 +32,10 @@ const get_manager_results_1 = require("./get-manager-results");
 const utils = __importStar(require("@applitools/utils"));
 function makeMakeManager({ spec, core, concurrency: defaultConcurrency = utils.general.getEnvValue('CONCURRENCY', 'number'), agentId: defaultAgentId, cwd = process.cwd(), logger: defaultLogger, }) {
     return async function makeManager({ type = 'classic', concurrency = defaultConcurrency, legacyConcurrency, batch, agentId = type === 'ufg' ? defaultAgentId === null || defaultAgentId === void 0 ? void 0 : defaultAgentId.replace(/(\/\d)/, '.visualgrid$1') : defaultAgentId, logger = defaultLogger, } = {}) {
-        var _a;
+        var _a, _b;
         concurrency !== null && concurrency !== void 0 ? concurrency : (concurrency = utils.types.isInteger(legacyConcurrency) ? legacyConcurrency * 5 : 5);
         batch !== null && batch !== void 0 ? batch : (batch = {});
-        (_a = batch.id) !== null && _a !== void 0 ? _a : (batch.id = `generated-${utils.general.guid()}`);
+        (_a = batch.id) !== null && _a !== void 0 ? _a : (batch.id = (_b = utils.general.getEnvValue('BATCH_ID')) !== null && _b !== void 0 ? _b : `generated-${utils.general.guid()}`);
         core !== null && core !== void 0 ? core : (core = (0, core_base_1.makeCore)({ agentId, cwd, logger }));
         const cores = { ufg: (0, core_2.makeCore)({ spec, core, concurrency, logger }), classic: (0, core_1.makeCore)({ spec, core, logger }) };
         const storage = [];

package/dist/ufg/check-and-close.js

@@ -206,11 +206,7 @@ function makeCheckAndClose({ spec, eyes, client, signal, target: defaultTarget,
                         settings: baseSettings,
                         logger,
                     });
-                    if (!baseEyes.running) {
-                        logger.warn(`Renderer with id ${baseEyes.test.rendererId} was aborted during one of the previous steps`);
-                        throw new abort_error_1.AbortError(`Renderer with id "${baseEyes.test.rendererId}" was aborted during one of the previous steps`);
-                    }
-                    return { ...result, eyes, renderer };
+                    return { ...result, eyes: baseEyes, renderer };
                 }
                 catch (error) {
                     await baseEyes.abort();
@@ -227,7 +223,7 @@ function makeCheckAndClose({ spec, eyes, client, signal, target: defaultTarget,
             var _a, _b;
             try {
                 const result = await promise;
-                return { ...result, userTestId: eyes.test.userTestId, asExpected: true };
+                return { ...result, userTestId: eyes.test.userTestId };
             }
             catch (error) {
                 await ((_b = (_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ logger }));

package/dist/ufg/open-eyes.js

@@ -85,13 +85,21 @@ function makeOpenEyes({ core, client, spec, logger: defaultLogger }) {
                     });
                     return results;
                 }),
-                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({
+                checkAndClose: utils.general.wrap((0, check_and_close_1.makeCheckAndClose)({
                     eyes,
                     client: client,
                     target: driver,
                     spec,
                     signal: controller.signal,
                     logger,
+                }), async (checkAndClose, options = {}) => {
+                    const results = await checkAndClose(options);
+                    results.forEach(result => {
+                        var _a;
+                        const key = JSON.stringify(result.renderer);
+                        storage.set(key, [...((_a = storage.get(key)) !== null && _a !== void 0 ? _a : []), { eyes: result.eyes, renderer: result.renderer }]);
+                    });
+                    return results;
                 }),
                 close: utils.general.wrap((0, close_1.makeClose)({ storage, target: driver, logger }), async (close, options) => {
                     running = false;

package/dist/ufg/utils/generate-safe-selectors.js

@@ -44,10 +44,8 @@ async function generateSafeSelectors({ context, elementReferences, }) {
     const selectors = mapping.elements.map((elements, index) => {
         if (elements.length === 0)
             return { safeSelector: null, originalSelector: null, elementReference: elementReferences[index] };
-        const safeSelector = generatedSelectors[offset].reduce((selector, value) => {
-            return utils.types.isObject(selector)
-                ? { ...selector, shadow: { type: 'css', selector: value } }
-                : { type: 'css', selector: value };
+        const safeSelector = generatedSelectors[offset].reduceRight((selector, value) => {
+            return selector ? { type: 'css', selector: value, shadow: selector } : { type: 'css', selector: value };
         }, undefined);
         offset += elements.length;
         return { safeSelector, originalSelector: elements[0].commonSelector, elementReference: elementReferences[index] };

package/dist/universal/core-server-process.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCoreServerProcess = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+function makeCoreServerProcess(options) {
+    return new Promise((resolve, reject) => {
+        const server = (0, child_process_1.fork)(path_1.default.resolve(__dirname, '../../dist/cli.js'), [`--config=${JSON.stringify(options)}`], {
+            stdio: [options.shutdownMode === 'stdin' ? 'inherit' : 'ignore', 'ignore', 'ignore', 'ipc'],
+            ...options.forkOptions,
+        });
+        const timeout = setTimeout(() => {
+            reject(new Error(`Server didn't respond for 10s after being started`));
+            server.kill();
+        }, 60000);
+        server.on('error', reject);
+        server.once('message', ({ name, payload }) => {
+            var _a;
+            if (name === 'port') {
+                resolve({ port: payload.port, close: () => server.kill() });
+                clearTimeout(timeout);
+                (_a = server.channel) === null || _a === void 0 ? void 0 : _a.unref();
+            }
+        });
+        server.unref();
+    });
+}
+exports.makeCoreServerProcess = makeCoreServerProcess;

package/dist/universal/core-server.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCoreServer = void 0;
+const socket_1 = require("@applitools/socket");
+const spec_driver_webdriver_1 = __importDefault(require("@applitools/spec-driver-webdriver"));
+const spec_driver_1 = require("./spec-driver");
+const ws_server_1 = require("./ws-server");
+const logger_1 = require("@applitools/logger");
+const core_1 = require("../core");
+const refer_1 = require("./refer");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+async function makeCoreServer({ debug = false, shutdownMode = 'lazy', idleTimeout = 900000, // 15min
+printStdout = false, ...handlerOptions } = {}) {
+    var _a, _b;
+    const logDirname = (_a = process.env.APPLITOOLS_LOG_DIR) !== null && _a !== void 0 ? _a : path_1.default.resolve(os_1.default.tmpdir(), `applitools-logs`);
+    const baseLogger = (0, logger_1.makeLogger)({
+        handler: { type: 'rolling file', name: 'eyes', dirname: logDirname },
+        label: 'eyes',
+        level: 'info',
+        colors: false,
+    });
+    const { server, port } = await (0, ws_server_1.makeServer)({ ...handlerOptions, debug });
+    // eslint-disable-next-line no-console
+    console.log(port); // NOTE: this is a part of the generic protocol
+    (_b = process.send) === null || _b === void 0 ? void 0 : _b.call(process, { name: 'port', payload: { port } }); // NOTE: this is a part of the js specific protocol
+    if (!server) {
+        baseLogger.console.log(`You are trying to spawn a duplicated server, use the server on port ${port} instead`);
+        return { port };
+    }
+    if (!printStdout)
+        process.stdout.write = () => true; // NOTE: prevent any write to stdout
+    baseLogger.log('Universal core is initialized on port', port);
+    let idle;
+    let serverClosed = false;
+    if (shutdownMode === 'stdin') {
+        process.stdin.resume();
+        process.stdin.on('end', () => {
+            server.close();
+        });
+    }
+    else if (shutdownMode === 'lazy') {
+        if (idleTimeout) {
+            idle = setTimeout(() => server.close(), idleTimeout);
+        }
+    }
+    server.on('close', () => {
+        clearTimeout(idle);
+        serverClosed = true;
+    });
+    server.on('connection', async (client) => {
+        const refer = (0, refer_1.makeRefer)();
+        const socket = (0, socket_1.makeSocket)(client, {
+            transport: 'ws',
+            logger: baseLogger,
+        });
+        if (shutdownMode === 'lazy' && idleTimeout) {
+            clearTimeout(idle);
+            socket.on('close', () => {
+                if (server.clients.size > 0 || serverClosed)
+                    return;
+                idle = setTimeout(() => server.close(), idleTimeout);
+            });
+        }
+        const logger = baseLogger.extend({
+            console: {
+                log: (message) => socket.emit('Logger.log', { level: 'info', message }),
+                warn: (message) => socket.emit('Logger.log', { level: 'warn', message }),
+                error: (message) => socket.emit('Logger.log', { level: 'error', message }),
+                fatal: (message) => socket.emit('Logger.log', { level: 'fatal', message }),
+            },
+        });
+        logger.console.log(`Logs saved in: ${logDirname}`);
+        const core = await socket.wait('Core.makeCore', ({ agentId, cwd, spec }) => {
+            return (0, core_1.makeCore)({
+                agentId: `eyes-universal/${require('../../package.json').version}/${agentId}`,
+                spec: spec === 'webdriver' ? spec_driver_webdriver_1.default : (0, spec_driver_1.makeSpec)({ socket, spec }),
+                cwd,
+            });
+        });
+        socket.command('Core.getAccountInfo', async (options) => {
+            return core.getAccountInfo(options);
+        });
+        socket.command('Core.getViewportSize', async (options) => {
+            var _a;
+            return (_a = core.getViewportSize) === null || _a === void 0 ? void 0 : _a.call(core, options);
+        });
+        socket.command('Core.setViewportSize', async (options) => {
+            var _a;
+            return (_a = core.setViewportSize) === null || _a === void 0 ? void 0 : _a.call(core, options);
+        });
+        socket.command('Core.closeBatch', async (options) => {
+            return core.closeBatch(options);
+        });
+        socket.command('Core.deleteTest', async (options) => {
+            return core.deleteTest(options);
+        });
+        socket.command('Core.locate', async (options) => {
+            return core.locate(options);
+        });
+        socket.command('Core.locateText', async (options) => {
+            return core.locateText(options);
+        });
+        socket.command('Core.extractText', async (options) => {
+            return core.extractText(options);
+        });
+        socket.command('Core.makeECClient', async (options) => {
+            const client = await core.makeECClient(options);
+            return { url: client.url };
+        });
+        socket.command('Core.makeManager', async (options) => {
+            return refer.ref(await core.makeManager(options));
+        });
+        socket.command('EyesManager.openEyes', async ({ manager, ...options }) => {
+            var _a;
+            const eyes = await ((_a = refer.deref(manager)) === null || _a === void 0 ? void 0 : _a.openEyes(options));
+            const eyesRef = refer.ref(eyes, manager);
+            return eyesRef;
+        });
+        socket.command('EyesManager.getResults', async ({ manager, ...options }) => {
+            var _a;
+            const results = (_a = refer.deref(manager)) === null || _a === void 0 ? void 0 : _a.getResults(options);
+            refer.destroy(manager);
+            return results;
+        });
+        socket.command('Eyes.check', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.check(options);
+        });
+        socket.command('Eyes.close', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.close(options);
+        });
+        socket.command('Eyes.abort', async ({ eyes, ...options }) => {
+            var _a;
+            return (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.abort(options);
+        });
+        socket.command('Eyes.getResults', async ({ eyes, ...options }) => {
+            var _a;
+            const results = (_a = refer.deref(eyes)) === null || _a === void 0 ? void 0 : _a.getResults(options);
+            refer.destroy(eyes);
+            return results;
+        });
+    });
+    return { port, close: () => server.close() };
+}
+exports.makeCoreServer = makeCoreServer;

package/dist/universal/core.js

@@ -0,0 +1,145 @@
+"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.makeClientSocket = exports.makeEyes = exports.makeManager = exports.makeCore = void 0;
+const socket_1 = require("@applitools/socket");
+const ws_1 = require("ws");
+const core_server_1 = require("./core-server");
+const utils = __importStar(require("@applitools/utils"));
+//TODO add refer and sanitizing support, solve types issues
+function makeCore(options) {
+    const socketPromise = makeClientSocket(options);
+    return {
+        async getAccountInfo(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.getAccountInfo', options);
+        },
+        async getViewportSize(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.getViewportSize', options);
+        },
+        async setViewportSize(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.setViewportSize', options);
+        },
+        async locate(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.locate', options);
+        },
+        async locateText(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.locateText', options);
+        },
+        async extractText(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.extractText', options);
+        },
+        async openEyes(options) {
+            const socket = await socketPromise;
+            const eyes = await socket.request('Core.openEyes', options);
+            return makeEyes({ socket, eyes });
+        },
+        async makeManager(options) {
+            const socket = await socketPromise;
+            const manager = await socket.request('Core.makeManager', options);
+            return makeManager({ socket, manager });
+        },
+        async makeECClient(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.makeECClient', options);
+        },
+        async closeBatch(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.closeBatch', options);
+        },
+        async deleteTest(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.deleteTest', options);
+        },
+        async logEvent(options) {
+            const socket = await socketPromise;
+            return socket.request('Core.logEvent', options);
+        },
+    };
+}
+exports.makeCore = makeCore;
+function makeManager({ socket, manager, }) {
+    return {
+        async openEyes(options) {
+            const eyes = await socket.request('EyesManager.openEyes', { ...options, manager });
+            return makeEyes({ socket, eyes });
+        },
+        async getResults(options) {
+            return socket.request('EyesManager.getResults', { ...options, manager });
+        },
+    };
+}
+exports.makeManager = makeManager;
+function makeEyes({ socket, eyes, }) {
+    return {
+        test: null,
+        running: null,
+        getBaseEyes() {
+            return null;
+        },
+        getTypedEyes() {
+            return null;
+        },
+        async check(options) {
+            return socket.request('Eyes.check', { ...options, eyes });
+        },
+        async checkAndClose(options) {
+            return socket.request('Eyes.checkAndClose', { ...options, eyes });
+        },
+        async close(options) {
+            return socket.request('Eyes.close', { ...options, eyes });
+        },
+        async abort(options) {
+            return socket.request('Eyes.abort', { ...options, eyes });
+        },
+        async getResults(options) {
+            return socket.request('Eyes.getResults', { ...options, eyes });
+        },
+    };
+}
+exports.makeEyes = makeEyes;
+async function makeClientSocket({ agentId, spec, }) {
+    const { port } = await (0, core_server_1.makeCoreServer)();
+    const socket = (0, socket_1.makeSocket)(new ws_1.WebSocket(`ws://localhost:${port}/eyes`), {
+        transport: 'ws',
+    });
+    socket.emit('Core.makeCore', {
+        agentId,
+        cwd: process.cwd(),
+        spec: utils.types.isString(spec) ? spec : Object.keys(spec),
+    });
+    if (!utils.types.isString(spec)) {
+        Object.entries(spec).forEach(([name, command]) => {
+            socket.command(`Driver.${name}`, args => command(...args));
+        });
+    }
+    return socket;
+}
+exports.makeClientSocket = makeClientSocket;

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;