@testim/testim-cli 3.245.0 → 3.246.0

package/chromiumInstaller.js

@@ -0,0 +1,92 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+const { ArgError } = require('./errors');
+const { unzipFile } = require('./utils');
+const { downloadAndSave, TESTIM_BROWSER_DIR } = require('./utils');
+const ora = require('ora');
+
+
+const CHROMIUM_VERSION = '1000968'; // '973306' = 101.0.4899.0  '1000968' = 103.0.5046.0;
+const DOWNLOAD_CHROME_FOLDER = path.join(TESTIM_BROWSER_DIR, `chrome-${CHROMIUM_VERSION}`);
+
+function getCurrentPlatform() {
+    const osType = os.type().toLowerCase();
+    if (osType === 'darwin') {
+        return os.arch() === 'arm' ? 'mac_arm' : 'mac';
+    }
+    if (osType === 'windows_nt') {
+        return os.arch() === 'x64' ? 'win64' : 'win32';
+    }
+    return 'linux';
+}
+
+async function downloadAndInstallChromium() {
+    /** Inspired by puppeteer's implementation https://github.com/puppeteer/puppeteer/blob/main/src/node/BrowserFetcher.ts#L45 */
+    const platform = getCurrentPlatform();
+
+    // example download url: https://storage.googleapis.com/chromium-browser-snapshots/Mac/1000968/chrome-mac.zip
+    const storageBaseUrl = 'https://storage.googleapis.com/chromium-browser-snapshots';
+    const platformFolder = {
+        linux: 'Linux_x64',
+        mac: 'Mac',
+        mac_arm: 'Mac_Arm',
+        win32: 'Win',
+        win64: 'Win_x64',
+    };
+    if (!(platform in platformFolder)) {
+        throw new ArgError(`Unsupported platform: ${platform}`);
+    }
+    // Windows archive name changed at r591479.
+    const winArchiveName = parseInt(CHROMIUM_VERSION, 10) > 591479 ? 'chrome-win' : 'chrome-win32';
+    const platformArchiveName = {
+        linux: 'chrome-linux',
+        mac: 'chrome-mac',
+        mac_arm: 'chrome-mac',
+        win32: winArchiveName,
+        win64: winArchiveName,
+    };
+    const binaryPaths = {
+        linux: 'chrome',
+        mac: 'Chromium.app/Contents/MacOS/Chromium',
+        mac_arm: 'Chromium.app/Contents/MacOS/Chromium',
+        win32: 'chrome.exe',
+        win64: 'chrome.exe',
+    };
+    const downloadUrl = `${storageBaseUrl}/${platformFolder[platform]}/${CHROMIUM_VERSION}/${platformArchiveName[platform]}.zip`;
+    const downloadArchivePath = path.join(DOWNLOAD_CHROME_FOLDER, platformArchiveName[platform]);
+    const downloadedZipFile = `${downloadArchivePath}.zip`;
+    const binaryPath = path.join(downloadArchivePath, binaryPaths[platform]);
+
+    if (await fs.pathExists(binaryPath)) {
+        return binaryPath;
+    }
+    if (!(await fs.pathExists(downloadedZipFile))) {
+        const downloadSpinner = ora('Downloading Chromium').start();
+        try {
+            await fs.mkdirp(DOWNLOAD_CHROME_FOLDER);
+            await downloadAndSave(downloadUrl, downloadedZipFile);
+            // todo - We can add a failover here if the download fails if we host the file too
+        } catch (e) {
+            const errorMessage = `Failed to download Chromium: ${e.message}`;
+            downloadSpinner.fail(errorMessage);
+            throw new Error(errorMessage);
+        }
+        downloadSpinner.succeed();
+    }
+    const extractSpinner = ora('Extracting Chromium').start();
+    try {
+        await unzipFile(downloadedZipFile, DOWNLOAD_CHROME_FOLDER);
+    } catch (e) {
+        const errorMessage = `Failed to extract Chromium: ${e.message}`;
+        extractSpinner.fail(errorMessage);
+        throw new Error(errorMessage);
+    }
+    extractSpinner.succeed();
+    return binaryPath;
+}
+
+module.exports = {
+    CHROMIUM_VERSION,
+    downloadAndInstallChromium,
+};

