@testim/testim-cli 3.213.0 → 3.217.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,7 +18,7 @@ const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
 const { preloadTests } = require('./commons/preloadTests');
 
 const RETRIES_ON_TIMEOUT = 3;
-const MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE = 50 * 1000; // max size, in characters, of stringified run data sent over URL params. Chosen arbitrarily, this value should be changed according to data.
+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) {
@@ -181,8 +181,9 @@ TestRun.prototype.getRunRequestParams = async function () {
         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 (lightweight mode). Run data size: ${JSON.stringify(runData).length} (limit: ${MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE} characters)`);
+            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);
     }
@@ -203,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) {

package/workers/WorkerExtension.js

@@ -110,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,29 +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)
-            .catch(err => {
-                reporter.onGetBrowserFailure(workerId, projectId, ++failedAttempts);
-                throw err;
-            })
-            .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}));
-            });
-        });
-    });
-}