@applitools/core 2.5.2 → 2.5.3-legacy

package/dist/classic/check.js

@@ -22,81 +22,340 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.makeCheck = void 0;
+const nml_client_1 = require("@applitools/nml-client");
 const driver_1 = require("@applitools/driver");
-const take_screenshot_1 = require("../automation/utils/take-screenshot");
-const take_dom_capture_1 = require("./utils/take-dom-capture");
+const take_screenshots_1 = require("./utils/take-screenshots");
 const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
 const wait_for_lazy_load_1 = require("../automation/utils/wait-for-lazy-load");
+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 chalk_1 = __importDefault(require("chalk"));
 const utils = __importStar(require("@applitools/utils"));
-function makeCheck({ eyes, target: defaultTarget, spec, logger: defaultLogger, }) {
-    return async function check({ target = defaultTarget, settings = {}, logger = defaultLogger, } = {}) {
-        var _a, _b, _c;
+const lang = __importStar(require("../lang"));
+function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
+    return async function check({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
+        var _a;
+        // logging
+        logger = logger.extend(mainLogger);
         logger.log('Command "check" is called with settings', settings);
+        // input validation and sanitization
         if (!target)
             throw new Error('Method was called with no target');
-        const baseEyes = await eyes.getBaseEyes();
-        if (!(0, driver_1.isDriver)(target, spec)) {
-            return (await Promise.all(baseEyes.map(baseEyes => baseEyes.check({ target, settings: settings, logger })))).flat();
+        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 driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger });
-        const environment = await driver.getEnvironment();
-        await driver.currentContext.setScrollingElement((_a = settings.scrollRootElement) !== null && _a !== void 0 ? _a : null);
-        if (settings.lazyLoad && environment.isWeb) {
-            if (settings.lazyLoad) {
-                await (0, wait_for_lazy_load_1.waitForLazyLoad)({
-                    context: driver.currentContext,
-                    settings: settings.lazyLoad !== true ? settings.lazyLoad : {},
-                    logger,
+        const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
+        let driver = undefined;
+        if ((0, driver_1.isDriver)(target, spec)) {
+            driver = await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger });
+            if (settings.retryTimeout) {
+                // when retry timeout is set, retry checking until it passes or timeout is reached. This will stall the client test execution until it passes or timeout is reached to prevent the test from continuing and changing the state of the app
+                logger.log(`Retry timeout is set to ${settings.retryTimeout}ms - will retry checking until it passes or timeout is reached`);
+                const start = Date.now();
+                const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
+                // this getter actually open the eyes session if it's not already open
+                const baseEyes = await Promise.all(uniqueEnvironments.map(environment => getBaseEyes({ environment, driver, logger: environmentLogger })));
+                // if the test is new for any of the environments, we wait for the page to stabaliize before starting the checks. This should prevent us from creating a baseline with a loading spinner or something similar
+                if (baseEyes.map(baseEye => baseEye.test.isNew).some(isNew => isNew)) {
+                    await new Promise(resolve => setTimeout(resolve, settings.retryTimeout));
+                }
+                let asExpected = false, retries = 0;
+                do {
+                    retries++;
+                    // generate base targets (images to be compared) and settings for each environment
+                    const baseScreenshotsAndSettings = await generateBaseScreenshotsAndSettings(settings, uniqueEnvironments, eyes, logger, driver);
+                    const promises = baseScreenshotsAndSettings.map(async ({ exactEnvironment: environment, baseSetting: settings, baseTarget: target }) => {
+                        return await checkEnvironment({
+                            eyes,
+                            driver,
+                            target,
+                            environment,
+                            signal,
+                            logger,
+                            settings: {
+                                ...settings,
+                                replaceLast: retries > 1,
+                            },
+                        });
+                    });
+                    const results = await Promise.all(promises);
+                    asExpected = results.every(result => result.asExpected);
+                    if (retries === 1) {
+                        baseScreenshotsAndSettings.forEach(({ exactEnvironment }) => {
+                            // put dummy promises in storage to tell eyes.close that all checks hepped
+                            putInStorage(exactEnvironment, eyes, Promise.resolve());
+                        });
+                    }
+                } while (!asExpected && Date.now() - start < settings.retryTimeout);
+            }
+            else {
+                // generate base targets (images to be compared) and settings for each environment
+                const baseScreenshotsAndSettings = await generateBaseScreenshotsAndSettings(settings, uniqueEnvironments, eyes, logger, driver);
+                // when no retry timeout is set, queue all environment checks against the server without stalling the client test execution
+                baseScreenshotsAndSettings.forEach(({ exactEnvironment: environment, baseSetting, baseTarget }) => {
+                    checkInTheBackground(environment, baseTarget, baseSetting);
                 });
             }
         }
-        // TODO it actually could be different per eyes
-        const shouldRunOnce = true;
-        const finishAt = Date.now() + ((_b = settings.retryTimeout) !== null && _b !== void 0 ? _b : 0);
-        let baseTarget;
-        let baseSettings;
-        let results;
-        const { elementReferencesToCalculate, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
-        do {
-            const screenshot = await (0, take_screenshot_1.takeScreenshot)({
-                driver,
-                settings: { ...settings, regionsToCalculate: elementReferencesToCalculate },
+        else {
+            uniqueEnvironments.forEach(environment => checkInTheBackground(environment, target, settings));
+        }
+        function checkInTheBackground(environment, target, settings) {
+            putInStorage(environment, eyes, checkEnvironment({ eyes, driver, target, environment, signal, logger, settings }));
+        }
+    };
+    function putInStorage(environment, eyes, promise) {
+        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(promise.then());
+        return item;
+    }
+    function getBaseEyes({ environment, driver, logger, }) {
+        return eyes.getBaseEyes({ settings: { environment, driver }, logger });
+    }
+}
+exports.makeCheck = makeCheck;
+async function logAmmutabilityIfNeeded({ eyes, baseEyes, settings, }) {
+    var _a;
+    if (settings.assumesMutability) {
+        await 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: (_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId,
+                    },
+                    isNew: baseEyes.test.isNew,
+                    resultsUrl: baseEyes.test.resultsUrl,
+                },
+                ...eyes.test.eyesServer,
+            },
+        });
+        settings.assumesMutability = false; // prevent from logging this message again for the same check
+    }
+}
+async function checkEnvironment({ eyes, driver, target, environment, signal, logger, settings, }) {
+    var _a, _b;
+    const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
+    environmentLogger.log('Command "check" is called with settings', settings);
+    try {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            abortError({ logger: environmentLogger, message: 'Command "check" was aborted before checking' });
+        }
+        const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger: environmentLogger });
+        void logAmmutabilityIfNeeded({
+            eyes,
+            baseEyes,
+            settings,
+        });
+        try {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                abortError({
+                    logger: environmentLogger,
+                    message: `Command "check" was aborted before checking`,
+                });
+            }
+            else if (!baseEyes.running) {
+                abortError({
+                    logger: environmentLogger,
+                    message: `Check on environment with id "${(_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId}" was aborted during one of the previous steps`,
+                });
+            }
+            return await baseEyes.check({
+                target,
+                settings: settings,
+                logger: environmentLogger,
+            });
+        }
+        catch (error) {
+            environmentLogger.error(`Check on environment with id "${(_b = baseEyes.test.environment) === null || _b === void 0 ? void 0 : _b.environmentId}" failed due to an error`, error);
+            if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted))
+                void baseEyes.abort({ logger: environmentLogger, settings: { reason: error } });
+        }
+    }
+    catch (error) {
+        environmentLogger.error(`Environment with id ${environment.environmentId} failed before checking started due to an error`, error);
+        error.info = { ...error.info, userTestId: eyes.test.userTestId, environment };
+        throw error;
+    }
+    return { asExpected: false };
+}
+/**
+ * @throws {AbortError}
+ */
+function abortError({ logger, message }) {
+    logger.warn(message);
+    throw new abort_error_1.AbortError(message);
+}
+/**
+ * create base targets (array of screenshots) and base settings (array of check settings) for each environment
+ */
+async function generateBaseScreenshotsAndSettings(settings, uniqueEnvironments, eyes, logger, driver) {
+    var _a;
+    const driverEnvironment = await driver.getEnvironment();
+    uniqueEnvironments = addMobileDeviceInfo(uniqueEnvironments, driverEnvironment);
+    await beforeScreenshot();
+    const shouldTakeWebScreenshot = driverEnvironment.isWeb ||
+        !((_a = driverEnvironment.applitoolsLib) === null || _a === void 0 ? void 0 : _a.instrumented) ||
+        settings.webview ||
+        settings.screenshotMode === 'default';
+    if (shouldTakeWebScreenshot) {
+        return await takeWebScreenshot({
+            driver,
+            settings,
+            environments: uniqueEnvironments,
+            logger,
+            eyes,
+        });
+    }
+    else {
+        // take screenshot using NML
+        checkConflictingCapabilities();
+        return await takeNMLScreenshot({
+            driver,
+            settings,
+            environments: uniqueEnvironments,
+            logger,
+            eyes,
+        });
+    }
+    async function beforeScreenshot() {
+        var _a;
+        await driver.currentContext.setScrollingElement((_a = settings.scrollRootElement) !== null && _a !== void 0 ? _a : null);
+        if (settings.lazyLoad && driverEnvironment.isWeb) {
+            await (0, wait_for_lazy_load_1.waitForLazyLoad)({
+                context: driver.currentContext,
+                settings: settings.lazyLoad !== true ? settings.lazyLoad : {},
                 logger,
             });
-            baseTarget = {
-                name: await driver.getTitle(),
-                source: await driver.getUrl(),
-                image: await screenshot.image.toPng(),
-                locationInViewport: utils.geometry.location(screenshot.region),
-                isTransformed: true,
-            };
-            baseSettings = getBaseCheckSettings({ calculatedRegions: screenshot.calculatedRegions });
-            if (environment.isWeb && settings.sendDom) {
-                if (settings.fully)
-                    await screenshot.scrollingElement.setAttribute('data-applitools-scroll', 'true');
-                else
-                    await ((_c = screenshot.element) === null || _c === void 0 ? void 0 : _c.setAttribute('data-applitools-scroll', 'true'));
-                baseTarget.dom = await (0, take_dom_capture_1.takeDomCapture)({ driver, settings: { proxy: eyes.test.server.proxy }, logger }).catch(() => undefined);
+        }
+    }
+    function checkConflictingCapabilities() {
+        var _a;
+        if ((_a = driverEnvironment.applitoolsLib) === null || _a === void 0 ? void 0 : _a.conflictingCapabilities) {
+            const message = lang.applitoolsLibConflictingCapabilitiesWarning({
+                conflictingCapabilities: driverEnvironment.applitoolsLib.conflictingCapabilities,
+            });
+            logger.console.log(chalk_1.default.yellow(message));
+            logger.log(message);
+        }
+    }
+    function addMobileDeviceInfo(environments, driverEnvironment) {
+        return environments.map(environment => {
+            var _a, _b;
+            var _c, _d;
+            if (utils.types.has(environment, 'iosDeviceInfo')) {
+                (_a = (_c = environment.iosDeviceInfo).version) !== null && _a !== void 0 ? _a : (_c.version = driverEnvironment.platformVersion);
             }
-            if (settings.pageId) {
-                const scrollingElement = await driver.mainContext.getScrollingElement();
-                const scrollingOffset = !scrollingElement || environment.isNative ? { x: 0, y: 0 } : await scrollingElement.getScrollOffset();
-                baseTarget.locationInView = utils.geometry.offset(scrollingOffset, screenshot.region);
-                baseTarget.fullViewSize = scrollingElement
-                    ? await scrollingElement.getContentSize()
-                    : await driver.getViewportSize();
+            else if (utils.types.has(environment, 'androidDeviceInfo')) {
+                (_b = (_d = environment.androidDeviceInfo).version) !== null && _b !== void 0 ? _b : (_d.version = driverEnvironment.platformVersion);
             }
-            await screenshot.restoreState();
-            baseSettings.ignoreMismatch = !shouldRunOnce;
-            results = (await Promise.all(baseEyes.map(baseEyes => baseEyes.check({ target: baseTarget, settings: baseSettings, logger })))).flat();
-        } while (!shouldRunOnce && !results.some(result => result.asExpected) && Date.now() < finishAt);
-        if (!shouldRunOnce && !results.some(result => result.asExpected)) {
-            baseSettings.ignoreMismatch = false;
-            results = (await Promise.all(baseEyes.map(baseEyes => baseEyes.check({ target: baseTarget, settings: baseSettings, logger })))).flat();
-        }
-        return results;
-    };
+            return environment;
+        });
+    }
+}
+async function takeWebScreenshot({ driver, settings, environments, logger, eyes, }) {
+    let actualEnvironments = environments;
+    if (settings.screenshotMode === 'default') {
+        const { localEnvironment, renderEnvironments } = await (0, nml_client_1.getNMLEnvironmentsInfo)({
+            environments: environments,
+            supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl,
+            proxy: eyes.test.eyesServer.proxy,
+            logger,
+        });
+        actualEnvironments = localEnvironment ? [localEnvironment] : renderEnvironments;
+    }
+    const { elementReferences, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
+    const screenshots = await (0, take_screenshots_1.takeScreenshots)({
+        driver,
+        settings: {
+            ...settings,
+            environments: actualEnvironments,
+            regionsToCalculate: elementReferences.calculate,
+            calculateView: !!settings.pageId,
+            domSettings: settings.sendDom ? { proxy: eyes.test.eyesServer.proxy } : undefined,
+        },
+        logger,
+    });
+    return screenshots.map(({ calculatedRegions, ...baseTarget }, i) => {
+        return {
+            baseTarget,
+            baseSetting: getBaseCheckSettings({ calculatedRegions }),
+            exactEnvironment: actualEnvironments[i],
+        };
+    });
+}
+async function takeNMLScreenshot({ driver, settings, environments, logger, eyes, }) {
+    const nmlClient = await eyes.core.getNMLClient({
+        driver,
+        settings: { ...eyes.test.eyesServer, supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl },
+        logger,
+    });
+    if (settings.scrollRootElement || settings.region || (0, to_base_check_settings_1.hasCodedRegions)(settings))
+        await nmlClient.preTakeScreenshot({ logger });
+    const { elementReferences, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+        settings: {
+            ...settings,
+            ...(await (0, to_base_check_settings_1.extractMobileElementsIntoCheckSettings)({ settings, driver, logger })),
+        },
+    });
+    const calculate = elementReferences.calculate;
+    const screenshots = await nmlClient.takeScreenshots({
+        settings: {
+            environments: environments,
+            fully: settings.fully,
+            stitchMode: settings.stitchMode,
+            hideScrollbars: settings.hideScrollbars,
+            hideCaret: settings.hideScrollbars,
+            overlap: settings.overlap,
+            waitBeforeCapture: settings.waitBeforeCapture,
+            waitBetweenStitches: settings.waitBetweenStitches,
+            lazyLoad: settings.lazyLoad,
+            name: settings.name,
+            region: elementReferences.target,
+            selectorsToFindRegionsFor: calculate.map(({ name }) => name),
+            scrollRootElement: elementReferences.scrolling,
+        },
+        logger,
+    });
+    return screenshots.map(({ calculateRegions, ...baseTarget }) => {
+        const aggregateCalculatedRegions = [];
+        calculate.forEach(({ reference }, index) => {
+            const regions = calculateRegions === null || calculateRegions === void 0 ? void 0 : calculateRegions[index];
+            if (regions) {
+                aggregateCalculatedRegions.push({ regions, selector: reference });
+            }
+            else {
+                logger.log(`Regions "${reference}" was not found in the screenshot`);
+            }
+        });
+        return {
+            baseTarget: { ...baseTarget, isTransformed: true },
+            baseSetting: getBaseCheckSettings({
+                calculatedRegions: aggregateCalculatedRegions,
+            }),
+            exactEnvironment: baseTarget.environment,
+        };
+    });
 }
