@applitools/core 2.5.2 → 2.5.3-legacy

package/dist/run-offline-snapshots.js

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

@@ -65,9 +65,11 @@ async function checkNetwork({ stream = process.stdout, eyes = eyes_1.default, uf
     const proxyMsg = '\nYour proxy seems to be blocking requests to Applitools. Please make sure the following command succeeds:';
     if (curlRenderErr) {
         printErr(proxyMsg, '\n', eyes.cmd, '\n');
+        throw new Error('Your proxy seems to be blocking requests to Applitools.');
     }
     else if (curlVgErr) {
         printErr(proxyMsg, '\n', await ufg.getCmd());
+        throw new Error('Your proxy seems to be blocking requests to Applitools.');
     }
     async function doTest(func, name) {
         const delimiterLength = 30 - name.length;
@@ -111,4 +113,6 @@ async function checkNetwork({ stream = process.stdout, eyes = eyes_1.default, uf
     }
 }
 exports.checkNetwork = checkNetwork;
-checkNetwork();
+if (require.main === module) {
+    void checkNetwork();
+}

package/dist/troubleshoot/eyes.js

@@ -40,7 +40,7 @@ const validateRawAccountInfo = (res) => {
     }
 };
 const validateAccountInfo = (res) => {
-    if (!res || !res.ufg || !res.ufg.accessToken || !res.uploadUrl) {
+    if (!res || !res.ufgServer || !res.ufgServer.accessToken || !res.uploadUrl) {
         throw new Error(`bad render info result ${JSON.stringify(res)}`);
     }
 };
@@ -58,8 +58,8 @@ exports.default = {
         validateRawAccountInfo(data);
     },
     async testServer() {
-        const server = (0, core_base_1.makeCoreRequests)({ agentId: 'check-network' });
-        const result = await server.getAccountInfo({ settings: utils_1.config });
+        const server = (0, core_base_1.makeCoreRequestsWithCache)();
+        const result = await server.getAccountInfo({ settings: { eyesServerUrl: utils_1.config.serverUrl, ...utils_1.config } });
         validateAccountInfo(result);
     },
     testHttps: async () => {

package/dist/troubleshoot/logs.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeLogs = exports.structureLogs = exports.stringifyLog = exports.parseLogs = void 0;
+function parseLogs(logs) {
+    const regexp = /^(?<label>[^\s]+) (?:\((?<tags>[^\)]+)\) )?\| (?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)? (?:\[(?<level>[A-Z]+)\s*\])? (?<message>.+)$/;
+    const lines = logs.split('\n');
+    return lines.reduce((logs, line) => {
+        var _a, _b;
+        const match = line.match(regexp);
+        if (match) {
+            logs.push({
+                ...match.groups,
+                tags: (_b = (_a = match.groups) === null || _a === void 0 ? void 0 : _a.tags) === null || _b === void 0 ? void 0 : _b.split(' & ').map(tags => tags.split('/')),
+            });
+        }
+        else if (logs[logs.length - 1]) {
+            logs[logs.length - 1].message += line;
+        }
+        return logs;
+    }, []);
+}
+exports.parseLogs = parseLogs;
+function stringifyLog(log) {
+    var _a;
+    // eslint-disable-next-line
+    return `${log.label} (${(_a = log.tags) === null || _a === void 0 ? void 0 : _a.map(tags => tags.join('/')).join(' & ')}) ${log.timestamp} [${log.level}] ${log.message}`;
+}
+exports.stringifyLog = stringifyLog;
+function structureLogs(logs) {
+    const groups = {};
+    groups.logs;
+    logs.forEach(log => {
+        var _a;
+        const tags = (_a = log.tags) !== null && _a !== void 0 ? _a : [[]];
+        tags.forEach(tags => {
+            var _a;
+            const group = tags.reduce((object, key) => {
+                var _a;
+                (_a = object[key]) !== null && _a !== void 0 ? _a : (object[key] = {});
+                return object[key];
+            }, groups);
+            (_a = group.logs) !== null && _a !== void 0 ? _a : (group.logs = []);
+            group.logs.push(log);
+        });
+    });
+    return groups;
+}
+exports.structureLogs = structureLogs;
+function analyzeLogs({ logs, ...groups }) {
+    var _a, _b;
+    const analysis = {};
+    analysis.logs = logs === null || logs === void 0 ? void 0 : logs.map(stringifyLog);
+    const groupAnalyses = Object.fromEntries(Object.entries(groups).map(([name, group]) => [name, analyzeLogs(group)]));
+    analysis.startedAt = Math.min(Date.parse((_a = logs === null || logs === void 0 ? void 0 : logs[0]) === null || _a === void 0 ? void 0 : _a.timestamp) || Infinity, ...Object.values(groupAnalyses).map(group => group.startedAt));
+    analysis.finishedAt = Math.max(Date.parse((_b = logs === null || logs === void 0 ? void 0 : logs[logs.length - 1]) === null || _b === void 0 ? void 0 : _b.timestamp) || 0, ...Object.values(groupAnalyses).map(group => group.finishedAt));
+    analysis.time = analysis.finishedAt - analysis.startedAt;
+    analysis.conclusion = '';
+    analysis.conclusion += `Time taken: ${formatTime(analysis.time)};`;
+    if (Object.keys(groupAnalyses).length > 0) {
+        analysis.conclusion += `Longest group: ${Object.keys(groupAnalyses).reduce((prev, cur) => groupAnalyses[cur].time > groupAnalyses[prev].time ? cur : prev)}`;
+    }
+    return { ...analysis, ...groupAnalyses };
+}
+exports.analyzeLogs = analyzeLogs;
+function formatTime(ms) {
+    const h = Math.floor(ms / 3600000);
+    if (h)
+        ms -= h * 3600000;
+    const m = Math.floor(ms / 60000);
+    if (m)
+        ms -= m * 60000;
+    const s = Math.floor(ms / 1000);
+    if (s)
+        ms -= s * 1000;
+    return [h && `${h}h`, m && `${m}m`, s && `${s}s`, ms && `${ms}ms`].filter(Boolean).join(' ');
+}

package/dist/troubleshoot/ufg.js

@@ -35,27 +35,34 @@ const utils_1 = require("./utils");
 const eyes_1 = require("./eyes");
 const utils = __importStar(require("@applitools/utils"));
 const node_fetch_1 = __importDefault(require("node-fetch"));
-const value = Buffer.from(JSON.stringify({ resources: {}, domNodes: [] }));
-const hash = (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+const rawValue = JSON.stringify({ resources: {}, domNodes: [] });
+const encodedValue = new TextEncoder().encode(rawValue);
+const hash = (0, crypto_1.createHash)('sha256').update(encodedValue).digest('hex');
 const contentType = 'x-applitools-html/cdt';
 const resource = {
     id: 'id',
     url: 'https://localhost:2107',
-    value,
+    value: encodedValue,
+    rawValue: rawValue,
     hash: { hashFormat: 'sha256', hash, contentType },
     contentType,
 };
 const UFG_PUT_RESOURCE_URL = `https://render-wus.applitools.com/sha256/${resource.hash.hash}?render-id=fake`;
-const accessTokenPromise = new Promise(async (resolve) => {
-    const { stdout } = await utils.process.execute(`curl -s ${eyes_1.RENDER_INFO_URL} ${(0, utils_1.getProxyCurlArg)()}`, {
-        maxBuffer: 10000000,
-    });
-    const accessToken = JSON.parse(stdout).accessToken;
-    if (!accessToken)
-        throw new Error('could not receive auth token since cURL command to get it failed.');
-    resolve(accessToken);
-});
-const getCmd = async () => `curl -X PUT -H "Content-Type: application/json" -H "X-Auth-Token: ${await accessTokenPromise}" -d '${resource.value}' ${UFG_PUT_RESOURCE_URL} ${(0, utils_1.getProxyCurlArg)()}`;
+const getAccessToken = (() => {
+    let accessToken;
+    return async () => {
+        if (!accessToken) {
+            const { stdout } = await utils.process.execute(`curl -s ${eyes_1.RENDER_INFO_URL} ${(0, utils_1.getProxyCurlArg)()}`, {
+                maxBuffer: 10000000,
+            });
+            accessToken = JSON.parse(stdout).accessToken;
+            if (!accessToken)
+                throw new Error('could not receive auth token since cURL command to get it failed.');
+        }
+        return accessToken;
+    };
+})();
+const getCmd = async () => `curl -X PUT -H "Content-Type: application/json" -H "X-Auth-Token: ${await getAccessToken()}" -d '${resource.rawValue}' ${UFG_PUT_RESOURCE_URL} ${(0, utils_1.getProxyCurlArg)()}`;
 exports.getCmd = getCmd;
 const validateVgResult = (res, sha) => {
     if (!res || res.hash !== sha) {
@@ -68,7 +75,7 @@ exports.default = {
             method: 'PUT',
             headers: {
                 'Content-Type': 'x-applitools-html/cdt',
-                'X-Auth-Token': await accessTokenPromise,
+                'X-Auth-Token': await getAccessToken(),
             },
             body: resource.value,
         });
@@ -91,7 +98,7 @@ exports.default = {
     testServer: async () => {
         const url = new URL(UFG_PUT_RESOURCE_URL);
         const requests = (0, ufg_client_1.makeUFGRequests)({
-            config: { serverUrl: url.origin, accessToken: await accessTokenPromise, uploadUrl: '', stitchingServiceUrl: '' },
+            settings: { ufgServerUrl: url.origin, accessToken: await getAccessToken() },
             logger: (0, logger_1.makeLogger)(),
         });
         await requests.uploadResource({ resource });
@@ -105,7 +112,7 @@ exports.default = {
                 method: 'PUT',
                 headers: {
                     'Content-Type': 'x-applitools-html/cdt',
-                    'X-Auth-Token': await accessTokenPromise,
+                    'X-Auth-Token': await getAccessToken(),
                 },
             });
             request.on('response', response => {