@testim/testim-cli 3.244.0 → 3.245.0

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/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);

package/commons/npmWrapper.js

@@ -78,7 +78,7 @@ async function installPackageLocally(rootPath, packageName, execOptions) {
         } catch (err) {
             // ignore error
         }
-        return await exec(`npm i ${packageName} --no-save --no-package-lock --no-prune --prefer-offline --no-audit --legacy-peer-deps --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
+        return await exec(`npm i ${packageName} --no-save --no-prune --prefer-offline --no-audit --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
             const pathWithMissingPermissions = getPathWithMissingPermissions(err);
             const npmEightMissingPermissions = npmSevenAndEightMissingPermissions(err);
             if (pathWithMissingPermissions || npmEightMissingPermissions) {
@@ -110,7 +110,7 @@ Testim had missing write access to ${pathWithMissingPermissions || rootPath}
     }
 }
 
-const localNpmLocation = path.resolve(require.resolve('npm').replace('index.js',''), 'bin','npm-cli.js');
+const localNpmLocation = path.resolve(require.resolve('npm').replace('index.js', ''), 'bin', 'npm-cli.js');
 
 function installPackages(prefix, packageNames, proxyUri, timeoutMs) {
     return new Promise((resolve, reject) => {
@@ -121,7 +121,7 @@ function installPackages(prefix, packageNames, proxyUri, timeoutMs) {
         let stdout = '';
         let stderr = '';
 
-        const ops = '--no-save --no-package-lock --no-prune --prefer-offline --no-audit --legacy-peer-deps --progress=false'.split(' ');
+        const ops = '--no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false'.split(' ');
         const npmInstall = spawn('node', [localNpmLocation, 'i', '--prefix', prefix, ...ops, ...packageNames, ...proxyFlag], envVars);
         npmInstall.stderr.pipe(process.stderr);
         npmInstall.stdout.pipe(process.stdout);

package/commons/npmWrapper.test.js

@@ -54,7 +54,7 @@ describe('npmWrapper', () => {
                 fakeChildProcess.exec.yields(undefined, []); //resolve without errors
                 const cwd = '/some/dir';
                 const pkg = 'some-package';
-                const expectedCmd = 'npm i some-package --no-save --no-package-lock --no-prune --prefer-offline --no-audit --legacy-peer-deps --progress=false';
+                const expectedCmd = 'npm i some-package --no-save --no-prune --prefer-offline --no-audit --progress=false';
                 const expectedExecParams = { cwd };
 
                 await npmWrapper.installPackageLocally(cwd, pkg);

package/commons/socket/baseSocketServiceSocketIO.js

@@ -1,9 +1,9 @@
 "use strict";
 
 const Promise = require('bluebird');
+const pRetry = require('p-retry');
 const io = require('socket.io-client');
 const config = require('../config');
-const utils = require('../../utils');
 
 const MAX_SOCKET_RECONNECT_ATTEMPT = 50;
 const MAX_RECONNECT_ATTEMPT_BEFORE_SWITCH = 10;
@@ -163,7 +163,7 @@ class BaseSocketServiceSocketIO {
         };
 
         this.emitPromisQueue = (this.emitPromisQueue || Promise.resolve())
-            .then(() => utils.runWithRetries(emitAndWait, 200, 3000))
+            .then(() => pRetry(emitAndWait, { retries: 200, minTimeout: 3000 }))
             .finally(() => {
                 if (Object.keys(errorneousEvents).length > 0) {
                     logger.error('Bad acknowledge from socket emit', { errorneousEvents });

package/commons/testimServicesApi.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const pako = require('pako');
+const pRetry = require('p-retry');
 const _ = require('lodash');
 const testimCustomToken = require('./testimCustomToken');
 const constants = require('./constants');
@@ -66,13 +67,13 @@ function getWithAuth(url, query, options, timeout) {
 }
 
 function getS3Artifact(url, timeout) {
-    return utils.runWithRetries(() => getWithAuth(`/storage${url}`, null, { isBinary: true }, timeout));
+    return pRetry(() => getWithAuth(`/storage${url}`, null, { isBinary: true }, timeout), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function getTestPlan(projectId, testPlanNames) {
     //TODO: need to be checked after 3 months to prevent users from using old version
     const parseProperty = (dataValue) => (dataValue == null ? [] : (typeof (dataValue) === 'string' && JSON.parse(dataValue)) || dataValue);
-    return utils.runWithRetries(() => getWithAuth('/testPlan', { projectId, name: testPlanNames.join(',') }))
+    return pRetry((() => getWithAuth('/testPlan', { projectId, name: testPlanNames.join(',') }), { retries: DEFAULT_REQUEST_RETRY }))
         .then(body => body.map(testPlan => {
             testPlan.testConfigIds = parseProperty(testPlan.testConfigIds);
             testPlan.beforeAllLabels = parseProperty(testPlan.beforeAllLabels);
@@ -84,20 +85,20 @@ function getTestPlan(projectId, testPlanNames) {
 
 
 function loadTest({ testId, branch, projectId, skipSharedSteps = false, useBranchMap = true }) {
-    return utils.runWithRetries(() => getWithAuth(`/test/${testId}`, {
+    return pRetry(() => getWithAuth(`/test/${testId}`, {
         projectId,
         branch,
         skipSharedSteps,
         useBranchMap,
-    }));
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function saveTestPlanResult(projectId, testPlanId, result) {
-    return utils.runWithRetries(() => postAuth({ url: '/testPlan/result', body: { projectId, testPlanId, result } }));
+    return pRetry(() => postAuth({ url: '/testPlan/result', body: { projectId, testPlanId, result } }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
-function updateTestStatus(projectId, executionId, testId, resultId, status, data, apiRetries = DEFAULT_REQUEST_RETRY) {
-    return utils.runWithRetries(() => putAuth('/result/run/test', {
+function updateTestStatus(projectId, executionId, testId, resultId, status, data, retries = DEFAULT_REQUEST_RETRY) {
+    return pRetry(() => putAuth('/result/run/test', {
         runId: executionId,
         testId,
         resultId,
@@ -105,11 +106,11 @@ function updateTestStatus(projectId, executionId, testId, resultId, status, data
         projectId,
         runnerVersion,
         ...data,
-    }), apiRetries);
+    }), { retries });
 }
 
 function updateExecutionTests(executionId, runnerStatuses, status, reason, success, startTime, endTime, projectId) {
-    return utils.runWithRetries(() => putAuth('/result/run/tests', {
+    return pRetry(() => putAuth('/result/run/tests', {
         runId: executionId,
         runnerStatuses,
         status,
@@ -118,7 +119,7 @@ function updateExecutionTests(executionId, runnerStatuses, status, reason, succe
         startTime,
         endTime,
         projectId,
-    }), DEFAULT_REQUEST_RETRY);
+    }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
 function reportExecutionStarted({
@@ -162,7 +163,7 @@ function reportExecutionStarted({
 function reportExecutionFinished(status, executionId, projectId, success, tmsOptions = {}, remoteRunId, resultExtraData) {
     const endTime = Date.now();
 
-    return utils.runWithRetries(() => putAuth('/result/run', {
+    return pRetry(() => putAuth('/result/run', {
         runId: executionId,
         projectId,
         endTime,
@@ -171,22 +172,22 @@ function reportExecutionFinished(status, executionId, projectId, success, tmsOpt
         tmsOptions,
         remoteRunId,
         resultExtraData,
-    }), DEFAULT_REQUEST_RETRY);
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 async function getTestPlanTestList(projectId, names, planIds, branch, intersections) {
-    return utils.runWithRetries(() => postAuth({
+    return pRetry(() => postAuth({
         url: '/testPlan/list',
         body: { projectId, names, planIds, branch, intersections },
         // people who send insane lists get a timeout :(
         timeout: 120000,
-    }));
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function getSuiteTestList({
     projectId, labels, testIds, testNames, testConfigNames, suiteNames, suiteIds, branch, rerunFailedByRunId, testConfigIds, intersections,
 }) {
-    return utils.runWithRetries(() => postAuth({
+    return pRetry(() => postAuth({
         url: '/suite/v2/list',
         body: {
             projectId,
@@ -201,11 +202,11 @@ function getSuiteTestList({
             testConfigIds,
             intersections,
         },
-    }));
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function getUsageForCurrentBillingPeriod(projectId) {
-    return utils.runWithRetries(() => getWithAuth(`/plan/project/${projectId}/usage-current-billing-period`))
+    return pRetry(() => getWithAuth(`/plan/project/${projectId}/usage-current-billing-period`), { reties: DEFAULT_REQUEST_RETRY })
         .catch((error) => {
             logger.error('failed getting usage for current billing period', { projectId, error });
             return undefined;
@@ -213,11 +214,11 @@ function getUsageForCurrentBillingPeriod(projectId) {
 }
 
 function isTestResultCompleted(resultId, projectId, testRetryKey) {
-    return utils.runWithRetries(() => getWithAuth(`/result/${resultId}/isComplete`, { projectId, testRetryKey }));
+    return pRetry(() => getWithAuth(`/result/${resultId}/isComplete`, { projectId, testRetryKey }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function getTestResults(testId, resultId, projectId, branch) {
-    return utils.runWithRetries(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }));
+    return pRetry(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function keepAliveGrid(projectId, slots) {
@@ -245,19 +246,19 @@ function getHybridGridProvider(body) {
 }
 
 function getGridByName(companyId, projectId, gridName, browser, executionId) {
-    return utils.runWithRetries(() => getWithAuth('/grid/name', {
+    return pRetry(() => getWithAuth('/grid/name', {
         companyId, projectId, name: gridName, browser, executionId, reqId: utils.guid(),
-    }));
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function getGridById(companyId, projectId, gridId, browser, executionId) {
-    return utils.runWithRetries(() => getWithAuth(`/grid/${gridId}`, { companyId, projectId, browser, executionId, reqId: utils.guid() }));
+    return pRetry(() => getWithAuth(`/grid/${gridId}`, { companyId, projectId, browser, executionId, reqId: utils.guid() }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 
 async function initializeUserWithAuth({ projectId, token, branchName, lightweightMode, localGrid }) {
     try {
-        return await utils.runWithRetries(() => httpRequest.post({
+        return await pRetry(() => httpRequest.post({
             url: `${config.SERVICES_HOST}/executions/initialize`,
             body: {
                 projectId,
@@ -266,7 +267,7 @@ async function initializeUserWithAuth({ projectId, token, branchName, lightweigh
                 lightweightMode,
                 localGrid,
             },
-        }));
+        }), { reties: DEFAULT_REQUEST_RETRY });
     } catch (e) {
         logger.error('error initializing info from server', e);
         if (e && e.message && e.message.includes('Bad Request')) {
@@ -288,7 +289,7 @@ async function getEditorUrl() {
         return config.EDITOR_URL;
     }
     try {
-        return await utils.runWithRetries(() => getWithAuth('/system-info/editor-url'));
+        return await pRetry(() => getWithAuth('/system-info/editor-url'), { reties: DEFAULT_REQUEST_RETRY });
     } catch (err) {
         logger.error('cannot retrieve editor-url from server');
         return 'https://app.testim.io';
@@ -296,20 +297,20 @@ async function getEditorUrl() {
 }
 
 function getAllGrids(companyId) {
-    return utils.runWithRetries(() => getWithAuth('/grid', { companyId }));
+    return pRetry(() => getWithAuth('/grid', { companyId }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
-const fetchLambdatestConfig = async () => utils.runWithRetries(() => getWithAuth('/grid/lt/config'));
+const fetchLambdatestConfig = async () => pRetry(() => getWithAuth('/grid/lt/config'), { reties: DEFAULT_REQUEST_RETRY });
 
-const getLabFeaturesByProjectId = async (projectId) => utils.runWithRetries(() => getWithAuth(`/labFeature/v2/project/${projectId}`));
+const getLabFeaturesByProjectId = async (projectId) => pRetry(() => getWithAuth(`/labFeature/v2/project/${projectId}`), { reties: DEFAULT_REQUEST_RETRY });
 
 
 function getRealData(projectId, channel, query) {
-    return utils.runWithRetries(() => getWithAuth(`/real-data/${channel}?${query}&projectId=${projectId}`));
+    return pRetry(() => getWithAuth(`/real-data/${channel}?${query}&projectId=${projectId}`), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function updateTestResult(projectId, resultId, testId, testResult, remoteRunId) {
-    return utils.runWithRetries(() => postAuth({
+    return pRetry(() => postAuth({
         url: '/result/test',
         body: {
             projectId,
@@ -318,11 +319,11 @@ function updateTestResult(projectId, resultId, testId, testResult, remoteRunId)
             testResult,
             remoteRunId,
         },
-    }));
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function clearTestResult(projectId, resultId, testId, testResult) {
-    return utils.runWithRetries(() => postAuth({
+    return pRetry(() => postAuth({
         url: '/result/test/clear',
         body: {
             projectId,
@@ -330,11 +331,11 @@ function clearTestResult(projectId, resultId, testId, testResult) {
             testId,
             testResult,
         },
-    }));
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function saveRemoteStep(projectId, resultId, stepId, remoteStep) {
-    return utils.runWithRetries(() => postAuth({
+    return pRetry(() => postAuth({
         url: '/remoteStep',
         body: {
             projectId,
@@ -342,7 +343,7 @@ function saveRemoteStep(projectId, resultId, stepId, remoteStep) {
             stepId,
             remoteStep,
         },
-    }));
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 function relativize(uri) {
@@ -381,9 +382,9 @@ function uploadArtifact(projectId, testId, testResultId, content, subType, mimeT
         },
     };
 
-    return utils.runWithRetries(() => postAuthFormData(`/storage${storagePath}`, {}, files, {
+    return pRetry(() => postAuthFormData(`/storage${storagePath}`, {}, files, {
         'X-Asset-Encoding': 'gzip',
-    })).then(() => storagePath);
+    }), { reties: DEFAULT_REQUEST_RETRY }).then(() => storagePath);
 }
 
 const uploadRunDataArtifact = _.memoize(async (projectId, testId, testResultId, runData) => {
@@ -422,7 +423,7 @@ function addTestRetry({
     previousTestResultId,
     testResult,
 }) {
-    return utils.runWithRetries(() => postAuth({
+    return pRetry(() => postAuth({
         url: '/result/test/retry',
         body: {
             projectId,
@@ -433,7 +434,7 @@ function addTestRetry({
             runId,
             testResult,
         },
-    }), DEFAULT_REQUEST_RETRY);
+    }), { reties: DEFAULT_REQUEST_RETRY });
 }
 
 /**

package/errors.js

@@ -1,3 +1,4 @@
+const { AbortError } = require('p-retry');
 /**
  * NoArgsError - throws when arguments not passed to cli
  *
@@ -57,7 +58,7 @@ class GetBrowserError extends Error {
     }
 }
 
-class PageNotAvailableError extends Error {
+class PageNotAvailableError extends AbortError {
 }
 
 class QuotaDepletedError extends Error { }