@testim/testim-cli 3.244.0 → 3.247.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/chromedriverWrapper.js

@@ -1,10 +1,11 @@
 /* eslint-disable no-console */
 
 const fkill = require('fkill');
+const pRetry = require('p-retry');
 
 const httpRequest = require('./httpRequest');
 const npmWrapper = require('./npmWrapper');
-const { getCliLocation, runWithRetries } = require('../utils');
+const { getCliLocation } = require('../utils');
 const { requireWithFallback } = require('./requireWithFallback');
 
 const PACKAGE_NAME = 'chromedriver';
@@ -40,7 +41,7 @@ const start = async () => {
 
 const isReady = async ({ chromeBinaryLocation }) => {
     // 100 tries, every 30ms
-    await runWithRetries(async () => {
+    await pRetry(async () => {
         const statusResponse = await httpRequest.get(`${DRIVER_BASE_URL}/status`);
         if (!statusResponse || !statusResponse.value || !statusResponse.value.ready) {
             throw new Error('status failed');
@@ -59,7 +60,7 @@ const isReady = async ({ chromeBinaryLocation }) => {
             throw new Error('create session failed');
         }
         await httpRequest.delete(`${DRIVER_BASE_URL}/session/${sessionResponse.sessionId}`);
-    }, 100, 30);
+    }, { retries: 100, minTimeout: 30 });
 };
 
 module.exports = {

package/commons/featureFlags.js

@@ -45,6 +45,7 @@ class FeatureFlagsService {
             warnOnBadNetwork: new Rox.Flag(false),
             overrideAzureStorageUrl: new Rox.Flag(),
             useJsInputCodeInSafari: new Rox.Flag(),
+            useJsInputCodeInFirefox: new Rox.Flag(),
             autoSaveDownloadFileFireFox: new Rox.Flag(true),
             safariSelectOptionDispatchEventOnSelectElement: new Rox.Flag(true),
             experimentalPreCodeCompilation: new Rox.Flag(true),

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/httpRequestCounters.test.js

@@ -1,5 +1,5 @@
+const pRetry = require('p-retry');
 const { makeCounters } = require('./httpRequestCounters');
-const { runWithRetries } = require('../utils');
 const { rejects, doesNotReject, strictEqual } = require('assert');
 
 describe('the http request counters', () => {
@@ -8,29 +8,29 @@ describe('the http request counters', () => {
         wrapWithMonitoring = makeCounters();
     });
 
-    it('Marks an always failing network as unhealthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
+    it('marks an always failing network as unhealthy', async () => {
+        const fn = pRetry(wrapWithMonitoring(() => { throw new Error('bad network'); }), { retries: 30, minTimeout: 0, maxTimeout: 0 });
         await rejects(fn);
         strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
     });
 
-    it('Marks an unstable network as unhealthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
-        const fn2 = runWithRetries(wrapWithMonitoring(() => 'hello'), 20, 1);
+    it('marks an unstable network as unhealthy', async () => {
+        const fn = pRetry(wrapWithMonitoring(() => { throw new Error('bad network'); }), { retries: 30, minTimeout: 0, maxTimeout: 0 });
+        const fn2 = pRetry(wrapWithMonitoring(() => 'hello'), { retries: 20, minTimeout: 0, maxTimeout: 0 });
         await rejects(fn);
         await doesNotReject(fn2);
         strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
     });
 
-    it('Marks a trivial amount of failed requests as healthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
+    it('marks a trivial amount of failed requests as healthy', async () => {
+        const fn = pRetry(wrapWithMonitoring(() => { throw new Error('bad network'); }), { retries: 30, minTimeout: 0, maxTimeout: 0 });
         await rejects(fn);
         const fn2 = wrapWithMonitoring(() => 'hello');
         await Promise.all(Array(290).fill().map(fn2));
         strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);
     });
 
-    it('Marks a healthy network as healthy', async () => {
+    it('marks a healthy network as healthy', async () => {
         const fn2 = wrapWithMonitoring(() => 'hello');
         await Promise.all(Array(200).fill().map(fn2));
         strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);