@applitools/core 2.5.2 → 2.5.3-legacy

package/dist/offline/run-offline-snapshots.js

@@ -0,0 +1,341 @@
+"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 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"));
+const merge_configs_1 = require("./merge-configs");
+async function runOfflineSnapshots(options) {
+    var _a, _b;
+    if (!options.offlineLocationPath)
+        throw new Error('offlineLocationPath is required');
+    const offlineLocationPath = path_1.default.resolve(options.offlineLocationPath);
+    const startTime = Date.now();
+    const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ format: { label: 'offline-exec' } });
+    const eyesServerSettings = { ...(_b = options.config) === null || _b === void 0 ? void 0 : _b.open, ...options };
+    const core = (0, core_1.makeCore)();
+    const account = await core.getAccountInfo({ settings: eyesServerSettings });
+    const ufgClient = await (0, get_ufg_client_1.makeGetUFGClient)({ logger })({
+        settings: { ...account.eyesServer, ...account.ufgServer },
+    });
+    const testFolders = (await fs_1.default.promises.readdir(offlineLocationPath))
+        .filter(filename => filename.startsWith('test-'))
+        .sort();
+    if (testFolders.length === 1) {
+        logger.console.log(`Running single test from folder ${offlineLocationPath}`);
+    }
+    else if (testFolders.length === 0) {
+        logger.console.log('No test artifacts were found at', offlineLocationPath);
+    }
+    else {
+        logger.console.log(`Running ${testFolders.length} tests from folder ${offlineLocationPath}`);
+    }
+    if (testFolders.length === 0) {
+        throw new Error(`Unable to find offline executions in ${offlineLocationPath}`);
+    }
+    const allTestResults = await runTests(testFolders);
+    const { isSuccess, outputStr } = processResults({ testResults: allTestResults, totalTime: Date.now() - startTime });
+    if (!isSuccess && options.failOnDiff) {
+        throw new Error(outputStr);
+    }
+    else {
+        logger.console.log(outputStr);
+    }
+    return allTestResults;
+    async function runTests(testFolders) {
+        logger.log('running tests', testFolders);
+        const results = await Promise.all(testFolders.map(async (testFolder) => {
+            const testLogger = logger.extend({ tags: [testFolder] });
+            const testPath = path_1.default.join(offlineLocationPath, testFolder);
+            const fileOpenSettings = await fs_1.default.promises
+                .readFile(path_1.default.join(testPath, 'settings.json'), 'utf-8')
+                .then(JSON.parse);
+            const openSettings = (0, merge_configs_1.mergeConfigs)(fileOpenSettings, options.config.open);
+            logger.console.log(`Running test: ${openSettings.testName} (${formatEnvironment(openSettings.environment)})`);
+            return runTest(testPath, openSettings, testLogger);
+        }));
+        const batchIds = [...new Set(results.map(t => t.batchId))];
+        const allTestResults = results.map(t => t.results);
+        logger.log('done running all tests', allTestResults);
+        await core.closeBatch({ settings: batchIds.map(batchId => ({ batchId, ...account.eyesServer })) });
+        logger.log('done closing batches');
+        return allTestResults;
+    }
+    async function runTest(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(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)));
+        const fileCloseSettings = await fs_1.default.promises.readFile(path_1.default.resolve(testPath, 'close.json'), 'utf-8').then(JSON.parse);
+        const closeSettings = (0, merge_configs_1.mergeConfigs)(fileCloseSettings, options.config.close);
+        await eyes.close({ settings: closeSettings });
+        logger.log('done running test', logger);
+        return { batchId: openSettings.batch.id, results: (await eyes.getResults({ logger }))[0] };
+    }
+    async function uploadResources(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.join(offlineLocationPath, '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.join(offlineLocationPath, '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
+        const mergedCheckSettings = (0, merge_configs_1.mergeConfigs)(baseSettings, options.config.check);
+        await eyes.check({
+            target: { ...baseTarget, isTransformed: true },
+            settings: mergedCheckSettings,
+            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 isSuccess;
+    if (errors.length) {
+        isSuccess = false;
+    }
+    else if (failOnDiff) {
+        isSuccess = !warnForUnsavedNewTests && passedOrNew.length && !unresolvedOrFailed.length;
+    }
+    else {
+        isSuccess = true;
+    }
+    return {
+        outputStr,
+        isSuccess,
+    };
+}
+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/open-eyes.js

@@ -31,74 +31,218 @@ const get_typed_eyes_1 = require("./get-typed-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 get_eyes_results_1 = require("./get-eyes-results");
-const extract_ci_provider_1 = require("./utils/extract-ci-provider");
+const populate_eyes_server_settings_1 = require("./utils/populate-eyes-server-settings");
 const utils = __importStar(require("@applitools/utils"));
-function makeOpenEyes({ type: defaultType = 'classic', concurrency, batch, core, cores, spec, logger: defaultLogger, }) {
-    return async function openEyes({ type = defaultType, settings, config, target, logger = defaultLogger, }) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
-        var _v, _w, _x, _y;
-        settings = { ...config === null || config === void 0 ? void 0 : config.open, ...settings };
+const core_base_1 = require("@applitools/core-base");
+const extract_git_info_1 = require("./utils/extract-git-info");
+function makeOpenEyes({ type: defaultType = 'classic', clients, batch, removeDuplicateTests, core, cores, spec, environment, logger: mainLogger, asyncCache, cwd = process.cwd(), }) {
+    return async function openEyes({ type = defaultType, settings: openSettings, config, target, logger = mainLogger, }) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+        var _w, _x, _y, _z, _0;
+        logger = logger.extend(mainLogger, { tags: [`eyes-${type}-${utils.general.shortid()}`] });
+        const settings = { ...config === null || config === void 0 ? void 0 : config.open, ...openSettings };
+        const eyesServerSettings = (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
+        logger.mask(eyesServerSettings.apiKey);
+        logger.mask(eyesServerSettings.eyesServerUrl);
         (_a = settings.userTestId) !== null && _a !== void 0 ? _a : (settings.userTestId = `${settings.testName}--${utils.general.guid()}`);
-        (_b = settings.serverUrl) !== null && _b !== void 0 ? _b : (settings.serverUrl = (_c = utils.general.getEnvValue('SERVER_URL')) !== null && _c !== void 0 ? _c : 'https://eyesapi.applitools.com');
-        (_d = settings.apiKey) !== null && _d !== void 0 ? _d : (settings.apiKey = utils.general.getEnvValue('API_KEY'));
         settings.batch = { ...batch, ...settings.batch };
-        (_e = (_v = settings.batch).id) !== null && _e !== void 0 ? _e : (_v.id = (_f = utils.general.getEnvValue('BATCH_ID')) !== null && _f !== void 0 ? _f : `generated-${utils.general.guid()}`);
-        (_g = (_w = settings.batch).name) !== null && _g !== void 0 ? _g : (_w.name = utils.general.getEnvValue('BATCH_NAME'));
-        (_h = (_x = settings.batch).sequenceName) !== null && _h !== void 0 ? _h : (_x.sequenceName = utils.general.getEnvValue('BATCH_SEQUENCE'));
-        (_j = (_y = settings.batch).notifyOnCompletion) !== null && _j !== void 0 ? _j : (_y.notifyOnCompletion = utils.general.getEnvValue('BATCH_NOTIFY', 'boolean'));
-        (_k = settings.keepBatchOpen) !== null && _k !== void 0 ? _k : (settings.keepBatchOpen = utils.general.getEnvValue('DONT_CLOSE_BATCHES', 'boolean'));
-        (_l = settings.branchName) !== null && _l !== void 0 ? _l : (settings.branchName = utils.general.getEnvValue('BRANCH'));
-        (_m = settings.parentBranchName) !== null && _m !== void 0 ? _m : (settings.parentBranchName = utils.general.getEnvValue('PARENT_BRANCH'));
-        (_o = settings.baselineBranchName) !== null && _o !== void 0 ? _o : (settings.baselineBranchName = utils.general.getEnvValue('BASELINE_BRANCH'));
-        (_p = settings.ignoreBaseline) !== null && _p !== void 0 ? _p : (settings.ignoreBaseline = false);
-        (_q = settings.compareWithParentBranch) !== null && _q !== void 0 ? _q : (settings.compareWithParentBranch = false);
-        const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: settings }));
-        const account = await core.getAccountInfo({
-            settings: settings,
-            logger,
-        });
-        if (account.ecEnabled) {
-            const environment = await (driver === null || driver === void 0 ? void 0 : driver.getEnvironment());
-            (_r = settings.properties) !== null && _r !== void 0 ? _r : (settings.properties = []);
-            settings.properties.push({ name: 'Execution cloud', value: (environment === null || environment === void 0 ? void 0 : environment.isEC) ? 'Yes' : 'No' });
+        (_b = (_w = settings.batch).id) !== null && _b !== void 0 ? _b : (_w.id = (_c = utils.general.getEnvValue('BATCH_ID')) !== null && _c !== void 0 ? _c : `generated-${utils.general.guid()}`);
+        (_d = (_x = settings.batch).buildId) !== null && _d !== void 0 ? _d : (_x.buildId = utils.general.getEnvValue('BATCH_BUILD_ID'));
+        (_e = (_y = settings.batch).name) !== null && _e !== void 0 ? _e : (_y.name = utils.general.getEnvValue('BATCH_NAME'));
+        (_f = (_z = settings.batch).sequenceName) !== null && _f !== void 0 ? _f : (_z.sequenceName = utils.general.getEnvValue('BATCH_SEQUENCE'));
+        (_g = (_0 = settings.batch).notifyOnCompletion) !== null && _g !== void 0 ? _g : (_0.notifyOnCompletion = utils.general.getEnvValue('BATCH_NOTIFY', 'boolean'));
+        (_h = settings.keepBatchOpen) !== null && _h !== void 0 ? _h : (settings.keepBatchOpen = utils.general.getEnvValue('DONT_CLOSE_BATCHES', 'boolean'));
+        (_j = settings.branchName) !== null && _j !== void 0 ? _j : (settings.branchName = utils.general.getEnvValue('BRANCH'));
+        (_k = settings.parentBranchName) !== null && _k !== void 0 ? _k : (settings.parentBranchName = utils.general.getEnvValue('PARENT_BRANCH'));
+        (_l = settings.baselineBranchName) !== null && _l !== void 0 ? _l : (settings.baselineBranchName = utils.general.getEnvValue('BASELINE_BRANCH'));
+        (_m = settings.gitBranchingTimestamp) !== null && _m !== void 0 ? _m : (settings.gitBranchingTimestamp = utils.general.getEnvValue('GIT_MERGE_BASE_TIMESTAMP'));
+        (_o = settings.latestCommitInfo) !== null && _o !== void 0 ? _o : (settings.latestCommitInfo = getLatestCommitInfoFromEnvVars(logger));
+        (_p = settings.ufgServerUrl) !== null && _p !== void 0 ? _p : (settings.ufgServerUrl = utils.general.getEnvValue('UFG_SERVER_URL'));
+        (_q = settings.ignoreBaseline) !== null && _q !== void 0 ? _q : (settings.ignoreBaseline = false);
+        (_r = settings.compareWithParentBranch) !== null && _r !== void 0 ? _r : (settings.compareWithParentBranch = false);
+        (_s = settings.removeDuplicateTests) !== null && _s !== void 0 ? _s : (settings.removeDuplicateTests = removeDuplicateTests);
+        (_t = settings.latestCommitInfo) !== null && _t !== void 0 ? _t : (settings.latestCommitInfo = await (0, extract_git_info_1.extractLatestCommitInfo)({ execOptions: { cwd }, logger }));
+        if (settings.latestCommitInfo && !(0, extract_git_info_1.isISODate)(settings.latestCommitInfo.timestamp)) {
+            logger.warn(`latestCommitInfo.timestamp is an invalid ISO date string: ${settings.latestCommitInfo.timestamp}`);
+            settings.latestCommitInfo = undefined;
+        }
+        if (process.env.CI && (isRealBatchId(settings.batch.id) || settings.latestCommitInfo)) {
+            await populateAutoScmInfo(isRealBatchId(settings.batch.id) ? settings.batch.id : settings.latestCommitInfo.sha);
+        }
+        if (settings.ignoreGitBranching) {
+            settings.gitBranchingTimestamp = undefined;
+        }
+        else if (!settings.gitBranchingTimestamp) {
+            const { branchName, parentBranchName } = settings;
+            if (branchName && parentBranchName && branchName !== parentBranchName) {
+                settings.gitBranchingTimestamp = await (0, extract_git_info_1.extractBranchingTimestamp)({
+                    branchName,
+                    parentBranchName,
+                    execOptions: { cwd },
+                    logger,
+                });
+            }
         }
-        core.logEvent({
+        if (settings.gitBranchingTimestamp && !(0, extract_git_info_1.isISODate)(settings.gitBranchingTimestamp)) {
+            logger.warn(`gitBranchingTimestamp is an invalid ISO date string: ${settings.gitBranchingTimestamp}`);
+            settings.gitBranchingTimestamp = undefined;
+        }
+        const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: settings }));
+        const driverEnvironment = await (driver === null || driver === void 0 ? void 0 : driver.getEnvironment());
+        const driverUrl = await (driver === null || driver === void 0 ? void 0 : driver.getDriverUrl());
+        void core.logEvent({
             settings: {
-                serverUrl: settings.serverUrl,
-                apiKey: settings.apiKey,
-                proxy: settings.proxy,
-                agentId: settings.agentId,
+                ...settings,
                 level: 'Notice',
                 event: {
-                    type: 'runnerStarted',
-                    testConcurrency: concurrency,
-                    concurrentRendersPerTest: (_u = (_t = (_s = config === null || config === void 0 ? void 0 : config.check) === null || _s === void 0 ? void 0 : _s.renderers) === null || _t === void 0 ? void 0 : _t.length) !== null && _u !== void 0 ? _u : 1,
-                    node: { version: process.version, platform: process.platform, arch: process.arch },
-                    driverUrl: await (driver === null || driver === void 0 ? void 0 : driver.getDriverUrl()),
-                    extractedCIProvider: (0, extract_ci_provider_1.extractCIProvider)(),
+                    type: 'openEyes',
+                    userTestId: settings.userTestId,
+                    concurrency: (_u = cores === null || cores === void 0 ? void 0 : cores[type].concurrency) !== null && _u !== void 0 ? _u : core.concurrency,
+                    environment,
+                    driver: {
+                        deviceName: driverEnvironment === null || driverEnvironment === void 0 ? void 0 : driverEnvironment.deviceName,
+                        browserName: driverEnvironment === null || driverEnvironment === void 0 ? void 0 : driverEnvironment.browserName,
+                        browserVersion: driverEnvironment === null || driverEnvironment === void 0 ? void 0 : driverEnvironment.browserVersion,
+                        platformName: driverEnvironment === null || driverEnvironment === void 0 ? void 0 : driverEnvironment.platformName,
+                        platformVersion: driverEnvironment === null || driverEnvironment === void 0 ? void 0 : driverEnvironment.platformVersion,
+                        isApplitoolsLib: (_v = driverEnvironment === null || driverEnvironment === void 0 ? void 0 : driverEnvironment.applitoolsLib) === null || _v === void 0 ? void 0 : _v.instrumented,
+                        isEC: driverEnvironment === null || driverEnvironment === void 0 ? void 0 : driverEnvironment.isEC,
+                    },
+                    driverUrl,
                 },
             },
             logger,
         });
+        if (settings.disableBrokerUrlCache && driver) {
+            await core.clearNMLClientCache(driver);
+        }
         const getTypedEyes = (0, get_typed_eyes_1.makeGetTypedEyes)({
             type,
             settings: settings,
             target: driver,
             cores: cores !== null && cores !== void 0 ? cores : {
-                ufg: (0, core_2.makeCore)({ spec, base: core.base, concurrency: concurrency !== null && concurrency !== void 0 ? concurrency : 5, logger }),
-                classic: (0, core_1.makeCore)({ spec, base: core.base, logger }),
+                ufg: (0, core_2.makeCore)({ spec, clients, base: core.base, asyncCache, logger }),
+                classic: (0, core_1.makeCore)({ spec, clients, base: core.base, logger }),
             },
             logger,
         });
-        const eyes = await getTypedEyes({ logger });
-        return utils.general.extend(eyes, eyes => ({
-            getTypedEyes,
-            check: (0, check_1.makeCheck)({ type, eyes, target: driver, spec, logger }),
-            checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ type, eyes, target: driver, spec, logger }),
-            close: (0, close_1.makeClose)({ eyes, logger }),
-            getResults: (0, get_eyes_results_1.makeGetEyesResults)({ eyes, logger }),
-        })); // TODO solve the types issue
+        const eyes = await getTypedEyes({ logger }).catch(error => {
+            throw refineMissingApiKeyException(error, environment === null || environment === void 0 ? void 0 : environment.sdk);
+        });
+        return utils.general.extend(eyes, eyes => {
+            var _a, _b;
+            return ({
+                getTypedEyes,
+                check: (0, check_1.makeCheck)({ type, eyes, target: driver, spec, logger }),
+                checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ type, eyes, target: driver, spec, logger }),
+                close: (0, close_1.makeClose)({ eyes, environments: (_a = config === null || config === void 0 ? void 0 : config.check) === null || _a === void 0 ? void 0 : _a.environments, logger }),
+                abort: (0, abort_1.makeAbort)({ eyes, environments: (_b = config === null || config === void 0 ? void 0 : config.check) === null || _b === void 0 ? void 0 : _b.environments, logger }),
+                getResults: (0, get_eyes_results_1.makeGetEyesResults)({ eyes, logger }),
+            });
+        }); // TODO solve the types issue
+        /////// END FUNCTION BODY ///////////////////
+        async function populateAutoScmInfo(batchId) {
+            var _a, _b;
+            var _c;
+            const branchName = await (0, extract_git_info_1.extractGitBranch)({ execOptions: { cwd }, logger });
+            const { owner: repoOwner, name: repoName } = await (0, extract_git_info_1.extractGitRepo)({ execOptions: { cwd }, logger });
+            const buildId = await (0, extract_git_info_1.extractBuildIdFromCI)();
+            if (branchName && repoOwner && repoName) {
+                const scmInfo = await core.base
+                    .updateIfScm({
+                    settings: { ...eyesServerSettings, batchId, branchName, repoOwner, repoName, buildId },
+                    logger,
+                })
+                    .catch(error => {
+                    throw refineMissingApiKeyException(error, environment === null || environment === void 0 ? void 0 : environment.sdk);
+                });
+                if (scmInfo) {
+                    (_a = settings.batch) !== null && _a !== void 0 ? _a : (settings.batch = {});
+                    settings.batch.id = isRealBatchId(settings.batch.id) ? settings.batch.id : batchId;
+                    (_b = (_c = settings.batch).buildId) !== null && _b !== void 0 ? _b : (_c.buildId = buildId);
+                    // Intentionally not auto populating branchName and parentBranchName. If there is scmInfo then Eyes already knows these values.
+                }
+            }
+            else {
+                logger.log(`Skipping check for SCM integration due to missing information: branchName=${branchName} repoName=${repoName} repoOwner=${repoOwner}`);
+            }
+        }
     };
 }
 exports.makeOpenEyes = makeOpenEyes;