-exports.makeCheck = makeCheck;

package/dist/classic/core.js

@@ -31,13 +31,13 @@ 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 open_eyes_1 = require("./open-eyes");
 const utils = __importStar(require("@applitools/utils"));
-function makeCore({ spec, base, agentId = 'core-classic', cwd = process.cwd(), logger: defaultLogger, }) {
-    var _a;
-    const logger = (_a = defaultLogger === null || defaultLogger === void 0 ? void 0 : defaultLogger.extend({ label: 'core-classic' })) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ label: 'core-classic' });
-    logger.log(`Core classic is initialized ${base ? 'with' : 'without'} custom base core`);
-    base !== null && base !== void 0 ? base : (base = (0, core_base_1.makeCore)({ agentId, cwd, logger }));
+function makeCore({ spec, clients, base: defaultBase, concurrency, agentId = 'core-classic', logger: defaultLogger, maskLog, offlineLocationPath, }) {
+    const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-classic' }, maskLog });
+    logger.log(`Core classic 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 });
     return utils.general.extend(base, core => {
         return {
             type: 'classic',
@@ -47,6 +47,7 @@ function makeCore({ spec, base, agentId = 'core-classic', cwd = process.cwd(), l
             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 }),
+            ...(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/classic/get-base-eyes.js

@@ -24,16 +24,36 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetBaseEyes = void 0;
+const to_environment_key_1 = require("../automation/utils/to-environment-key");
 const utils = __importStar(require("@applitools/utils"));
-function makeGetBaseEyes({ settings, eyes, base, logger: defaultLogger }) {
-    const getBaseEyesWithCache = utils.general.cachify(getBaseEyes, () => 'default');
-    if (base)
-        getBaseEyesWithCache.setCachedValue('default', Promise.resolve(base));
+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 = (0, to_environment_key_1.toEnvironmentKey)(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({ logger = defaultLogger } = {}) {
+    async function getBaseEyes({ settings, logger = mainLogger, }) {
+        var _a;
+        logger = logger.extend(mainLogger);
         logger.log(`Command "getBaseEyes" is called with settings`, settings);
-        const baseEyes = await eyes.core.base.openEyes({ settings, logger });
-        return [baseEyes];
+        const baseEyes = await eyes.core.base.openEyes({
+            settings: {
+                ...defaultSettings,
+                fallbackBaselineId: (_a = settings.environment) === null || _a === void 0 ? void 0 : _a.fallbackBaselineId,
+                environment: { ...defaultSettings.environment, ...settings.environment },
+            },
+            logger,
+        });
+        void (0, report_kobiton_1.reportKobiton)({ driver: settings.driver, settings: baseEyes.test, logger });
+        return baseEyes;
     }
 }
 exports.makeGetBaseEyes = makeGetBaseEyes;

package/dist/classic/open-eyes.js

@@ -28,69 +28,59 @@ const driver_1 = require("@applitools/driver");
 const get_base_eyes_1 = require("./get-base-eyes");
 const check_1 = require("./check");
 const check_and_close_1 = require("./check-and-close");
-const close_1 = require("./close");
-const abort_1 = require("./abort");
+const close_1 = require("../automation/close");
+const abort_1 = require("../automation/abort");
+const get_results_1 = require("../automation/get-results");
+const extract_default_environments_1 = require("./utils/extract-default-environments");
+const abort_controller_1 = require("abort-controller");
 const utils = __importStar(require("@applitools/utils"));
-function makeOpenEyes({ core, spec, logger: defaultLogger }) {
-    return async function openEyes({ target, settings, base, logger = defaultLogger, }) {
-        var _a, _b, _c, _d, _e, _f;
-        var _g;
-        logger.log(`Command "openEyes" is called with ${target ? 'default driver and' : ''}`, ...(settings ? ['settings', settings] : []), base ? 'predefined eyes' : '');
+function makeOpenEyes({ core, spec, logger: mainLogger }) {
+    return async function openEyes({ target, settings, storage = new Map(), logger = mainLogger, }) {
+        var _a, _b, _c;
+        logger = logger.extend(mainLogger);
+        logger.log(`Command "openEyes" is called with ${target ? 'default driver' : ''}`, ...(settings ? ['and settings', settings] : []), storage.size > 0 ? 'and default eyes storage' : '');
         const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: settings }));
-        if (driver && !base) {
+        if (driver && storage.size === 0) {
             const environment = await driver.getEnvironment();
-            const currentContext = driver.currentContext;
-            (_a = settings.environment) !== null && _a !== void 0 ? _a : (settings.environment = {});
-            if (environment.isEC) {
-                settings.environment.ecSessionId = (await driver.getSessionId());
-            }
-            if (environment.isWeb) {
-                (_b = (_g = settings.environment).userAgent) !== null && _b !== void 0 ? _b : (_g.userAgent = (_c = (await driver.getUserAgentLegacy())) !== null && _c !== void 0 ? _c : undefined);
-            }
-            if (!settings.environment.deviceName && environment.deviceName) {
-                settings.environment.deviceName = environment.deviceName;
-            }
-            if (!settings.environment.os) {
-                if (environment.isNative && environment.platformName) {
-                    settings.environment.os = environment.platformName;
-                    if (!settings.keepPlatformNameAsIs) {
-                        if ((_d = settings.environment.os) === null || _d === void 0 ? void 0 : _d.startsWith('android')) {
-                            settings.environment.os = `Android${settings.environment.os.slice(7)}`;
-                        }
-                        if ((_e = settings.environment.os) === null || _e === void 0 ? void 0 : _e.startsWith('ios')) {
-                            settings.environment.os = `iOS${settings.environment.os.slice(3)}`;
-                        }
-                    }
-                    if (environment.platformVersion) {
-                        settings.environment.os += ` ${environment.platformVersion}`;
-                    }
-                }
-                else if (environment.isChromium &&
-                    ((environment.isWindows && Number.parseInt(environment.browserVersion) >= 107) ||
-                        (environment.isMac && Number.parseInt(environment.browserVersion) >= 90))) {
-                    settings.environment.os = `${environment.platformName} ${(_f = environment.platformVersion) !== null && _f !== void 0 ? _f : ''}`.trim();
-                }
-            }
-            if (!settings.environment.viewportSize || environment.isMobile) {
-                const viewport = await driver.getViewport();
-                const size = await driver.getViewportSize();
-                settings.environment.viewportSize = utils.geometry.scale(size, viewport.viewportScale);
-            }
-            else {
+            if (((_a = settings.environment) === null || _a === void 0 ? void 0 : _a.viewportSize) && !environment.isMobile) {
                 await driver.setViewportSize(settings.environment.viewportSize);
             }
-            await currentContext.focus();
+            (_b = settings.environment) !== null && _b !== void 0 ? _b : (settings.environment = {});
+            if (environment.isEC) {
+                settings.environment.ecSessionId = (_c = (await driver.getSessionId())) !== null && _c !== void 0 ? _c : undefined;
+            }
         }
-        base !== null && base !== void 0 ? base : (base = [await core.base.openEyes({ settings, logger })]);
-        return utils.general.extend(base[0], eyes => ({
-            type: 'classic',
-            core,
-            getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, base, logger }),
-            check: (0, check_1.makeCheck)({ eyes, target: driver, spec, logger }),
-            checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, spec, logger }),
-            close: (0, close_1.makeClose)({ eyes, target: driver, spec, logger }),
-            abort: (0, abort_1.makeAbort)({ eyes, target: driver, spec, logger }),
-        }));
+        const environments = await (0, extract_default_environments_1.extractDefaultEnvironments)({ driver, settings });
+        const controller = new abort_controller_1.AbortController();
+        const { signal } = controller;
+        const account = await core.getAccountInfo({ settings, logger });
+        return utils.general.extend({}, eyes => {
+            var _a, _b, _c, _d;
+            return {
+                type: 'classic',
+                core,
+                test: {
+                    userTestId: settings.userTestId,
+                    batchId: (_a = settings.batch) === null || _a === void 0 ? void 0 : _a.id,
+                    batchBuildId: (_b = settings.batch) === null || _b === void 0 ? void 0 : _b.buildId,
+                    keepBatchOpen: settings.keepBatchOpen,
+                    eyesServer: account.eyesServer,
+                    ufgServer: { ...account.ufgServer, ufgServerUrl: (_c = settings.ufgServerUrl) !== null && _c !== void 0 ? _c : (_d = account.ufgServer) === null || _d === void 0 ? void 0 : _d.ufgServerUrl },
+                    uploadUrl: account.uploadUrl,
+                    stitchingServiceUrl: account.stitchingServiceUrl,
+                    supportedEnvironmentsUrl: account.supportedEnvironmentsUrl,
+                    account,
+                },
+                running: true,
+                storage,
+                getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, logger }),
+                check: (0, check_1.makeCheck)({ eyes, target: driver, environments, spec, signal, logger }),
+                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, environments, spec, signal, logger }),
+                close: (0, close_1.makeClose)({ eyes, driver, environments, logger }),
+                abort: (0, abort_1.makeAbort)({ eyes, driver, environments, controller, logger }),
+                getResults: (0, get_results_1.makeGetResults)({ eyes, logger }),
+            };
+        });
     };
 }
 exports.makeOpenEyes = makeOpenEyes;