@testim/testim-cli 3.212.0 → 3.216.0

package/runner.js

@@ -25,6 +25,7 @@ const FREE_PLAN_MINIMUM_BROWSER_TIMEOUT = 30 * 60 * 1000;
 const TestPlanRunner = require('./runners/TestPlanRunner');
 const labFeaturesService = require('./services/labFeaturesService');
 const featureAvailabilityService = require('./commons/featureAvailabilityService');
+const featureFlagService = require('./commons/featureFlags');
 
 const logger = require('./commons/logger').getLogger('runner');
 
@@ -268,12 +269,12 @@ async function init(options) {
         await labFeaturesService.loadLabFeatures(projectById.id, companyByProjectId.activePlan);
     }
 
-    if (options.lightweightMode && options.lightweightMode.type === 'highSpeed' && (!labFeaturesService.isFeatureAvailableForProject('highSpeedMode') || options.company.planType === 'free')) {
+    if (options.lightweightMode && options.lightweightMode.type === 'turboMode' && (featureFlagService.flags.highSpeedMode.getValue() === 'disabled' || options.company.planType === 'free')) {
         delete options.lightweightMode;
     }
 
-    if (options.lightweightMode && options.lightweightMode.type === 'highSpeed') {
-        console.log('High-speed mode will ignore step delays. Test artifacts like screenshots and logs will only be saved for failed runs. For more information see our docs: https://help.testim.io/docs/high-speed-mode');
+    if (options.lightweightMode && options.lightweightMode.type === 'turboMode') {
+        console.log('\nTurbo mode will ignore step delays. Test artifacts like screenshots and logs will only be saved for failed runs. For more information see our docs: https://help.testim.io/docs/turbo-mode');
     }
 
     gridService.keepAlive.start(project);

package/services/lambdatestService.js

@@ -180,6 +180,7 @@ class LambdatestService {
 
         const defaultBrowserCaps = LambdatestService.lambdatestConfig.CAPABILITIES[browser] || {};
 
+
         const tunnelCaps = {};
         if (LambdatestService.tunnelName) {
             tunnelCaps.tunnel = true;

package/testRunHandler.js

@@ -18,6 +18,8 @@ const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
 const { preloadTests } = require('./commons/preloadTests');
 
 const RETRIES_ON_TIMEOUT = 3;
+const MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE = 20 * 1000; // max size, in characters, of stringified run data sent over URL params. Chosen arbitrarily, this value should be changed according to data.
+const canSendRunDataOverUrl = (runData) => JSON.stringify(runData).length < MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE;
 
 const TestRun = function (executionId, executionName, test, options, branchToUse, testRunStatus) {
     this._executionId = executionId;
@@ -175,7 +177,14 @@ TestRun.prototype.getRunRequestParams = async function () {
 
     if (this._options.lightweightMode && this._options.lightweightMode.general) {
         runRequestParams.company = this._options.company;
-        runRequestParams.runData = this.getRunData();
+        const runData = this.getRunData();
+        runRequestParams.lightweightMode.isRunDataSentInUrl = canSendRunDataOverUrl(runData);
+        if (runRequestParams.lightweightMode.isRunDataSentInUrl) {
+            runRequestParams.runData = runData;
+            logger.info(`Run data sent as URL param, test id: ${this.getTestId()} run data length: ${JSON.stringify(runData).length}`);
+        } else {
+            logger.warn(`Run data is too big to be sent as a URL param. Test id: ${this.getTestId()}, run data size: ${JSON.stringify(runData).length} (limit: ${MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE} characters)`);
+        }
         runRequestParams.isLocalRun = Boolean(this._options.useLocalChromeDriver || this._options.useChromeLauncher);
     }
 
@@ -195,9 +204,11 @@ TestRun.prototype.getRunRequestParams = async function () {
     return runRequestParams;
 };
 
-TestRun.prototype.getRunTestUrl = function () {
-    return this.getRunRequestParams()
-        .then(runRequestParams => `https://run.testim.io/?params=${encodeURIComponent(JSON.stringify(runRequestParams))}`);
+TestRun.prototype.getRunTestUrl = async function () {
+    const runRequestParams = await this.getRunRequestParams();
+    const url = `https://run.testim.io/?params=${encodeURIComponent(JSON.stringify(runRequestParams))}`;
+    logger.info(`Test (${this.getTestId()}) run URL length: ${url.length}`);
+    return url;
 };
 
 TestRun.prototype.setSessionId = function (sessionId) {
@@ -240,7 +251,7 @@ TestRun.prototype.clearTestResult = function () {
     const mustClearPreviousStepResults = !this.isAllowReportTestResultRetries() && (this._timeoutRetryCount > 1 || this._retryCount > 1);
 
     if (this._options.lightweightMode && this._options.lightweightMode.disableResults &&
-        !mustClearPreviousStepResults) {
+            !mustClearPreviousStepResults && canSendRunDataOverUrl(runData)) {
         return Promise.resolve();
     }
 

package/workers/BaseWorker.js

@@ -8,7 +8,7 @@ const { timeoutMessages, testRunStatus, stepResult, runnerTestStatus } = require
 const logger = require('../commons/logger').getLogger('base-worker');
 const testResultService = require('../commons/socket/testResultService');
 const remoteStepService = require('../commons/socket/remoteStepService');
-const { isNetworkHealthy } = require('../commons/httpRequest');
+const { isNetworkHealthy, didNetworkConnectivityTestFail } = require('../commons/httpRequest');
 const testimServicesApi = require('../commons/testimServicesApi');
 const gridService = require('../services/gridService');
 const LambdatestService = require('../services/lambdatestService');
@@ -264,13 +264,14 @@ class BaseWorker {
                 return undefined;
             }
         };
+        const getNetworkErrorMessage = () => 'Due to network connectivity issues, Testim CLI has been unable to connect to the grid.\n' +
+                                             `Please make sure the CLI has stable access to the internet. ${didNetworkConnectivityTestFail() ? '(Internal: network connectivity test failed)' : ''}`;
 
-        const buildError = (err) => {
-            if (!isNetworkHealthy() && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
+        const buildError = (err, wasNetworkHealthy) => {
+            if (!wasNetworkHealthy && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
                 return {
                     errorType: NETWORK_ERROR,
-                    reason: 'Due to network connectivity issues, Testim CLI has been unable to connect to the grid.' +
-                        'Please make sure the CLI has stable access to the internet.',
+                    reason: getNetworkErrorMessage(),
                 };
             }
 
@@ -324,17 +325,16 @@ class BaseWorker {
         };
 
         const onRunError = async (err, testRunHandler) => {
-            if (!isNetworkHealthy() && featureFlags.flags.warnOnBadNetwork.isEnabled()) {
+            const wasNetworkHealthy = await isNetworkHealthy();
+            if (!wasNetworkHealthy && featureFlags.flags.warnOnBadNetwork.isEnabled()) {
                 // intentional, we want to log to stderr:
                 // eslint-disable-next-line no-console
-                console.warn('Due to network connectivity issues, Testim CLI has been unable to connect to the grid.');
-                // eslint-disable-next-line no-console
-                console.warn('Please make sure the CLI has stable access to the internet.');
+                console.warn(getNetworkErrorMessage());
             }
             logger.warn('error on run', { err });
 
             const projectId = this.userData && this.userData.projectId;
-            const { errorType, reason } = buildError(err);
+            const { errorType, reason } = buildError(err, wasNetworkHealthy);
             testimServicesApi.updateTestResult(projectId, this.testResultId, this.testId, {
                 status: testRunStatus.COMPLETED,
                 success: false,

package/workers/WorkerExtension.js

@@ -87,7 +87,10 @@ class WorkerExtension extends BaseWorker {
                 .then(url => {
                     reporter.onWaitToTestStart(this.id);
                     return Promise.all([
-                        driver.url(url).tap(() => { startStausDetails.driverUrlFinished = true; }).tapCatch(err => logger.error('error from driver.url', { err, testResultId, executionId, testId })),
+                        driver.url(url).tap(() => { startStausDetails.driverUrlFinished = true; }).catch(err => {
+                            logger.error('error from driver.url', { err, testResultId, executionId, testId, url, urlLength: url.length });
+                            throw err;
+                        }),
                         testRunHandler.onStarted(TEST_START_TIMEOUT_MS).tap(() => { startStausDetails.testRunHandlerStartedFinished = true; }),
                     ])
                         .timeout(TEST_START_TIMEOUT_MS, timeoutMessages.TEST_START_TIMEOUT_MSG)
@@ -107,14 +110,11 @@ class WorkerExtension extends BaseWorker {
                     };
                     driver.registerToClosedBrowser(onBrowserClosed);
                     return testRunHandler.onCompleted().timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
-                        .tap(testResult => {
+                        .then(async testResult => {
                             driver.unregisterToClosedBrowser(onBrowserClosed);
                             if (this.lambdatestService.isLambdatestRun()) {
-                                return driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => {});
+                                await driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => { });
                             }
-                            return undefined;
-                        })
-                        .then(testResult => {
                             if (!driver.isAlive()) {
                                 logger.warn(`possible grid unresponsive for test ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
                                 testResult.gridIssues = 'could not validate grid is alive';

package/workers/WorkerSelenium.js

@@ -168,13 +168,10 @@ class WorkerSelenium extends BaseWorker {
                     }
                     throw err;
                 })
-                .tap(() => {
+                .then(async testResult => {
                     if (sessionPlayerInit.localAssetService) {
-                        return sessionPlayerInit.localAssetService.drain();
+                        await sessionPlayerInit.localAssetService.drain();
                     }
-                    return undefined;
-                })
-                .then(testResult => {
                     testResult.stepsResults = null;
                     testResult.resultId = this.testResultId;
                     if (!driver.isAlive()) {
@@ -187,13 +184,11 @@ class WorkerSelenium extends BaseWorker {
                         logger.warn(`possible browser keep alive issue ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
                         testResult.keepAliveIssue = maxKeepAliveGap;
                     }
-                    return { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
-                })
-                .tap(testResult => {
+                    const resultWithStats = { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
                     if (this.lambdatestService.isLambdatestRun()) {
-                        return driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => { });
+                        await driver.executeJS(`lambda-status=${!resultWithStats.success ? 'failed' : 'passed'}`).catch(() => { });
                     }
-                    return Promise.resolve();
+                    return resultWithStats;
                 });
         }
 

package/workers/workerUtils.js

@@ -1,19 +1,6 @@
 const Promise = require('bluebird');
-const utils = require('../utils');
 const gridService = require('../services/gridService');
 const logger = require('../commons/logger').getLogger('worker-utils');
-const { timeoutMessages } = require('../commons/constants');
-const { GetBrowserError, PageNotAvailableError } = require('../errors');
-
-const waitUntilBrowserTimeout = (err, startTime, interval, projectId, workerId, player, releaseSlotOnTestFinished) => {
-    logger.warn('failed getting browser from grid', { err });
-    return releasePlayer(workerId, releaseSlotOnTestFinished, projectId, player)
-        .then(() => {
-            const requestTime = Date.now() - startTime;
-            const timeDiff = interval - requestTime;
-            return Promise.delay(timeDiff).then(() => Promise.reject(err));
-        });
-};
 
 const releaseGridSlot = (workerId, releaseSlotOnTestFinished, projectId) => {
     if (!releaseSlotOnTestFinished) {
@@ -29,26 +16,3 @@ const releasePlayer = (workerId, releaseSlotOnTestFinished, projectId, player) =
 };
 
 module.exports.releasePlayer = releasePlayer;
-
-module.exports.getBrowserWithRetries = ({ getBrowserOnce, testPlayerFactory, releaseSlotOnTestFinished }, { totalTimeoutDuration, singleGetBrowserDuration, projectId, workerId, reporter }) => {
-    const maxGetBrowserAttempts = totalTimeoutDuration / singleGetBrowserDuration;
-    let failedAttempts = 0;
-
-    return utils.runWithRetries(() => {
-        const startTime = Date.now();
-        const player = testPlayerFactory();
-        return getBrowserOnce(player)
-            .then((getBrowserRes) => player || getBrowserRes)
-            .timeout(singleGetBrowserDuration, timeoutMessages.GET_BROWSER_TIMEOUT_MSG)
-            .tapCatch(() => reporter.onGetBrowserFailure(workerId, projectId, ++failedAttempts))
-            .tap(() => reporter.onGetBrowserSuccess(workerId, projectId))
-            .catch(err => waitUntilBrowserTimeout(err, startTime, singleGetBrowserDuration, projectId, workerId, player, releaseSlotOnTestFinished));
-    }, maxGetBrowserAttempts).catch(err => {
-        if (err instanceof PageNotAvailableError) {
-            throw err;
-        }
-        throw new GetBrowserError(err);
-    });
-};
-
-module.exports.isGetBrowserError = err => err && err.constructor && err.constructor.name === 'GetBrowserError';

package/agent/routers/cliJsCode/runNpmWorker.js

@@ -1,39 +0,0 @@
-module.exports = function (input) {
-    const {transactionId, packages, command, localPackageInstallFolder, proxyUri} = input;
-    return installLocalPackages(transactionId, packages, command, localPackageInstallFolder, proxyUri);
-};
-
-const path = require('path');
-const npm = require("npm");
-const {NpmPackageError} = require('../../../errors');
-
-function installLocalPackages(transactionId, packages, command, localPackageInstallFolder, proxyUri) {
-    if (!packages || packages.length === 0) {
-        return Promise.resolve();
-    }
-
-    const installFolder = path.join(localPackageInstallFolder, `/${transactionId}`);
-
-    return new Promise((resolve, reject) => {
-        const npmLoadConfig = {
-            prefix: installFolder,
-            loglevel: 'silent',
-        };
-        if(proxyUri) {
-            npmLoadConfig.proxy = proxyUri;
-            npmLoadConfig["https-proxy"] = proxyUri;
-        }
-        npm.load(npmLoadConfig, (err) => {
-            if (err) {
-                return reject(err);
-            }
-
-            npm.commands[command](packages, (installErr, data) => {
-                if (installErr) {
-                    return reject(new NpmPackageError(installErr.message));
-                }
-                resolve(Object.assign({data, installFolder}));
-            });
-        });
-    });
-}