@applitools/core 4.18.2 → 4.20.0

package/dist/run-offline-snapshots.js

@@ -0,0 +1,346 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOfflineSnapshots = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const tar = __importStar(require("tar"));
+const core_1 = require("./core");
+const get_ufg_client_1 = require("./ufg/get-ufg-client");
+const logger_1 = require("@applitools/logger");
+const to_base_check_settings_1 = require("./automation/utils/to-base-check-settings");
+const chalk_1 = __importDefault(require("chalk"));
+const utils = __importStar(require("@applitools/utils"));
+async function runOfflineSnapshots(options) {
+    if (!options.offlineLocationPath)
+        throw new Error('offlineLocationPath is required');
+    const startTime = Date.now();
+    const logger = (0, logger_1.makeLogger)({ format: { label: 'offline-exec' } });
+    const core = (0, core_1.makeCore)();
+    const account = await core.getAccountInfo({ settings: options });
+    const ufgClient = await (0, get_ufg_client_1.makeGetUFGClient)({ logger })({
+        settings: { ...account.eyesServer, ...account.ufgServer },
+    });
+    const executionFiles = (await fs_1.default.promises.readdir(options.offlineLocationPath)).filter(filename => filename.endsWith('.tar.gz'));
+    if (executionFiles.length === 1) {
+        logger.console.log(`Running execution ${executionFiles[0]} from folder ${path_1.default.resolve(options.offlineLocationPath)}`);
+    }
+    else if (executionFiles.length === 0) {
+        logger.console.log('No execution artifacts were found at', options.offlineLocationPath);
+    }
+    else {
+        logger.console.log(`Running the following executions from folder ${options.offlineLocationPath} :\n  ${executionFiles.join('\n  ')}`);
+    }
+    if (executionFiles.length === 0) {
+        throw new Error(`Unable to find offline executions in ${options.offlineLocationPath}`);
+    }
+    const allTestResults = (await Promise.all(executionFiles.map(runExecution))).flat();
+    const { exitCode, outputStr } = processResults({ testResults: allTestResults, totalTime: Date.now() - startTime });
+    if (exitCode) {
+        throw new Error(outputStr);
+    }
+    else {
+        logger.console.log(outputStr);
+    }
+    async function runExecution(executionFile) {
+        const executionName = executionFile.replace('.tar.gz', '');
+        const executionLogger = logger.extend({ tags: [executionName] });
+        executionLogger.log('unpacking execution', executionFile);
+        await tar.extract({
+            file: path_1.default.resolve(options.offlineLocationPath, executionFile),
+            gzip: true,
+            C: options.offlineLocationPath,
+        });
+        const executionPath = path_1.default.resolve(options.offlineLocationPath, executionName);
+        executionLogger.log('handling execution', executionPath);
+        const testFolders = (await fs_1.default.promises.readdir(executionPath)).filter(foldername => foldername.startsWith('test-'));
+        executionLogger.log('running tests', testFolders);
+        const results = await Promise.all(testFolders.map(async (testFolder) => {
+            const testLogger = logger.extend({ tags: [testFolder] });
+            const testPath = path_1.default.resolve(executionPath, testFolder);
+            const openSettings = (await fs_1.default.promises
+                .readFile(path_1.default.resolve(testPath, 'settings.json'), 'utf-8')
+                .then(JSON.parse));
+            logger.console.log(`Running test: ${openSettings.testName} (${formatEnvironment(openSettings.environment)})`);
+            return runTest(executionPath, testPath, openSettings, testLogger);
+        }));
+        const batchIds = [...new Set(results.map(t => t.batchId))];
+        const allTestResults = results.map(t => t.results);
+        executionLogger.log('done running all tests', allTestResults);
+        // @ts-expect-error // we use node v12 types, therefore it's not aware of the existence of `fs.promises.rm`
+        await fs_1.default.promises.rm(executionPath, { recursive: true });
+        await core.closeBatch({ settings: batchIds.map(batchId => ({ batchId, ...account.eyesServer })) });
+        executionLogger.log('one execution', executionFile);
+        return allTestResults;
+    }
+    async function runTest(executionPath, testPath, openSettings, logger) {
+        const environment = await ufgClient.getActualEnvironment({
+            settings: { environment: openSettings.environment.requested },
+        });
+        const eyes = await core.base.openEyes({
+            settings: {
+                ...openSettings,
+                environment: {
+                    ...openSettings.environment,
+                    ...environment,
+                },
+                ...account.eyesServer,
+            },
+            logger,
+        });
+        const checkFolders = (await fs_1.default.promises.readdir(testPath)).filter(folderpath => folderpath.startsWith('check-'));
+        logger.log('running checks for test', testPath, ':', checkFolders);
+        const targets = (await Promise.all(checkFolders.map(checkFolder => fs_1.default.promises.readFile(path_1.default.resolve(testPath, checkFolder, 'snapshot.json'), 'utf-8').then(JSON.parse))));
+        await uploadResources(executionPath, targets, logger);
+        // logger.log('resource hashes for test', testFolder, ':', resourceHashes)
+        logger.log('uploaded resources for test', testPath);
+        await Promise.all(targets.map((target, index) => runCheck(eyes, target, index, logger)));
+        await eyes.close({
+            settings: await fs_1.default.promises.readFile(path_1.default.resolve(testPath, 'close.json'), 'utf-8').then(JSON.parse),
+        });
+        logger.log('done running test', logger);
+        return { batchId: openSettings.batch.id, results: (await eyes.getResults({ logger }))[0] };
+    }
+    async function uploadResources(executionPath, targets, logger) {
+        const uploadLogger = logger.extend({ tags: ['upload-resources'] });
+        const promises = targets.map(async ({ target }) => {
+            let resourcePromises = Object.values(target.resources)
+                .filter(isHashedResource)
+                .map(async (resource) => {
+                const contentfuleResource = {
+                    id: '',
+                    url: '',
+                    value: await fs_1.default.promises.readFile(path_1.default.resolve(executionPath, 'resources', resource.hash)),
+                    contentType: resource.contentType,
+                    hash: resource,
+                };
+                return ufgClient.uploadResource({ resource: contentfuleResource, logger: uploadLogger });
+            });
+            resourcePromises = resourcePromises.concat(ufgClient.uploadResource({
+                resource: {
+                    id: '',
+                    url: '',
+                    value: await fs_1.default.promises.readFile(path_1.default.resolve(executionPath, 'resources', target.snapshot.hash)),
+                    contentType: target.snapshot.contentType,
+                    hash: target.snapshot,
+                },
+                logger: uploadLogger,
+            }));
+            return Promise.all(resourcePromises);
+        });
+        await Promise.all(promises);
+        function isHashedResource(resource) {
+            return 'hash' in resource;
+        }
+    }
+    async function runCheck(eyes, target, index, logger) {
+        var _a;
+        const checkLogger = logger.extend({ tags: [`check-${index}`] });
+        const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+            settings: target.settings,
+        });
+        const { renderId, selectorRegions, ...baseTarget } = await ufgClient.render({
+            target: target.target,
+            settings: {
+                ...target.settings,
+                region: (_a = selectors.target) !== null && _a !== void 0 ? _a : target.settings.region,
+                scrollRootElement: selectors.scrolling,
+                selectorsToCalculate: selectors.calculate,
+                includeFullPageSize: Boolean(target.settings.pageId),
+                environment: target.settings.environment,
+                uploadUrl: account.uploadUrl,
+                stitchingServiceUrl: account.stitchingServiceUrl,
+            },
+            logger: checkLogger,
+        });
+        const baseSettings = getBaseCheckSettings({
+            calculatedRegions: selectors.calculate.map((_, index) => {
+                var _a;
+                return ({
+                    regions: (_a = selectorRegions === null || selectorRegions === void 0 ? void 0 : selectorRegions[index]) !== null && _a !== void 0 ? _a : [],
+                });
+            }),
+        });
+        baseSettings.renderId = renderId;
+        baseSettings.stepIndex = index;
+        baseTarget.source = target.target.source; // TODO verify
+        // baseTarget.name = snapshot.title // TODO figure out
+        await eyes.check({
+            target: { ...baseTarget, isTransformed: true },
+            settings: baseSettings,
+            logger: checkLogger,
+        });
+    }
+}
+exports.runOfflineSnapshots = runOfflineSnapshots;
+function uniq(arr) {
+    return [...new Set(arr)];
+}
+function processResults({ testResults, totalTime, saveNewTests = true, failOnDiff = true, }) {
+    let outputStr = '\n';
+    const pluralize = utils.general.pluralize;
+    const testResultsWithErrors = testResults.filter(r => r && r.reason);
+    const unresolved = testResults.filter(r => r.isDifferent && !r.isAborted);
+    const passedOrNew = testResults.filter(r => r.status === 'Passed' || (r.isNew && !r.isAborted));
+    const aborted = testResults.filter(r => r.isAborted);
+    const newTests = testResults.filter(r => r.isNew && !r.isAborted);
+    const failedTests = testResults.filter(r => !r.reason && !r.isNew && !r.isAborted && !r.isDifferent && r.status === 'Failed');
+    const newTestsSize = newTests.length;
+    const warnForUnsavedNewTests = !!(!saveNewTests && newTestsSize);
+    const errMessagesToExclude = ['detected differences', 'Please approve the new baseline', 'is failed! See details at'];
+    const errors = testResultsWithErrors
+        .filter(r => !errMessagesToExclude.some(msg => { var _a, _b; return (_b = (_a = r.reason) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.includes(msg); }))
+        .map(r => ({
+        error: r.reason,
+        title: r.name,
+    }));
+    const hasResults = unresolved.length || passedOrNew.length || aborted.length;
+    const seeDetailsStr = hasResults && `See details at ${(passedOrNew[0] || unresolved[0] || aborted[0]).appUrls.batch}`;
+    if (hasResults) {
+        outputStr += `${seeDetailsStr}\n\n`;
+    }
+    outputStr += '[EYES: TEST RESULTS]:\n\n';
+    if (passedOrNew.length > 0) {
+        outputStr += testResultsOutput(passedOrNew, warnForUnsavedNewTests);
+    }
+    if (failedTests.length > 0) {
+        outputStr += testResultsOutput(failedTests, warnForUnsavedNewTests);
+    }
+    if (unresolved.length > 0) {
+        outputStr += testResultsOutput(unresolved, warnForUnsavedNewTests);
+    }
+    if (aborted.length > 0) {
+        outputStr += testResultsOutput(aborted, warnForUnsavedNewTests);
+    }
+    if (errors.length) {
+        const sortedErrors = errors.sort((a, b) => a.title.localeCompare(b.title));
+        outputStr += uniq(sortedErrors.map(({ title, error }) => `${title} - ${chalk_1.default.red('Failed')}. ${error.message || error.toString()}`)).join('\n');
+        outputStr += '\n';
+    }
+    if (!errors.length && !hasResults) {
+        outputStr += 'Test is finished but no results returned.\n';
+    }
+    const unresolvedOrFailed = unresolved.concat(failedTests);
+    if (errors.length && !unresolvedOrFailed.length) {
+        outputStr += chalk_1.default.red(`\nA total of ${errors.length} test${pluralize(errors.length)} failed for unexpected error${pluralize(errors.length)}.`);
+    }
+    else if (unresolvedOrFailed.length && !errors.length) {
+        outputStr += chalk_1.default.keyword(failedTests.length ? 'red' : 'orange')(`\nA total of ${unresolvedOrFailed.length} difference${pluralize(unresolvedOrFailed.length, [
+            's were',
+            ' was',
+        ])} found.`);
+    }
+    else if (unresolvedOrFailed.length || errors.length) {
+        outputStr += chalk_1.default.red(`\nA total of ${unresolvedOrFailed.length} difference${pluralize(unresolvedOrFailed.length, [
+            's were',
+            ' was',
+        ])} found and ${errors.length} test${pluralize(errors.length)} failed for ${pluralize(errors.length, [
+            '',
+            'an ',
+        ])}unexpected error${pluralize(errors.length)}.`);
+    }
+    else if (warnForUnsavedNewTests) {
+        const countText = newTestsSize > 1 ? `are ${newTestsSize} new tests` : `is a new test: '${newTests[0].name}'`;
+        outputStr += chalk_1.default.red(`\n'saveNewTests' was set to false and there ${countText}. Please approve ${pluralize(newTestsSize, [
+            'their',
+            'its',
+        ])} baseline${pluralize(newTestsSize)} in Eyes dashboard.\n`);
+    }
+    else if (passedOrNew.length) {
+        outputStr += chalk_1.default.green(`\nNo differences were found!`);
+    }
+    if (hasResults) {
+        outputStr += `\n${seeDetailsStr}\nTotal time: ${Math.round(totalTime / 1000)} seconds\n`;
+    }
+    // if (Number(testConcurrency) === 5) {
+    //   outputStr += `\n${concurrencyMsg}\n`
+    // }
+    let exitCode;
+    if (errors.length) {
+        exitCode = 1;
+    }
+    else if (failOnDiff) {
+        exitCode = !warnForUnsavedNewTests && passedOrNew.length && !unresolvedOrFailed.length ? 0 : 1;
+    }
+    else {
+        exitCode = 0;
+    }
+    return {
+        outputStr,
+        exitCode,
+    };
+}
+function testResultsOutput(results, warnForUnsavedNewTests) {
+    let outputStr = '';
+    const sortedTestResults = results.sort((a, b) => a.name.localeCompare(b.name));
+    sortedTestResults.forEach(result => {
+        const testTitle = `${result.name} [${result.hostApp}] [${result.hostDisplaySize.width}x${result.hostDisplaySize.height}] - `;
+        if (result.isAborted) {
+            outputStr += `${testTitle}${chalk_1.default.keyword('red')(`Aborted`)}\n`;
+        }
+        else if (result.isNew) {
+            const newResColor = warnForUnsavedNewTests ? 'orange' : 'blue';
+            outputStr += `${testTitle}${chalk_1.default.keyword(newResColor)('New')}\n`;
+        }
+        else if (result.status === 'Passed') {
+            outputStr += `${testTitle}${chalk_1.default.green('Passed')}\n`;
+        }
+        else if (result.status === 'Failed') {
+            outputStr += `${testTitle}${chalk_1.default.keyword('red')('Failed')}\n`;
+        }
+        else {
+            outputStr += `${testTitle}${chalk_1.default.keyword('orange')(`Unresolved`)}\n`;
+        }
+    });
+    outputStr += '\n';
+    return outputStr;
+}
+function formatEnvironment(environment) {
+    const env = environment.requested;
+    if (isChromeEmulation(env)) {
+        return `${env.chromeEmulationInfo.deviceName}${env.chromeEmulationInfo.screenOrientation ? ` [${env.chromeEmulationInfo.screenOrientation}]` : ''}`;
+    }
+    else if (isIOSDevice(env)) {
+        return `${env.iosDeviceInfo.deviceName}${env.iosDeviceInfo.screenOrientation ? ` [${env.iosDeviceInfo.screenOrientation}]` : ''}`;
+    }
+    else if (isAndroidDevice(env)) {
+        return `${env.androidDeviceInfo.deviceName}${env.androidDeviceInfo.screenOrientation ? ` [${env.androidDeviceInfo.screenOrientation}]` : ''}`;
+    }
+    else {
+        return `${env.name} [${env.width}x${env.height}]`;
+    }
+    function isChromeEmulation(env) {
+        return env.chromeEmulationInfo;
+    }
+    function isIOSDevice(env) {
+        return env.iosDeviceInfo;
+    }
+    function isAndroidDevice(env) {
+        return env.androidDeviceInfo;
+    }
+}

package/dist/ufg/check.js

@@ -28,29 +28,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheck = void 0;
 const driver_1 = require("@applitools/driver");
-const take_dom_snapshots_1 = require("./utils/take-dom-snapshots");
-const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
-const to_generated_selectors_1 = require("./utils/to-generated-selectors");
 const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
 const to_environment_key_1 = require("../automation/utils/to-environment-key");
 const abort_error_1 = require("../errors/abort-error");
 const utils = __importStar(require("@applitools/utils"));
 const lang = __importStar(require("../lang"));
 const chalk_1 = __importDefault(require("chalk"));
+const take_snapshots_1 = require("./take-snapshots");
+const create_render_target_from_snapshot_1 = require("./create-render-target-from-snapshot");
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
 function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     return async function check({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
-        var _a, _b;
+        var _a;
         logger = logger.extend(mainLogger);
         logger.log('Command "check" is called with settings', settings);
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             logger.warn('Command "check" was called after test was already aborted');
             throw new abort_error_1.AbortError('Command "check" was called after test was already aborted');
         }
-        const { elementReferences, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
-        const { elementReferencesToMark, getGeneratedSelectors } = (0, to_generated_selectors_1.toGeneratedSelectors)({
-            elementReferences,
-            transformElementReference: elementReference => { var _a; return ((0, driver_1.isSelector)(elementReference) && ((_a = spec === null || spec === void 0 ? void 0 : spec.toSimpleCommonSelector) === null || _a === void 0 ? void 0 : _a.call(spec, elementReference))) || undefined; },
-        });
         const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
         const ufgClient = await eyes.core.getUFGClient({
             settings: {
@@ -61,66 +56,27 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
             logger,
         });
         let snapshots;
-        let snapshotUrl;
-        let snapshotTitle;
-        let userAgent;
-        const driver = spec && (0, driver_1.isDriver)(target, spec)
-            ? await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger })
-            : undefined;
-        if (driver) {
-            const environment = await driver.getEnvironment();
-            const currentContext = driver.currentContext;
-            await currentContext.setScrollingElement((_b = settings.scrollRootElement) !== null && _b !== void 0 ? _b : null);
-            if (environment.isWeb) {
-                userAgent = await driver.getUserAgentLegacy();
-                snapshots = await (0, take_dom_snapshots_1.takeDomSnapshots)({
-                    driver,
-                    settings: {
-                        ...eyes.test.eyesServer,
-                        waitBeforeCapture: settings.waitBeforeCapture,
-                        disableBrowserFetching: settings.disableBrowserFetching,
-                        layoutBreakpoints: settings.layoutBreakpoints,
-                        environments: uniqueEnvironments,
-                        skipResources: ufgClient.getCachedResourceUrls(),
-                        lazyLoad: settings.lazyLoad,
-                        elementReferences: elementReferencesToMark,
-                    },
-                    provides: {
-                        getChromeEmulationDevices: ufgClient.getChromeEmulationDevices,
-                        getIOSDevices: ufgClient.getIOSDevices,
-                    },
-                    logger,
-                });
-            }
-            else {
-                const nmlClient = await eyes.core.getNMLClient({
-                    driver,
-                    settings: { ...eyes.test.eyesServer, supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl },
-                    logger,
-                });
-                snapshots = (await nmlClient.takeSnapshots({
-                    settings: {
-                        ...eyes.test.eyesServer,
-                        waitBeforeCapture: settings.waitBeforeCapture,
-                        environments: uniqueEnvironments,
-                    },
-                    logger,
-                }));
-            }
-            await currentContext.focus();
-            snapshotUrl = await driver.getUrl();
-            snapshotTitle = await driver.getTitle();
+        let driver;
+        if (spec && (0, driver_1.isDriver)(target, spec)) {
+            const takeSnapshots = (0, take_snapshots_1.makeTakeSnapshots)({ core: eyes.core, spec, signal, logger });
+            driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger });
+            snapshots = await takeSnapshots({
+                driver,
+                account: eyes.test.account,
+                settings: { ...settings, environments: uniqueEnvironments },
+                logger,
+            });
         }
         else {
+            // TODO (amit)
             snapshots = !utils.types.isArray(target) ? Array(uniqueEnvironments.length).fill(target) : target;
-            snapshotUrl = utils.types.has(snapshots[0], 'url') ? snapshots[0].url : undefined;
         }
-        const generatedSelectors = snapshots.map(snapshot => getGeneratedSelectors(utils.types.has(snapshot, 'generatedSelectors') ? snapshot.generatedSelectors : undefined));
-        const promises = uniqueEnvironments.map(async (environment, index) => {
+        const promises = snapshots.map(async (snapshot, i) => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-            const ufgEnvironment = environment;
-            if (utils.types.has(ufgEnvironment, 'name') && ufgEnvironment.name === 'edge') {
+            const { target } = snapshot;
+            const environment = uniqueEnvironments[i];
+            if (utils.types.has(environment, 'name') && environment.name === 'edge') {
                 environmentLogger.console.log(chalk_1.default.yellow(lang.edgeUfgEnvironmentDeprecatedWarning));
             }
             try {
@@ -128,26 +84,10 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                     environmentLogger.warn('Command "check" was aborted before rendering');
                     throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
                 }
-                const { cookies, ...snapshot } = snapshots[index];
-                const selectors = generatedSelectors[index];
-                if (utils.types.has(ufgEnvironment, 'iosDeviceInfo') || utils.types.has(ufgEnvironment, 'androidDeviceInfo')) {
-                    ufgEnvironment.type = utils.types.has(snapshot, 'cdt') ? 'web' : 'native';
+                if (utils.types.has(environment, 'iosDeviceInfo') || utils.types.has(environment, 'androidDeviceInfo')) {
+                    environment.type = utils.types.has(target, 'cdt') ? 'web' : 'native';
                 }
-                const renderTargetPromise = ufgClient.createRenderTarget({
-                    snapshot,
-                    settings: {
-                        environment: ufgEnvironment,
-                        cookies,
-                        headers: {
-                            Referer: snapshotUrl,
-                            'User-Agent': userAgent,
-                            ...settings.headers,
-                        },
-                        proxy: eyes.test.eyesServer.proxy,
-                        autProxy: settings.autProxy,
-                    },
-                    logger: environmentLogger,
-                });
+                const renderTargetPromise = (0, create_render_target_from_snapshot_1.createRenderTargetFromSnapshot)({ ufgClient, snapshot, logger: environmentLogger });
                 const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger: environmentLogger });
                 try {
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
@@ -167,31 +107,35 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                         environmentLogger.warn(`Render on environment with id "${(_c = baseEyes.test.environment) === null || _c === void 0 ? void 0 : _c.environmentId}" was aborted during one of the previous steps`);
                         throw new abort_error_1.AbortError(`Render on environment with id "${(_d = baseEyes.test.environment) === null || _d === void 0 ? void 0 : _d.environmentId}" was aborted during one of the previous steps`);
                     }
+                    const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+                        settings: snapshot.settings,
+                    });
                     const { renderId, selectorRegions, ...baseTarget } = await ufgClient.render({
                         target: renderTarget,
                         settings: {
-                            ...settings,
-                            region: (_e = selectors.target) !== null && _e !== void 0 ? _e : settings.region,
+                            ...snapshot.settings,
+                            region: (_e = selectors.target) !== null && _e !== void 0 ? _e : snapshot.settings.region,
                             scrollRootElement: selectors.scrolling,
-                            selectorsToCalculate: selectors.calculate.flatMap(({ safeSelector }) => safeSelector !== null && safeSelector !== void 0 ? safeSelector : []),
-                            includeFullPageSize: Boolean(settings.pageId),
-                            environment: { ...ufgEnvironment, environmentId: baseEyes.test.environment.environmentId },
+                            selectorsToCalculate: selectors.calculate,
+                            includeFullPageSize: Boolean(snapshot.settings.pageId),
+                            environment: { ...environment, environmentId: baseEyes.test.environment.environmentId },
                             uploadUrl: baseEyes.test.uploadUrl,
                             stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
                         },
                         signal,
                         logger: environmentLogger,
                     });
-                    let offset = 0;
                     const baseSettings = getBaseCheckSettings({
-                        calculatedRegions: selectors.calculate.map(({ originalSelector, safeSelector }) => ({
-                            selector: originalSelector !== null && originalSelector !== void 0 ? originalSelector : undefined,
-                            regions: safeSelector ? selectorRegions[offset++] : [],
-                        })),
+                        calculatedRegions: selectors.calculate.map((_, index) => {
+                            var _a;
+                            return ({
+                                regions: (_a = selectorRegions === null || selectorRegions === void 0 ? void 0 : selectorRegions[index]) !== null && _a !== void 0 ? _a : [],
+                            });
+                        }),
                     });
                     baseSettings.renderId = renderId;
-                    baseTarget.source = snapshotUrl;
-                    baseTarget.name = snapshotTitle;
+                    baseTarget.source = snapshot.url;
+                    baseTarget.name = snapshot.title;
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                         environmentLogger.warn('Command "check" was aborted after rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted after rendering');
@@ -238,8 +182,8 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                 }
             }
             catch (error) {
-                environmentLogger.error(`Environment with id ${ufgEnvironment.environmentId} failed before rendering started due to an error`, error);
-                error.info = { ...error.info, userTestId: eyes.test.userTestId, environment: ufgEnvironment };
+                environmentLogger.error(`Environment with id ${environment.environmentId} failed before rendering started due to an error`, error);
+                error.info = { ...error.info, userTestId: eyes.test.userTestId, environment };
                 throw error;
             }
         });