+function refineMissingApiKeyException(error, sdk) {
+    var _a;
+    if (!sdk || typeof sdk !== 'object')
+        return error;
+    try {
+        if (error instanceof core_base_1.MissingApiKeyError) {
+            const apiKeyTutorials = {
+                python: {
+                    'eyes-selenium': 'api-ref/sdk-api/selenium/python/#API',
+                    'eyes-playwright': 'api-ref/sdk-api/playwright/python/#API',
+                    'eyes-robotframework': 'api-ref/sdk-api/robot/#API',
+                    'eyes-images': undefined,
+                },
+                ruby: {
+                    eyes_images: 'api-ref/sdk-api/selenium/ruby/#API',
+                    eyes_appium: undefined,
+                    eyes_selenium: undefined,
+                    eyes_universal: undefined,
+                    eyes_capybara: undefined,
+                    eyes_calabash: undefined,
+                },
+                java: {
+                    java_appium: undefined,
+                    java_selenium: 'api-ref/sdk-api/selenium/java/#API',
+                    java_playwright: 'api-ref/sdk-api/playwright/java/#API',
+                    java_images: undefined,
+                },
+                dotnet: {
+                    'eyes-selenium': 'api-ref/sdk-api/selenium/csharp/#API',
+                    'eyes-playwright': 'api-ref/sdk-api/playwright/csharp/#API',
+                    'eyes-appium': undefined,
+                    'eyes-appium2': undefined,
+                    'eyes-images': undefined,
+                },
+                js: {
+                    'eyes-images': undefined,
+                    'eyes-webdriverio': 'api-ref/sdk-api/wdio/#API',
+                    'eyes-selenium': 'api-ref/sdk-api/selenium/javascript/#API',
+                    'eyes-playwright': 'api-ref/sdk-api/playwright/javascript/#API',
+                    'eyes-puppeteer': 'api-ref/sdk-api/puppeteer/javascript/#API',
+                    'eyes-storybook': 'api-ref/sdk-api/storybook/#API',
+                    'eyes-cypress': 'api-ref/sdk-api/cypress/#API',
+                },
+            };
+            const { lang, name } = sdk !== null && sdk !== void 0 ? sdk : {};
+            const path = (_a = apiKeyTutorials[lang]) === null || _a === void 0 ? void 0 : _a[name];
+            if (path) {
+                error.message = error.message.replace('Default.html#cshid=api', path);
+            }
+        }
+    }
+    catch {
+        // if it fails, no harm done. The error message is fine without this refinement
+        return error;
+    }
+    return error;
+}
+function getLatestCommitInfoFromEnvVars(logger) {
+    const timestamp = utils.general.getEnvValue('GIT_LATEST_COMMIT_TIMESTAMP');
+    const sha = utils.general.getEnvValue('GIT_LATEST_COMMIT_SHA');
+    if (timestamp && sha) {
+        return { timestamp, sha };
+    }
+    else if (timestamp && !sha) {
+        logger.warn(`APPLITOOLS_GIT_LATEST_COMMIT_TIMESTAMP was provided without APPLITOOLS_GIT_LATEST_COMMIT_SHA. Proceeding provided timestamp ${timestamp} and NO_SHA_PROVIDED`);
+        return { timestamp, sha: 'NO_SHA_PROVIDED' };
+    }
+    else if (sha && !timestamp) {
+        logger.warn(`APPLITOOLS_GIT_LATEST_COMMIT_SHA was provided without APPLITOOLS_GIT_LATEST_COMMIT_TIMESTAMP. Not populating latestCommitInfo with the provided sha ${sha}.`);
+    }
+}
+function isRealBatchId(batchId) {
+    return !!batchId && !batchId.startsWith('generated');
+}