@applitools/core 2.5.2 → 2.5.3-legacy

package/dist/ufg/check.js

@@ -28,241 +28,174 @@ 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 take_vhses_1 = require("./utils/take-vhses");
-const wait_for_lazy_load_1 = require("../automation/utils/wait-for-lazy-load");
-const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
-const generate_safe_selectors_1 = require("./utils/generate-safe-selectors");
-const uniquify_renderers_1 = require("./utils/uniquify-renderers");
+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"));
-function makeCheck({ eyes, target: defaultTarget, spec, signal, logger: defaultLogger, }) {
-    return async function check({ target = defaultTarget, settings = {}, logger = defaultLogger, }) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+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;
+        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 { elementReferencesToCalculate, elementReferenceToTarget, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
-            settings,
-        });
-        const uniqueRenderers = (0, uniquify_renderers_1.uniquifyRenderers)((_a = settings.renderers) !== null && _a !== void 0 ? _a : []);
+        const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
         const ufgClient = await eyes.core.getUFGClient({
-            config: { ...eyes.test.ufgServer },
-            concurrency: uniqueRenderers.length || 5,
+            settings: {
+                ...eyes.test.ufgServer,
+                eyesServerUrl: eyes.test.eyesServer.eyesServerUrl,
+                apiKey: eyes.test.eyesServer.apiKey,
+            },
             logger,
         });
         let snapshots;