package/cli.js

@@ -11,6 +11,7 @@ const { onExit, ignoreFailingTestsInExitCode } = require('./cli/onExit');
 const testRunner = require('./runner');
 const prepareRunner = require('./commons/prepareRunner');
 const { CLI_MODE } = require('./commons/constants');
+const { updateRemoteRunFailure } = require('./commons/testimServicesApi');
 const prepareRunnerAndTestimStartUtils = require('./commons/prepareRunnerAndTestimStartUtils');
 
 const {
@@ -21,7 +22,6 @@ const {
 
 const utils = require('./utils');
 const semver = require('semver');
-const Promise = require('bluebird');
 const perf = require('./commons/performance-logger');
 const agentMode = require('./cliAgentMode');
 
@@ -35,19 +35,19 @@ async function checkNodeVersion() {
         throw new ArgError(`Required node version ${version} not satisfied with current version ${process.version}`);
     }
 
-    const [major, minor, patch] = process.version.split('.');
-    // all good
-    if (major !== 'v12') {
-        return;
+    const majorVersion = Number(process.version.replace('v', '').split('.')[0]);
+    const dateHasPassed = new Date('2022-08-01T00:00:00.000Z') <= new Date();
+
+    if (majorVersion < 14 && dateHasPassed) {
+        throw new ArgError('Testim.io CLI supports Node.js 14 and above, please upgrade to a newer Node.js version');
     }
 
-    const minorParsed = Number(minor);
-    if (minorParsed < 20) {
-        console.log('\x1b[33m%s\x1b[0m', 'Testim.io CLI will stop supporting Node.js < 12.20 on March 1st 2022, please upgrade to a newer Node.js version');
+    if (majorVersion < 14) {
+        console.log('\x1b[33m%s\x1b[0m', 'Testim.io CLI will stop supporting Node.js < 14 on August 1st 2022, please upgrade to a newer Node.js version');
     }
 }
 
-function main() {
+async function main() {
     console.log('Starting Testim.io CLI');
     perf.log('Starting Testim.io CLI');
     require('./processHandler')(onExit);
@@ -57,91 +57,93 @@ function main() {
         process.exit(1);
     });
 
-    return Promise.try(() => options.process())
-        .log('in main, after options.process')
-        .tap(options => {
-            require('./commons/logger').setProxyUri(global.proxyUri);
-            if (options.parallel && options.parallel > 5) {
-                EventEmitter.defaultMaxListeners = options.parallel * 2;
-            }
-            require('./commons/logger').setProjectId(options.project);
-            require('./commons/runnerFileCache').setEncryptKey(typeof options.token === 'string' ? options.token : 'anonymous_encrypt_key');
-        })
-        .then(async (options) => {
-            if (options.initCodimMode) {
-                const codimCli = require('./codim/codim-cli');
-                return codimCli.init(options.initTestProject);
-            }
-            if (options.loginMode) {
-                return undefined;
-            }
-            if (options.createPrefechedData) {
-                const runnerFileCache = require('./commons/runnerFileCache');
-                await runnerFileCache.clear();
-                await prepareRunner.initializeUserWithAuth(options);
-                await require('./commons/preloadTests').preloadTests(options);
-                if (!options.playerRequirePath && options.mode !== CLI_MODE.EXTENSION) {
-                    await prepareRunnerAndTestimStartUtils.preparePlayer(options.playerLocation, options.canary);
-                }
-                const res = await runnerFileCache.waitForSave();
-                if (res.success) {
-                    console.log(`created prefeched data at ${runnerFileCache.getCacheFileLocation()}`);
-                } else {
-                    console.error('failed to create prefech data', res.error);
-                }
-                return undefined;
-            }
-
-            if (options.tunnelOnlyMode) {
-                await testRunner.init(options);
-                await require('./commons/testimTunnel').serveTunneling(options);
-                return undefined;
-            }
-
-            if (agentMode.shouldStartAgentMode(options)) {
-                return agentMode.runAgentMode(options);
+    try {
+        const processedOptions = await options.process();
+        perf.log('in main, after options.process');
+        require('./commons/logger').setProxyUri(global.proxyUri);
+        if (processedOptions.parallel && processedOptions.parallel > 5) {
+            EventEmitter.defaultMaxListeners = processedOptions.parallel * 2;
+        }
+        require('./commons/logger').setProjectId(processedOptions.project);
+        require('./commons/runnerFileCache').setEncryptKey(typeof processedOptions.token === 'string' ? processedOptions.token : 'anonymous_encrypt_key');
+
+        if (processedOptions.initCodimMode) {
+            const codimCli = require('./codim/codim-cli');
+            return codimCli.init(processedOptions.initTestProject);
+        }
+        if (processedOptions.loginMode) {
+            return undefined;
+        }
+        if (processedOptions.createPrefechedData) {
+            const runnerFileCache = require('./commons/runnerFileCache');
+            await runnerFileCache.clear();
+            await prepareRunner.initializeUserWithAuth(processedOptions);
+            await require('./commons/preloadTests').preloadTests(processedOptions);
+            if (!processedOptions.playerRequirePath && processedOptions.mode !== CLI_MODE.EXTENSION) {
+                await prepareRunnerAndTestimStartUtils.preparePlayer(processedOptions.playerLocation, processedOptions.canary);
             }
-
-            if (options.saveRCALocally) {
-                const { port } = await require('./services/localRCASaver').initServer(options);
-                options.localRCASaver = `http://localhost:${port}`;
-            }
-
-            if (options.exitCodeIgnoreFailingTests) {
-                ignoreFailingTestsInExitCode();
+            const res = await runnerFileCache.waitForSave();
+            if (res.success) {
+                console.log(`created prefeched data at ${runnerFileCache.getCacheFileLocation()}`);
+            } else {
+                console.error('failed to create prefech data', res.error);
             }
-
-            perf.log('right before testRunner.init/prepareRunner.prepare');
-            return Promise.all([
-                testRunner.init(options),
-                prepareRunner.prepare(options),
-            ])
-                .log('right after testRunner.init/prepareRunner.prepare')
-                .then(([init, customExtensionLocalLocation]) => testRunner.run(options, customExtensionLocalLocation));
-        })
-        .catch(NoArgsError, () => {
+            return undefined;
+        }
+
+        if (processedOptions.tunnelOnlyMode) {
+            await testRunner.init(processedOptions);
+            await require('./commons/testimTunnel').serveTunneling(processedOptions);
+            return undefined;
+        }
+
+        if (agentMode.shouldStartAgentMode(processedOptions)) {
+            return agentMode.runAgentMode(processedOptions);
+        }
+
+        if (processedOptions.saveRCALocally) {
+            const { port } = await require('./services/localRCASaver').initServer(processedOptions);
+            processedOptions.localRCASaver = `http://localhost:${port}`;
+        }
+
+        if (processedOptions.exitCodeIgnoreFailingTests) {
+            ignoreFailingTestsInExitCode();
+        }
+
+        perf.log('right before testRunner.init/prepareRunner.prepare');
+        const [customExtensionLocalLocation] = await Promise.all([
+            prepareRunner.prepare(processedOptions),
+            testRunner.init(processedOptions),
+        ]);
+        perf.log('right after testRunner.init/prepareRunner.prepare');
+        return await testRunner.run(processedOptions, customExtensionLocalLocation);
+    } catch (err) {
+        if (err instanceof NoArgsError) {
             // display help by default
-        })
-        .catch(ArgError, err => {
+            return undefined;
+        }
+        const argsForRemoteRunFailure = utils.getArgsOnRemoteRunFailure();
+        if (argsForRemoteRunFailure) {
+            await updateRemoteRunFailure({ ...argsForRemoteRunFailure, error: err.message }).catch(() => { /* */ });
+        }
+        if (err instanceof ArgError) {
             console.log('Argument Error:', err.message);
             return err;
-        })
-        .catch(SeleniumError, err => {
+        }
+        if (err instanceof SeleniumError) {
             console.log('Selenium Error:', err.message);
             return err;
-        })
-        .catch(err => {
-            console.log('Error:', err.message);
-            logger.error('runner ended with unexpected error', { err });
-            return err;
-        })
-        .then(result => {
-            if (Array.isArray(result) && result.length === 0) {
-                console.log('No tests ran');
-            }
-            onExit(result);
-        });
+        }
+        console.log('Error:', err.message);
+        logger.error('runner ended with unexpected error', { err });
+        return err;
+    }
 }
 
-main();
+main().then(result => {
+    if (Array.isArray(result) && result.length === 0) {
+        console.log('No tests ran');
+    }
+    onExit(result);
+});
 

package/cliAgentMode.js

@@ -4,26 +4,23 @@
 'use strict';
 
 const path = require('path');
-const os = require('os');
 const fs = require('fs-extra');
 const ms = require('ms');
 const WebSocket = require('ws');
 const Bluebird = require('bluebird');
 const ChromeLauncher = require('chrome-launcher');
-const httpRequest = require('./commons/httpRequest');
 const config = require('./commons/config');
 const { ArgError } = require('./errors');
 const lazyRequire = require('./commons/lazyRequire');
 const prepareUtils = require('./commons/prepareRunnerAndTestimStartUtils');
-const { unzipFile } = require('./utils');
-const { downloadAndSave } = require('./utils');
+const { downloadAndSave, unzipFile, getCdpAddressForHost, TESTIM_BROWSER_DIR } = require('./utils');
 const ora = require('ora');
+const { downloadAndInstallChromium, CHROMIUM_VERSION } = require('./chromiumInstaller');
+
 
 const LOG_LEVEL = config.WEBDRIVER_DEBUG ? 'verbose' : 'silent';
 const EXTENSION_CACHE_TIME = ms('1h');
-const HOMEDIR = os.homedir();
-const TESTIM_BROWSER_PROFILES_CONTAINER = path.join(HOMEDIR, '.testim-browser-profile');
-const USER_DATA_DIR = path.join(TESTIM_BROWSER_PROFILES_CONTAINER, 'profile');
+const USER_DATA_DIR = path.join(TESTIM_BROWSER_DIR, 'profile');
 
 // https://github.com/bayandin/chromedriver/blob/5013f2124888c50fff15dc2ff8287288f780b046/chrome_launcher.cc#L105
 const CHOMEDRIVER_DEVTOOLS_ACTIVE_PORT_FILENAME = 'DevToolsActivePort';
@@ -111,84 +108,37 @@ function getStartedWithStart() {
     return startedWithStart;
 }
 
-function getCurrentPlatform() {
-    const osType = os.type().toLowerCase();
-    if (osType === 'darwin') {
-        return os.arch() === 'arm' ? 'mac_arm' : 'mac';
-    }
-    if (osType === 'windows_nt') {
-        return os.arch() === 'x64' ? 'win64' : 'win32';
+function isPidRunning(pid) {
+    try {
+        return process.kill(pid, 0);
+    } catch {
+        return false;
     }
-    return 'linux';
 }
-async function downloadAndInstallChrome(platform, revision, saveLocation) {
-    // Inspired by puppeteer's implementation https://github.com/puppeteer/puppeteer/blob/main/src/node/BrowserFetcher.ts#L45
-    // example download url: https://storage.googleapis.com/chromium-browser-snapshots/Mac/1000968/chrome-mac.zip
-    const storageBaseUrl = 'https://storage.googleapis.com/chromium-browser-snapshots';
-    const platformFolder = {
-        linux: 'Linux_x64',
-        mac: 'Mac',
-        mac_arm: 'Mac_Arm',
-        win32: 'Win',
-        win64: 'Win_x64',
-    };
-    if (!(platform in platformFolder)) {
-        throw new ArgError(`Unsupported platform: ${platform}`);
-    }
-    // Windows archive name changed at r591479.
-    const winArchiveName = parseInt(revision, 10) > 591479 ? 'chrome-win' : 'chrome-win32';
-    const platformArchiveName = {
-        linux: 'chrome-linux',
-        mac: 'chrome-mac',
-        mac_arm: 'chrome-mac',
-        win32: winArchiveName,
-        win64: winArchiveName,
-    };
-    const binaryPaths = {
-        linux: 'chrome',
-        mac: 'Chromium.app/Contents/MacOS/Chromium',
-        mac_arm: 'Chromium.app/Contents/MacOS/Chromium',
-        win32: 'chrome.exe',
-        win64: 'chrome.exe',
+
+async function startFixedVersionChromium(options, extensionBase64, downloadedExtensionPathUnzipped) {
+    const CHROMIUM_PROCESS_INFO_FILE = path.join(TESTIM_BROWSER_DIR, `chrome-${CHROMIUM_VERSION}-process`);
+    const CHECK_CHROMIUM_RUNNING_INTERVAL = 3000;
+
+    const onBrowserClosed = () => {
+        fs.removeSync(CHROMIUM_PROCESS_INFO_FILE);
+        // eslint-disable-next-line no-console
+        console.log('\n\nBrowser session ended');
+        process.exit(0);
     };
-    const downloadUrl = `${storageBaseUrl}/${platformFolder[platform]}/${revision}/${platformArchiveName[platform]}.zip`;
-    const downloadArchivePath = path.join(saveLocation, platformArchiveName[platform]);
-    const downloadedZipFile = `${downloadArchivePath}.zip`;
-    const binaryPath = path.join(downloadArchivePath, binaryPaths[platform]);
 
-    if (await fs.pathExists(binaryPath)) {
-        return binaryPath;
-    }
-    if (!(await fs.pathExists(downloadedZipFile))) {
-        const downloadSpinner = ora('Downloading Chromium').start();
-        try {
-            await fs.mkdirp(saveLocation);
-            await downloadAndSave(downloadUrl, downloadedZipFile);
-            // todo - We can add a failover here if the download fails if we host the file too
-        } catch (e) {
-            const errorMessage = `Failed to download Chromium: ${e.message}`;
-            downloadSpinner.fail(errorMessage);
-            throw new Error(errorMessage);
+
+    if (fs.existsSync(CHROMIUM_PROCESS_INFO_FILE)) {
+        const processInfo = fs.readJSONSync(CHROMIUM_PROCESS_INFO_FILE);
+        if (isPidRunning(processInfo.pid)) { // if a previous instance of our browser is still running, use it and exit if it does
+            const monitorPidForExit = () => (isPidRunning(processInfo.pid) ? setTimeout(monitorPidForExit, CHECK_CHROMIUM_RUNNING_INTERVAL) : onBrowserClosed());
+            monitorPidForExit();
+            return {
+                webdriverApi: processInfo,
+            };
         }
-        downloadSpinner.succeed();
     }
-    const extractSpinner = ora('Extracting Chromium').start();
-    try {
-        await unzipFile(downloadedZipFile, saveLocation);
-    } catch (e) {
-        const errorMessage = `Failed to extract Chromium: ${e.message}`;
-        extractSpinner.fail(errorMessage);
-        throw new Error(errorMessage);
-    }
-    extractSpinner.succeed();
-    return binaryPath;
-}
-
-async function startFixedVersionBrowser(options, extensionBase64, downloadedExtensionPathUnzipped) {
-    const CHROME_VERSION = '1000968';
-    const DOWNLOAD_CHROME_FOLDER = path.join(TESTIM_BROWSER_PROFILES_CONTAINER, `chrome-${CHROME_VERSION}`);
-
-    const chromeBinary = await downloadAndInstallChrome(getCurrentPlatform(), CHROME_VERSION, DOWNLOAD_CHROME_FOLDER);
+    const chromeBinary = await downloadAndInstallChromium();
 
     if (!(await fs.pathExists(USER_DATA_DIR))) {
         await fs.mkdirp(USER_DATA_DIR);
@@ -210,12 +160,12 @@ async function startFixedVersionBrowser(options, extensionBase64, downloadedExte
     };
     const appUrl = `${options.extensionPath ? 'http://localhost:3000/app/' : 'https://app.testim.io'}?startMode=true`;
     const chrome = await ChromeLauncher.launch({ chromeFlags, startingUrl: appUrl, ignoreDefaultFlags: true, userDataDir: USER_DATA_DIR, chromePath: chromeBinary, envVars });
-    const onBrowserClosed = () => process.exit(0);
-
+    const processInfo = { port: chrome.port, pid: chrome.pid, cdpUrl: await getCdpAddressForHost(`localhost:${chrome.port}`) };
+    fs.writeJSONSync(CHROMIUM_PROCESS_INFO_FILE, processInfo);
     chrome.process.once('exit', onBrowserClosed);
     chrome.process.once('close', onBrowserClosed);
     return {
-        webdriverApi: chrome,
+        webdriverApi: processInfo,
     };
 }
 
@@ -226,8 +176,8 @@ async function startTestimStandaloneBrowser(options) {
     const fullExtensionUrl = `${config.EDGE_URL}/extension/testim-full-master.zip`;
     const extensionFilename = path.basename(fullExtensionUrl);
 
-    const downloadedExtensionPath = path.join(TESTIM_BROWSER_PROFILES_CONTAINER, extensionFilename);
-    const downloadedExtensionPathUnzipped = path.join(TESTIM_BROWSER_PROFILES_CONTAINER, `${extensionFilename}__unzipped__`);
+    const downloadedExtensionPath = path.join(TESTIM_BROWSER_DIR, extensionFilename);
+    const downloadedExtensionPathUnzipped = path.join(TESTIM_BROWSER_DIR, `${extensionFilename}__unzipped__`);
 
     let shouldDownloadExtension = !(options.ext || options.extensionPath);
 
@@ -236,7 +186,7 @@ async function startTestimStandaloneBrowser(options) {
         const stat = await fs.stat(downloadedExtensionPath);
         shouldDownloadExtension = (Date.now() - EXTENSION_CACHE_TIME > stat.mtimeMs);
     }
-    await fs.mkdirp(TESTIM_BROWSER_PROFILES_CONTAINER);
+    await fs.mkdirp(TESTIM_BROWSER_DIR);
 
     if (shouldDownloadExtension) {
         const spinner = ora('Downloading Testim Editor').start();
@@ -268,7 +218,7 @@ async function startTestimStandaloneBrowser(options) {
 
     const extensionBase64 = options.extensionPath ? null : (await fs.readFile(options.ext || downloadedExtensionPath)).toString('base64');
     if (options.downloadBrowser) {
-        return await startFixedVersionBrowser(options, extensionBase64, downloadedExtensionPathUnzipped);
+        return await startFixedVersionChromium(options, extensionBase64, downloadedExtensionPathUnzipped);
     }
     await prepareUtils.prepareChromeDriver(
         { projectId: options.project },
@@ -301,9 +251,8 @@ async function startTestimStandaloneBrowser(options) {
     // save the initial URL we navigated to so we don't consider it the AuT
     webdriverApi.initialUrl = appUrl;
     try {
-        //TODO(Benji) do we want this to be exactly getCdpAddress or should this fail less gracefully indicating the agent did not start correctly?
-        const debuggerAddress = await httpRequest.get(`http://${webdriverInitResponse.value['goog:chromeOptions'].debuggerAddress}/json/version`);
-        webdriverApi.cdpUrl = debuggerAddress.webSocketDebuggerUrl;
+        //TODO(Benji) do we want this to be exactly getCdpAddressForHost or should this fail less gracefully indicating the agent did not start correctly?
+        webdriverApi.cdpUrl = await getCdpAddressForHost(webdriverInitResponse.value['goog:chromeOptions'].debuggerAddress);
     } catch (e) {
         // ignore error
     }
@@ -392,31 +341,7 @@ async function readAndValidateChromedriverDevToolsActivePortFile() {
         throw new Error('invalid devtools browser url');
     }
 
-    let webSocketDebuggerUrl;
-    try {
-        /**
-example response
-
- {
-   "Browser": "Chrome/81.0.4044.138",
-   "Protocol-Version": "1.3",
-   "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36",
-   "V8-Version": "8.1.307.32",
-   "WebKit-Version": "537.36 (@8c6c7ba89cc9453625af54f11fd83179e23450fa)",
-   "webSocketDebuggerUrl": "ws://localhost:58938/devtools/browser/d4290379-ec08-4d03-a41a-ab9d9d4c36ac"
-}
- */
-        ({ webSocketDebuggerUrl } = await httpRequest.get(
-            `http://localhost:${port}/json/version`,
-            undefined,
-            undefined,
-            // short timeout, as we try to connect to localhost
-            100
-        ));
-    } catch (e) {
-        throw new Error('unable to connect to devtools http server');
-    }
-
+    const webSocketDebuggerUrl = await getCdpAddressForHost(`localhost:${port}`, 500);
     // invariant check
     if (!webSocketDebuggerUrl.endsWith(browserCDPURLLine)) {
         throw new Error('invariant webSocketDebuggerUrl miss match');

package/commons/getSessionPlayerRequire.js

@@ -21,7 +21,8 @@ const testimAppDataFolder = getSessionPlayerFolder();
         stepParamBuilder: typeof import('../../../clickim/src/common/stepParamsBuilder').StepParamsBuilder;
         stepParamExpressionEvaluator: import('../../../clickim/src/common/stepParamExpressionEvaluator');
         manifestVersion: string | undefined;
-        EyeSdkBuilder: typeof import('../../../clickim/src/background/eyeSdkBuilder').EyeSdkBuilder
+        EyeSdkBuilder: typeof import('../../../clickim/src/background/eyeSdkBuilder').EyeSdkBuilder;
+        sfdc: typeof import('sfdc-engine');
     }}
  */
 const sessionPlayer = require(require('path').join(testimAppDataFolder, 'sessionPlayer.js')); // eslint-disable-line import/no-dynamic-require

package/commons/prepareRunner.js

@@ -10,6 +10,7 @@ const Ajv = require('ajv');
 const prepareRunnerAndTestimStartUtils = require('./prepareRunnerAndTestimStartUtils');
 const mockNetworkRuleFileSchema = require('./mockNetworkRuleFileSchema.json');
 const { initializeUserWithAuth } = require('./initializeUserWithAuth');
+const { downloadAndInstallChromium } = require('../chromiumInstaller');
 
 const MAX_RULE_FILE_SIZE_IN_MB = 1;
 const PREPARE_MOCK_NETWORK_ERROR_PREFIX = 'JSON file supplied to --mock-network-pattern';
@@ -30,6 +31,7 @@ async function prepare(options) {
     const hasNoGrid = !options.host && !options.gridId && !options.grid && (!options.testPlan || options.testPlan.length === 0);
     const isTdkRun = options.files.length !== 0;
     if ((hasNoGrid && isTdkRun) || options.useLocalChromeDriver) {
+        options.chromeBinaryLocation = options.downloadBrowser ? await downloadAndInstallChromium() : options.chromeBinaryLocation;
         chromedriverPromise = prepareRunnerAndTestimStartUtils.prepareChromeDriver(
             { projectId: options.project, userId: options.user },
             { chromeBinaryLocation: options.chromeBinaryLocation },

package/commons/testimServicesApi.js

@@ -476,6 +476,10 @@ function deleteCloudflareTunnel(companyId, tunnelId) {
     }
 }
 
+function updateRemoteRunFailure(body) {
+    return httpRequest.post({ url: `${config.SERVICES_HOST}/result/remoteRunFailure`, body });
+}
+
 module.exports = {
     getS3Artifact,
     getTestPlan,
@@ -511,4 +515,5 @@ module.exports = {
     getCloudflareTunnel,
     forceUpdateCloudflareTunnelRoutes,
     deleteCloudflareTunnel,
+    updateRemoteRunFailure,
 };