package/dist/ufg/core.js

@@ -36,10 +36,11 @@ const take_snapshots_1 = require("./take-snapshots");
 const get_ufg_client_1 = require("./get-ufg-client");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, fetchConcurrency, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
+function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, offlineLocationPath, fetchConcurrency, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
     const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-ufg' } });
     logger.log(`Core ufg is initialized ${defaultBase ? 'with' : 'without'} custom base core`);
-    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger });
+    const base = defaultBase !== null && defaultBase !== void 0 ? defaultBase : (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger, offlineLocationPath });
+    const ufgClient = clients === null || clients === void 0 ? void 0 : clients.ufg;
     return utils.general.extend(base, core => {
         return {
             type: 'ufg',
@@ -50,7 +51,7 @@ function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, f
             locate: (0, locate_1.makeLocate)({ spec, core, logger }),
             locateText: (0, locate_text_1.makeLocateText)({ spec, core, logger }),
             extractText: (0, extract_text_1.makeExtractText)({ spec, core, logger }),
-            getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({ client: clients === null || clients === void 0 ? void 0 : clients.ufg, fetchConcurrency, asyncCache, logger }),
+            getUFGClient: (0, get_ufg_client_1.makeGetUFGClient)({ client: ufgClient, fetchConcurrency, asyncCache, offlineLocationPath, logger }),
             ...(0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, logger }),
             openEyes: (0, open_eyes_1.makeOpenEyes)({ spec, core, logger }),
         };

package/dist/ufg/create-render-target-from-snapshot.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRenderTargetFromSnapshot = void 0;
+async function createRenderTargetFromSnapshot({ ufgClient, snapshot, logger, }) {
+    return await ufgClient.createRenderTarget({
+        snapshot: snapshot.target,
+        settings: {
+            environment: snapshot.environment,
+            cookies: snapshot.target.cookies,
+            headers: {
+                Referer: snapshot.url,
+                'User-Agent': snapshot.userAgent,
+                ...snapshot.settings.headers,
+            },
+            proxy: snapshot.account.eyesServer.proxy,
+            autProxy: snapshot.settings.autProxy,
+        },
+        logger,
+    });
+}
+exports.createRenderTargetFromSnapshot = createRenderTargetFromSnapshot;

package/dist/ufg/get-ufg-client.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetUFGClient = void 0;
 const ufg_client_1 = require("@applitools/ufg-client");
 const utils = __importStar(require("@applitools/utils"));
-function makeGetUFGClient({ client, fetchConcurrency, logger: mainLogger, asyncCache }) {
+function makeGetUFGClient({ client, fetchConcurrency, offlineLocationPath, logger: mainLogger, asyncCache, }) {
     // we are caching by the server config, therefor if the user creates another Runner / manager with the same server config but different
     // fetchConcurrency, it will not take any affect.
     const getUFGClientWithCache = utils.general.cachify(getUFGClient, ([options]) => client ? 'default' : [{ ...options.settings, fetchConcurrency: undefined }]);
@@ -39,7 +39,7 @@ function makeGetUFGClient({ client, fetchConcurrency, logger: mainLogger, asyncC
             ? utils.general.getEnvValue('TUNNEL_IDS')
             : undefined;
         return (0, ufg_client_1.makeUFGClient)({
-            settings: { ...settings, fetchConcurrency, tunnelIds, asyncCache },
+            settings: { ...settings, fetchConcurrency, offlineLocationPath, tunnelIds, asyncCache },
             logger,
         });
     }

package/dist/ufg/take-snapshots.js

@@ -28,25 +28,23 @@ const driver_1 = require("@applitools/driver");
 const take_dom_snapshots_1 = require("./utils/take-dom-snapshots");
 const to_safe_check_settings_1 = require("./utils/to-safe-check-settings");
 const to_generated_selectors_1 = require("./utils/to-generated-selectors");
-const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
 const abort_error_1 = require("../errors/abort-error");
 const utils = __importStar(require("@applitools/utils"));
 function makeTakeSnapshots({ core, spec, signal, logger: mainLogger }) {
-    return async function takeSnapshots({ target, settings = {}, environments: defaultEnvironments = [], account, logger = mainLogger, }) {
-        var _a, _b;
+    return async function takeSnapshots({ driver, settings = {}, account, logger = mainLogger, }) {
+        var _a;
         logger = logger.extend(mainLogger);
         logger.log('Command "takeSnapshots" is called with settings', settings);
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             logger.warn('Command "takeSnapshots" was called after test was already aborted');
             throw new abort_error_1.AbortError('Command "takeSnapshots" was called after test was already aborted');
         }
-        const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
-        const driver = spec && target ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
+        const uniqueEnvironments = settings.environments;
         if (!driver)
             throw new Error('Cannot create check snapshot without a driver');
         const environment = await driver.getEnvironment();
         const currentContext = driver.currentContext;
-        await currentContext.setScrollingElement((_b = settings.scrollRootElement) !== null && _b !== void 0 ? _b : null);
+        await currentContext.setScrollingElement((_a = settings.scrollRootElement) !== null && _a !== void 0 ? _a : null);
         const { elementReferences, getSafeCheckSettings } = (0, to_safe_check_settings_1.toSafeCheckSettings)({ settings });
         const { elementReferencesToMark, getGeneratedSelectors } = (0, to_generated_selectors_1.toGeneratedSelectors)({
             elementReferences,