-        let snapshotUrl;
-        let snapshotTitle;
-        let userAgent;
-        let regionToTarget;
-        let scrollRootSelector;
-        let selectorsToCalculate;
-        const driver = spec && (0, driver_1.isDriver)(target, spec) ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
-        if (driver) {
-            const environment = await driver.getEnvironment();
-            await driver.currentContext.setScrollingElement((_b = settings.scrollRootElement) !== null && _b !== void 0 ? _b : null);
-            if (uniqueRenderers.length === 0) {
-                if (environment.isWeb) {
-                    const viewportSize = await driver.getViewportSize();
-                    uniqueRenderers.push({ name: 'chrome', ...viewportSize });
-                }
-                else {
-                    // TODO add default nmg renderers
-                }
-            }
-            let cleanupGeneratedSelectors;
-            if (environment.isWeb) {
-                userAgent = (_c = (await driver.getUserAgentLegacy())) !== null && _c !== void 0 ? _c : undefined;
-                const generated = await (0, generate_safe_selectors_1.generateSafeSelectors)({
-                    context: driver.currentContext,
-                    elementReferences: [
-                        ...(elementReferenceToTarget ? [elementReferenceToTarget] : []),
-                        ...(settings.scrollRootElement ? [settings.scrollRootElement] : []),
-                        ...elementReferencesToCalculate,
-                    ],
-                });
-                cleanupGeneratedSelectors = generated.cleanupGeneratedSelectors;
-                selectorsToCalculate = generated.selectors;
-                if (elementReferenceToTarget) {
-                    if (!((_d = selectorsToCalculate[0]) === null || _d === void 0 ? void 0 : _d.safeSelector))
-                        throw new Error('Target element not found');
-                    regionToTarget = selectorsToCalculate[0].safeSelector;
-                    selectorsToCalculate = selectorsToCalculate.slice(1);
-                }
-                if (settings.scrollRootElement) {
-                    scrollRootSelector = (_e = selectorsToCalculate[0].safeSelector) !== null && _e !== void 0 ? _e : undefined;
-                    selectorsToCalculate = selectorsToCalculate.slice(1);
-                }
-            }
-            else {
-                regionToTarget = (0, driver_1.isSelector)(elementReferenceToTarget)
-                    ? (_g = (_f = spec === null || spec === void 0 ? void 0 : spec.untransformSelector) === null || _f === void 0 ? void 0 : _f.call(spec, settings.scrollRootElement)) !== null && _g !== void 0 ? _g : undefined
-                    : undefined;
-                scrollRootSelector = (0, driver_1.isSelector)(settings.scrollRootElement)
-                    ? (_j = (_h = spec === null || spec === void 0 ? void 0 : spec.untransformSelector) === null || _h === void 0 ? void 0 : _h.call(spec, settings.scrollRootElement)) !== null && _j !== void 0 ? _j : undefined
-                    : undefined;
-            }
-            const currentContext = driver.currentContext;
-            const snapshotOptions = {
-                settings: {
-                    ...eyes.test.server,
-                    waitBeforeCapture: settings.waitBeforeCapture,
-                    disableBrowserFetching: settings.disableBrowserFetching,
-                    layoutBreakpoints: settings.layoutBreakpoints,
-                    renderers: uniqueRenderers,
-                    skipResources: ufgClient.getCachedResourceUrls(),
-                },
-                hooks: {
-                    async beforeSnapshots() {
-                        if (settings.lazyLoad && environment.isWeb) {
-                            await (0, wait_for_lazy_load_1.waitForLazyLoad)({
-                                context: driver.currentContext,
-                                settings: settings.lazyLoad !== true ? settings.lazyLoad : {},
-                                logger,
-                            });
-                        }
-                    },
-                },
-                provides: {
-                    getChromeEmulationDevices: ufgClient.getChromeEmulationDevices,
-                    getIOSDevices: ufgClient.getIOSDevices,
-                },
-            };
-            if (environment.isWeb) {
-                snapshots = await (0, take_dom_snapshots_1.takeDomSnapshots)({ driver, ...snapshotOptions, logger });
-            }
-            else {
-                const nmlClient = await eyes.core.getNMLClient({ config: eyes.test.server, driver, logger });
-                if (nmlClient) {
-                    snapshots = (await nmlClient.takeSnapshots({ ...snapshotOptions, logger }));
-                }
-                else {
-                    snapshots = await (0, take_vhses_1.takeVHSes)({ driver, ...snapshotOptions, logger });
-                }
-            }
-            await currentContext.focus();
-            snapshotUrl = await driver.getUrl();
-            snapshotTitle = await driver.getTitle();
-            await (cleanupGeneratedSelectors === null || cleanupGeneratedSelectors === void 0 ? void 0 : cleanupGeneratedSelectors());
+        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 {
-            snapshots = !utils.types.isArray(target) ? Array(uniqueRenderers.length).fill(target) : target;
-            snapshotUrl = utils.types.has(snapshots[0], 'url') ? snapshots[0].url : undefined;
+            // TODO (amit)
+            snapshots = !utils.types.isArray(target) ? Array(uniqueEnvironments.length).fill(target) : target;
         }
-        regionToTarget !== null && regionToTarget !== void 0 ? regionToTarget : (regionToTarget = (_k = elementReferenceToTarget) !== null && _k !== void 0 ? _k : settings.region);
-        selectorsToCalculate !== null && selectorsToCalculate !== void 0 ? selectorsToCalculate : (selectorsToCalculate = elementReferencesToCalculate.map(selector => ({
-            originalSelector: selector,
-            safeSelector: selector,
-        })));
-        const promises = uniqueRenderers.map(async (renderer, index) => {
-            if (utils.types.has(renderer, 'name') && renderer.name === 'edge') {
-                const message = chalk_1.default.yellow(`The 'edge' option that is being used in your browsers' configuration will soon be deprecated. Please change it to either 'edgelegacy' for the legacy version or to 'edgechromium' for the new Chromium-based version. Please note, when using the built-in BrowserType enum, then the values are BrowserType.EDGE_LEGACY and BrowserType.EDGE_CHROMIUM, respectively.`);
-                logger.console.log(message);
+        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 { 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 {
                 if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                    logger.warn('Command "check" was aborted before rendering');
+                    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 snapshotType = utils.types.has(snapshot, 'cdt') ? 'web' : 'native';
-                const renderTargetPromise = ufgClient.createRenderTarget({
-                    snapshot,
-                    settings: {
-                        renderer,
-                        referer: snapshotUrl,
-                        cookies,
-                        proxy: eyes.test.server.proxy,
-                        autProxy: settings.autProxy,
-                        userAgent,
-                    },
-                });
-                const [baseEyes] = await eyes.getBaseEyes({ settings: { renderer, type: snapshotType }, logger });
+                if (utils.types.has(environment, 'iosDeviceInfo') || utils.types.has(environment, 'androidDeviceInfo')) {
+                    environment.type = utils.types.has(target, 'cdt') ? 'web' : 'native';
+                }
+                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) {
-                        logger.warn('Command "check" was aborted before rendering');
+                        environmentLogger.warn('Command "check" was aborted before rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
                     }
                     else 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`);
+                        environmentLogger.warn(`Render on environment with id "${(_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId}" was aborted during one of the previous steps`);
+                        throw new abort_error_1.AbortError(`Render on environment with id "${(_b = baseEyes.test.environment) === null || _b === void 0 ? void 0 : _b.environmentId}" was aborted during one of the previous steps`);
                     }
                     const renderTarget = await renderTargetPromise;
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                        logger.warn('Command "check" was aborted before rendering');
+                        environmentLogger.warn('Command "check" was aborted before rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
                     }
                     else 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`);
+                        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: regionToTarget,
-                            scrollRootElement: scrollRootSelector,
-                            selectorsToCalculate: selectorsToCalculate.flatMap(({ safeSelector }) => safeSelector !== null && safeSelector !== void 0 ? safeSelector : []),
-                            includeFullPageSize: Boolean(settings.pageId),
-                            type: snapshotType,
-                            renderer,
-                            rendererUniqueId: baseEyes.test.rendererUniqueId,
-                            rendererId: baseEyes.test.rendererId,
+                            ...snapshot.settings,
+                            region: (_e = selectors.target) !== null && _e !== void 0 ? _e : snapshot.settings.region,
+                            scrollRootElement: selectors.scrolling,
+                            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: selectorsToCalculate.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) {
-                        logger.warn('Command "check" was aborted after rendering');
+                        environmentLogger.warn('Command "check" was aborted after rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted after rendering');
                     }
                     else 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`);
+                        environmentLogger.warn(`Render on environment with id "${(_f = baseEyes.test.environment) === null || _f === void 0 ? void 0 : _f.environmentId}" was aborted during one of the previous steps`);
+                        throw new abort_error_1.AbortError(`Render on environment with id "${(_g = baseEyes.test.environment) === null || _g === void 0 ? void 0 : _g.environmentId}" was aborted during one of the previous steps`);
                     }
-                    const [result] = await baseEyes.check({
+                    if (settings.assumesMutability) {
+                        void eyes.core.logEvent({
+                            settings: {
+                                level: 'Notice',
+                                event: {
+                                    type: 'eyes.check',
+                                    message: 'Assuming mutability for check Target',
+                                    test: {
+                                        checkName: settings.name,
+                                        batchId: baseEyes.test.batchId,
+                                        sessionId: baseEyes.test.sessionId,
+                                        testName: baseEyes.test.testName,
+                                        testId: baseEyes.test.testId,
+                                        userTestId: baseEyes.test.userTestId,
+                                        appId: baseEyes.test.appId,
+                                        baselineId: baseEyes.test.baselineId,
+                                        environmentId: (_h = baseEyes.test.environment) === null || _h === void 0 ? void 0 : _h.environmentId,
+                                    },
+                                    isNew: baseEyes.test.isNew,
+                                    resultsUrl: baseEyes.test.resultsUrl,
+                                },
+                                ...eyes.test.eyesServer,
+                            },
+                        });
+                    }
+                    await baseEyes.check({
                         target: { ...baseTarget, isTransformed: true },
                         settings: baseSettings,
-                        logger,
+                        logger: environmentLogger,
                     });
-                    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: baseEyes, renderer };
                 }
                 catch (error) {
-                    if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
-                        await baseEyes.abort({ settings: { testMetadata: await (driver === null || driver === void 0 ? void 0 : driver.getSessionMetadata()) } });
-                    }
-                    error.info = { eyes: baseEyes };
-                    throw error;
+                    environmentLogger.error(`Render on environment with id "${(_j = baseEyes.test.environment) === null || _j === void 0 ? void 0 : _j.environmentId}" failed due to an error`, error);
+                    if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted))
+                        await baseEyes.abort({ logger: environmentLogger, settings: { reason: error } });
                 }
             }
             catch (error) {
-                error.info = { ...error.info, userTestId: eyes.test.userTestId, renderer };
+                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;
             }
         });
-        return uniqueRenderers.map((renderer, index) => ({
-            asExpected: true,
-            userTestId: eyes.test.userTestId,
-            renderer,
-            promise: promises[index],
-        }));
+        uniqueEnvironments.forEach((environment, index) => {
+            const key = (0, to_environment_key_1.toEnvironmentKey)(environment);
+            let item = eyes.storage.get(key);
+            if (!item) {
+                item = { eyes: utils.promises.makeControlledPromise(), jobs: [] };
+                eyes.storage.set(key, item);
+            }
+            item.jobs.push(promises[index]);
+        });
     };
 }
 exports.makeCheck = makeCheck;

package/dist/ufg/core.js

@@ -31,26 +31,28 @@ const set_viewport_size_1 = require("../automation/set-viewport-size");
 const locate_1 = require("../automation/locate");
 const locate_text_1 = require("../automation/locate-text");
 const extract_text_1 = require("../automation/extract-text");
+const get_nml_client_1 = require("../automation/get-nml-client");
+const take_snapshots_1 = require("./take-snapshots");
 const get_ufg_client_1 = require("./get-ufg-client");
-const get_nml_client_1 = require("./get-nml-client");
 const open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ concurrency, spec, clients, base, agentId = 'core-ufg', cwd = process.cwd(), logger: defaultLogger, }) {
-    var _a;
-    const logger = (_a = defaultLogger === null || defaultLogger === void 0 ? void 0 : defaultLogger.extend({ label: 'core-ufg' })) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ label: 'core-ufg' });
-    logger.log(`Core ufg is initialized ${base ? 'with' : 'without'} custom base core`);
-    base !== null && base !== void 0 ? base : (base = (0, core_base_1.makeCore)({ agentId, concurrency, cwd, logger }));
+function makeCore({ spec, clients, base: defaultBase, asyncCache, concurrency, offlineLocationPath, fetchConcurrency, agentId = 'core-ufg', logger: defaultLogger, maskLog, }) {
+    const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-ufg' }, maskLog });
+    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, logger, offlineLocationPath, maskLog });
+    const ufgClient = clients === null || clients === void 0 ? void 0 : clients.ufg;
     return utils.general.extend(base, core => {
         return {
             type: 'ufg',
             base: base,
             getViewportSize: spec && (0, get_viewport_size_1.makeGetViewportSize)({ spec, logger }),
             setViewportSize: spec && (0, set_viewport_size_1.makeSetViewportSize)({ spec, logger }),
+            takeSnapshots: spec && (0, take_snapshots_1.makeTakeSnapshots)({ spec, core, logger }),
             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, logger }),
-            getNMLClient: (0, get_nml_client_1.makeGetNMLClient)({ client: clients === null || clients === void 0 ? void 0 : clients.nml, 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-base-eyes.js

@@ -25,26 +25,54 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetBaseEyes = void 0;
 const utils = __importStar(require("@applitools/utils"));
-function makeGetBaseEyes({ settings: defaultSettings, eyes, base, logger: defaultLogger, }) {
-    const getBaseEyesWithCache = utils.general.cachify(getBaseEyes, ([options]) => options === null || options === void 0 ? void 0 : options.settings);
-    if (base) {
-        base.forEach(baseEyes => getBaseEyesWithCache.setCachedValue(baseEyes.test.rendererInfo, Promise.resolve([baseEyes])));
-    }
+const report_kobiton_1 = require("../automation/utils/report-kobiton");
+function makeGetBaseEyes({ settings: defaultSettings, eyes, logger: mainLogger, }) {
+    const getBaseEyesWithCache = utils.general.wrap(getBaseEyes, (getBaseEyes, options) => {
+        const key = JSON.stringify(options.settings.environment);
+        let item = eyes.storage.get(key);
+        if (!item) {
+            item = { eyes: utils.promises.makeControlledPromise(), jobs: [] };
+            eyes.storage.set(key, item);
+        }
+        if (!item.eyes.settled)
+            item.eyes.resolve(getBaseEyes(options));
+        return item.eyes;
+    });
     return getBaseEyesWithCache;
-    async function getBaseEyes({ settings, logger = defaultLogger, } = {}) {
+    async function getBaseEyes({ settings, logger = mainLogger, }) {
+        var _a;
+        logger = logger.extend(mainLogger);
         logger.log(`Command "getBaseEyes" is called with settings`, settings);
-        if (!settings)
-            throw new Error('');
         const ufgClient = await eyes.core.getUFGClient({
-            config: { ...eyes.test.ufgServer },
+            settings: {
+                ...eyes.test.ufgServer,
+                eyesServerUrl: eyes.test.eyesServer.eyesServerUrl,
+                apiKey: eyes.test.eyesServer.apiKey,
+            },
+            logger,
+        });
+        const environment = await ufgClient.getActualEnvironment({
+            settings: { environment: settings.environment },
             logger,
         });
-        const environment = await ufgClient.bookRenderer({ settings });
         const baseEyes = await eyes.core.base.openEyes({
-            settings: { ...defaultSettings, environment: { ...defaultSettings.environment, ...environment } },
+            settings: {
+                ...defaultSettings,
+                fallbackBaselineId: (_a = settings.environment) === null || _a === void 0 ? void 0 : _a.fallbackBaselineId,
+                environment: {
+                    ...defaultSettings.environment,
+                    ...environment,
+                    os: settings.environment.os,
+                    displayOs: settings.environment.displayOs,
+                    hostingApp: settings.environment.hostingApp,
+                    displayHostingApp: settings.environment.displayHostingApp,
+                    properties: settings.environment.properties,
+                },
+            },
             logger,
         });
-        return [baseEyes];
+        void (0, report_kobiton_1.reportKobiton)({ driver: settings.driver, settings: baseEyes.test, logger });
+        return baseEyes;
     }
 }
 exports.makeGetBaseEyes = makeGetBaseEyes;

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

@@ -26,13 +26,22 @@ 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, logger: defaultLogger }) {
-    const getUFGClientWithCache = utils.general.cachify(getUFGClient, ([options]) => client ? 'default' : [options.config]);
+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, offlineLocationPath }]);
     if (client)
         getUFGClientWithCache.setCachedValue('default', Promise.resolve(client));
     return getUFGClientWithCache;
-    async function getUFGClient({ config, logger = defaultLogger }) {
-        return (0, ufg_client_1.makeUFGClient)({ config, logger });
+    async function getUFGClient({ settings, logger = mainLogger }) {
+        logger = logger.extend(mainLogger);
+        const tunnelIds = utils.general.getEnvValue('FETCH_RESOURCE_FROM_TUNNEL', 'boolean')
+            ? utils.general.getEnvValue('TUNNEL_IDS')
+            : undefined;
+        return (0, ufg_client_1.makeUFGClient)({
+            settings: { ...settings, fetchConcurrency, offlineLocationPath, tunnelIds, asyncCache },
+            logger,
+        });
     }
 }
 exports.makeGetUFGClient = makeGetUFGClient;