@testim/testim-cli 3.235.0 → 3.238.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.235.0",
+  "version": "3.238.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{

package/player/stepActions/inputFileStepAction.js

@@ -4,7 +4,7 @@ const StepAction = require('./stepAction');
 const _ = require('lodash');
 const logger = require('../../commons/logger').getLogger('input-file-step-action');
 const { codeSnippets, utils } = require('../../commons/getSessionPlayerRequire');
-const { extractElementId } = require('../../utils');
+const { extractElementId, download } = require('../../utils');
 const inputFileUtils = require('../../inputFileUtils');
 const featureFlagService = require('../../commons/featureFlags');
 
@@ -41,18 +41,15 @@ class InputFileStepAction extends StepAction {
     }
 
     async uploadFilesAndForceVisibility(gridLocalFiles, target) {
-        const preUploadStep = this.driver.isSafari() ?
-            // in safari we force the visibility ahead of time because making it visible the second time around doesn't work
-            this.safariPreUploadActions(target) :
-            Promise.resolve();
-
         try {
-            await preUploadStep;
+            if (this.driver.isSafari()) {
+                await this.safariPreUploadActions(target);
+            }
             await this.uploadFiles(gridLocalFiles, target);
         } catch (err) {
             const edgeErrorEditableMessage = 'The element is not editable';
             const edgeErrorFocusableMessage = 'The element is not focusable';
-            const safariErrorVisibleMessege = 'An element command could not be completed because the element is not visible on the page.';
+            const safariErrorVisibleMessage = 'An element command could not be completed because the element is not visible on the page.';
             const elementNotInteractable = 'element not interactable';
             const elementNotPointerOrKeyboardInteractable = 'element is not pointer- or keyboard interactable';
             const invalidStateMsg = 'invalid element state: Element is not currently interactable and may not be manipulated';
@@ -64,7 +61,7 @@ class InputFileStepAction extends StepAction {
                 _.startsWith(errorMsg, mustBeVisibleMsg) ||
                 _.startsWith(errorMsg, edgeErrorEditableMessage) ||
                 _.startsWith(errorMsg, edgeErrorFocusableMessage) ||
-                _.startsWith(errorMsg, safariErrorVisibleMessege) ||
+                _.startsWith(errorMsg, safariErrorVisibleMessage) ||
                 _.includes(errorMsg, notReachableByKeyboard) ||
                 _.includes(errorMsg, elementNotInteractable) ||
                 _.includes(errorMsg, elementNotPointerOrKeyboardInteractable)
@@ -88,9 +85,18 @@ class InputFileStepAction extends StepAction {
     async performAction() {
         const target = this.context.data[this.step.targetId || 'targetId'];
         const overrideAzureStorageUrl = featureFlagService.flags.overrideAzureStorageUrl.isEnabled();
-
-        const fileUrls = await utils.addTokenToFileUrl(this.context.project.id, this.step.fileUrls, this.stepActionUtils.testimServicesApi, overrideAzureStorageUrl, logger);
         const useJsInputCodeInSafari = featureFlagService.flags.useJsInputCodeInSafari.isEnabled();
+        const downloadToBase64 = featureFlagService.flags.downloadToBase64.isEnabled();
+
+        let fileUrls = await utils.addTokenToFileUrl(this.context.project.id, this.step.fileUrls, this.stepActionUtils.testimServicesApi, overrideAzureStorageUrl, logger);
+
+        if (downloadToBase64) {
+            fileUrls = await Promise.all(fileUrls.map(async ({ name, url }) => {
+                const res = await download(url);
+                return { name, url: `data:${res.type};base64,${Buffer.from(res.body).toString('base64')}` };
+            }));
+        }
+
         if (this.driver.isSafari() && (useJsInputCodeInSafari || fileUrls.length > 1)) {
             await this.driver.executeJSWithArray(`
                 const getLocatedElement = ${codeSnippets.getLocatedElementCode};
@@ -165,15 +171,18 @@ function downloadAndUpload() {
             return new File([blob], name, { type: blob.type });
         }));
 
-        fileList.item = function(ind) { return this[ind]; };
+        const dt = new DataTransfer();
+        for (const file of fileList) {
+            dt.items.add(file);
+        }
+        element.files = dt.files;
+
         let changeWasFired = false;
         const changeFiredHandler = (e) => {
             changeWasFired = true;
         };
 
         element.addEventListener("change", changeFiredHandler, true);
-        Reflect.deleteProperty(element, 'files');
-        Reflect.defineProperty(element, 'files', { get() { return fileList; }, configurable: true });
         await Promise.resolve(); // wait microtick
         element.dispatchEvent(new Event("input", { bubbles: true }));
         if (!changeWasFired) {

package/player/stepActions/textValidationStepAction.js

@@ -1,5 +1,6 @@
 "use strict";
 
+
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 
 const StepAction = require('./stepAction');
@@ -7,6 +8,7 @@ const constants = sessionPlayer.commonConstants.stepResult;
 const paramEvaluator = sessionPlayer.stepParamExpressionEvaluator;
 const utils = sessionPlayer.utils;
 
+
 const Promise = require('bluebird');
 
 class TextValidationStepAction extends StepAction {
@@ -15,6 +17,7 @@ class TextValidationStepAction extends StepAction {
         var context = this.context;
         var target = this.getTarget();
         var frameHandler = this.frameHandler;
+        
 
         return new Promise(resolve => {
             var onFail = resultInfo => {

package/player/webdriver.js

@@ -59,6 +59,7 @@ class WebDriver extends WebDriverApi {
         this.cdpUrl = undefined;
         this.browserClosedCallbacks = [];
         this.browserClosedFailedKeepAlives = 0;
+        this.ignoreHiddenTagsText = false;
     }
 
     registerToClosedBrowser(callback) {
@@ -71,6 +72,7 @@ class WebDriver extends WebDriverApi {
 
     async init(browserOptions, testName, testRunConfig, gridInfo, customExtensionLocalLocation, executionId, testResultId, seleniumPerfStats = new SeleniumPerfStats(), fastInit = false, lambdatestService) {
         this.browserClosedFailedKeepAlives = 0;
+        this.ignoreHiddenTagsText = _(browserOptions).get('company.activePlan.premiumFeatures.ignoreHiddenTagsText');
         this.browserClosedCallbacks = [];
         const capabilities = desiredCapabilitiesBuilder.buildSeleniumOptions(browserOptions, testName, testRunConfig, gridInfo, customExtensionLocalLocation, executionId, testResultId, lambdatestService);
         if (capabilities.desiredCapabilities) {
@@ -330,7 +332,7 @@ class WebDriver extends WebDriverApi {
     }
 
     getElementTextJS(locatedElement) {
-        function extractTextCode(locatedElement) {
+        function extractTextCode(locatedElement, ignoreHiddenTagsText) {
             // copy of utils.getElementTextContent to run inside content script
             // sadly .children doesn't work for SVG elements in IE11
             function clearTitleTags(node) {
@@ -360,7 +362,15 @@ class WebDriver extends WebDriverApi {
                         return element.shadowRoot.textContent.replace(/(\r\n|\n|\r)/gm, "");
                     }
                 } catch (err) { }
-                return element.textContent.replace(/(\r\n|\n|\r)/gm, "");
+                if (ignoreHiddenTagsText && Array.prototype.some.call(element.children, function (elem) { return elem.hidden; })) {
+                    var dupElement = element.cloneNode(true);
+                    var hiddenChildren = Array.prototype.filter.call(dupElement.children, function (elem) { return elem.hidden; });
+                    hiddenChildren.forEach(function (child) { 
+                        dupElement.removeChild(child);
+                    });
+                    return dupElement.textContent.replace(/(\r\n|\n|\r)/gm, '');
+                }
+                return element.textContent.replace(/(\r\n|\n|\r)/gm, '');
             }
 
             function getElementTextContent(element) {
@@ -390,7 +400,7 @@ class WebDriver extends WebDriverApi {
             var getLocatedElement = ${codeSnippets().getLocatedElementCode};
             var extractText = ${extractTextCode.toString()};
             return extractText.apply(null, arguments)
-        `, locatedElement)
+        `, locatedElement, this.ignoreHiddenTagsText)
             .then(result => result.value);
     }
 

package/runOptions.js

@@ -187,6 +187,8 @@ program
     .option('--token [token]', 'identification token to testim')
     .option('--is-regression-baseline-run', 'save doms and run results as regression baseline data')
     .option('--parallel [number-of-tests]', 'number of tests to run on parallel')
+    .option('--before-parallel [number-of-tests]', 'number of tests to run on parallel in the before phase of a test plan')
+    .option('--after-parallel [number-of-tests]', 'number of tests to run on parallel in the after phase of a test plan')
     .option('--canary [canary-mode]', 'enable canary mode', false)
     .option('--test-plan [test-plan-name]', 'test plan to run', collect, [])
     .option('--test-plan-id [test-plan-id]', 'test plan to run', collect, [])
@@ -322,6 +324,7 @@ program
     // Agent mode
     .option('connect, --agent [enable-agent-mode]', 'enable Testim CLI agent mode', false)
     .option('start [enable-start]', 'Connect to testim and open the editor in a standalone browser', false)
+    .option('--download-browser', 'when used with the start option, downloads a fixed version to run Testim editor in', false)
     .option('--agent-port [agent-port]', 'set agent port', Number, 42543)
     .option('--agent-bind [agent-host-bind]', 'set agent host bind', '127.0.0.1')
 
@@ -761,7 +764,9 @@ module.exports = {
 
         const timeoutWasGiven = Boolean(program.timeout);
         program.timeout = !program.timeout || typeof program.timeout === 'boolean' ? 10 * 60 * 1000 : Number(program.timeout);
+        program.beforeParallel = !program.beforeParallel || typeof program.beforeParallel === 'boolean' ? 1 : Number(program.beforeParallel);
         program.parallel = !program.parallel || typeof program.parallel === 'boolean' ? 1 : Number(program.parallel);
+        program.afterParallel = !program.afterParallel || typeof program.afterParallel === 'boolean' ? 1 : Number(program.afterParallel);
 
 
         if (program.parallel > 1 && program.run && !program.gridId && !program.grid &&
@@ -816,10 +821,18 @@ module.exports = {
             throw new ArgError('test run timeout could not be a negative number, --timeout <run-timeout>');
         }
 
+        if (program.beforeParallel <= 0 || _.isNaN(program.beforeParallel)) {
+            throw new ArgError('before-parallel could not be a negative number or not number, --before-parallel <number-of-tests>');
+        }
+
         if (program.parallel <= 0 || _.isNaN(program.parallel)) {
             throw new ArgError('parallel could not be a negative number or not number, --parallel <number-of-tests>');
         }
 
+        if (program.afterParallel <= 0 || _.isNaN(program.afterParallel)) {
+            throw new ArgError('after-parallel could not be a negative number or not number, --after-parallel <number-of-tests>');
+        }
+
         if (![CLI_MODE.EXTENSION, CLI_MODE.SELENIUM].includes(program.mode)) {
             throw new ArgError(`runner mode <${program.mode}> is not supported`);
         }
@@ -865,6 +878,10 @@ module.exports = {
             );
         }
 
+        if (!isTestPlanSpecified && (program.beforeParallel !== 1 || program.afterParallel !== 1)) {
+            throw new ArgError('cannot set --before-parallel or --after-parallel without --test-plan option');
+        }
+
         if (
             (program.testId.length ||
                 isTestPlanSpecified ||
@@ -1088,7 +1105,9 @@ module.exports = {
             mode: program.mode,
             isRegressionBaselineRun: program.isRegressionBaselineRun,
             browser: program.browser,
+            beforeParallel: program.beforeParallel,
             parallel: program.parallel,
+            afterParallel: program.afterParallel,
             canary: program.canary,
             rerunFailedByRunId: program.rerunFailedByRunId,
             disableGridCheck: program.disableGridCheck,

package/runOptionsAgentFlow.js

@@ -5,12 +5,16 @@
 const { ArgError } = require('./errors');
 const _ = require('lodash');
 const runOptionsUtils = require('./runOptionsUtils');
+const analytics = require('./commons/testimAnalytics');
 
 /**
  *
  * @param {import("commander").CommanderStatic} program
  */
 function isAgentFlow(program) {
+    if (program.start) {
+        analytics.track(null, 'cli-start-command', { downloadBrowser: Boolean(program.downloadBrowser) });
+    }
     if (program.startV2 || program.start || program.agent) {
         return true;
     }
@@ -73,6 +77,7 @@ async function runAgentFlow(program) {
         canary: program.canary,
         playerPath: program.playerPath,
         playerRequirePath: program.playerRequirePath,
+        downloadBrowser: Boolean(program.downloadBrowser),
     };
 }
 

package/runner.js

@@ -25,7 +25,6 @@ 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');
 
@@ -269,7 +268,7 @@ async function init(options) {
         await labFeaturesService.loadLabFeatures(projectById.id, companyByProjectId.activePlan);
     }
 
-    if (options.lightweightMode && options.lightweightMode.type === 'turboMode' && (featureFlagService.flags.highSpeedMode.getValue() === 'disabled' || options.company.planType === 'free')) {
+    if (options.lightweightMode && options.lightweightMode.type === 'turboMode' && (featureFlags.flags.highSpeedMode.getValue() === 'disabled' || options.company.planType === 'free')) {
         delete options.lightweightMode;
     }
 

package/runners/ParallelWorkerManager.js

@@ -8,7 +8,6 @@ const config = require('../commons/config');
 const ExecutionQueue = require('../executionQueue');
 
 const testimCustomToken = require('../commons/testimCustomToken');
-const testimServicesApi = require('../commons/testimServicesApi');
 const labFeaturesService = require('../services/labFeaturesService');
 const perf = require('../commons/performance-logger');
 const { StopRunOnError } = require('../errors');
@@ -51,6 +50,8 @@ class ParallelWorkerManager {
             return undefined;
         }
 
+        let stoppedOnError = false;
+        let runningTests = 0;
         const runAndWaitToComplete = token => new Promise((resolve, reject) => {
             const projectId = options.project;
             const executionQueue = new ExecutionQueue(executionId, executionName, testList, options, branchToUse, testStatus);
@@ -69,6 +70,7 @@ class ParallelWorkerManager {
             const sessionType = utils.getSessionType(options);
 
             const onTestStarted = (wid, testId, resultId, isRerun, testRetryKey) => {
+                runningTests++;
                 analyticsService.analyticsTestStart({
                     authData,
                     executionId,
@@ -89,6 +91,7 @@ class ParallelWorkerManager {
             };
 
             const onTestCompleted = async (wid, testId, testResult, sessionId, isRerun) => {
+                runningTests--;
                 const update = {};
                 if (lightweightMode && lightweightMode.onlyTestIdsNoSuite) {
                     update.show = true;
@@ -151,11 +154,11 @@ class ParallelWorkerManager {
                     isStartUp,
                 });
                 if (stopOnError && !testResult.success) {
-                    reject(new StopRunOnError());
-                    throw new StopRunOnError();
+                    executionQueue.stop();
+                    stoppedOnError = true;
                 }
                 const completedTests = Object.keys(combinedTestResults).length;
-                if (completedTests === testCount) {
+                if (completedTests === testCount || (stoppedOnError && runningTests === 0)) {
                     resolve(combinedTestResults);
                     return undefined;
                 }
@@ -165,8 +168,9 @@ class ParallelWorkerManager {
             const onTestIgnored = (wid, testResult) => {
                 combinedTestResults[testResult.resultId] = testResult;
                 testStatus.onTestIgnored(wid, testResult.resultId);
+                runningTests--;
                 const completedTests = Object.keys(combinedTestResults).length;
-                if (completedTests === testCount) {
+                if (completedTests === testCount || (stoppedOnError && runningTests === 0)) {
                     resolve(combinedTestResults);
                 }
             };
@@ -196,7 +200,11 @@ class ParallelWorkerManager {
 
         try {
             const token = await testimCustomToken.getCustomTokenV3();
-            return await runAndWaitToComplete(token);
+            const result = await runAndWaitToComplete(token);
+            if (stoppedOnError) {
+                throw new StopRunOnError();
+            }
+            return result;
         } catch (err) {
             logger.error('failed running parallel workers', { executionId, err });
             throw err;

package/runners/TestPlanRunner.js

@@ -20,7 +20,6 @@ const { getSuite, calcTestResultStatus, validateConfig } = require('./runnerUtil
 const { StopRunOnError, ArgError } = require('../errors');
 const Logger = require('../commons/logger');
 const perf = require('../commons/performance-logger');
-const featureFlags = require('../commons/featureFlags');
 
 const guid = utils.guid;
 const logger = Logger.getLogger('test-plan-runner');
@@ -35,14 +34,14 @@ class TestPlanRunner {
         const executionResults = {};
         const authData = testimCustomToken.getTokenV3UserData();
 
-        const runBeforeTests = (beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData) => {
-            const workerCount = 1;
+        const runBeforeTests = () => {
+            const workerCount = tpOptions.beforeParallel || 1;
             const stopOnError = true;
             return this.workerManager.runTests(beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError)
                 .then(beforeTestsResults => Object.assign(executionResults, beforeTestsResults));
         };
 
-        const runTestPlanTests = (tests, testStatus, executionId, executionName, tpOptions, branchToUse, authData) => {
+        const runTestPlanTests = () => {
             const workerCount = config.TESTIM_CONCURRENT_WORKER_COUNT || tpOptions.parallel;
             const stopOnError = false;
             perf.log('right before this.workerManager.runTests');
@@ -51,30 +50,30 @@ class TestPlanRunner {
                 .then(testsResults => Object.assign(executionResults, testsResults));
         };
 
-        const runAfterTests = (afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData) => {
-            const workerCount = 1;
+        const runAfterTests = () => {
+            const workerCount = tpOptions.afterParallel || 1;
             const stopOnError = false;
             return this.workerManager.runTests(afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError)
                 .then(afterTestsResults => Object.assign(executionResults, afterTestsResults));
         };
 
-        function catchBeforeTestsFailed(executionId) {
+        function catchBeforeTestsFailed() {
             return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
         }
 
         const sessionType = utils.getSessionType(tpOptions);
         analyticsService.analyticsExecsStart({ authData, executionId, projectId: tpOptions.project, sessionType });
         perf.log('right before runBeforeTests');
-        return runBeforeTests(beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData)
+        return runBeforeTests()
             .log('right before runTestPlanTests')
-            .then(() => runTestPlanTests(tests, testStatus, executionId, executionName, tpOptions, branchToUse, authData))
+            .then(() => runTestPlanTests())
             .log('right after runTestPlanTests')
-            .then(() => runAfterTests(afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData))
+            .then(() => runAfterTests())
             .then(() => executionResults)
             .catch(err => {
                 logger.error('error running test plan', { err });
                 if (err instanceof StopRunOnError) {
-                    return catchBeforeTestsFailed(executionId);
+                    return catchBeforeTestsFailed();
                 }
                 throw err;
             })

package/services/lambdatestService.js

@@ -1,13 +1,12 @@
 const os = require('os');
-const { spawn } = require('child_process');
+const childProcess = require('child_process');
 const Promise = require('bluebird');
 const fse = require('fs-extra');
 const portfinder = require('portfinder');
 const ms = require('ms');
 
-const {
-    downloadAndSave, unzipFile, guid, runWithRetries, isURL,
-} = require('../utils');
+const { guid, isURL } = require('../utils');
+const utils = require('../utils');
 const { gridTypes, CLI_MODE } = require('../commons/constants');
 const httpRequest = require('../commons/httpRequest');
 const { ArgError } = require('../errors');
@@ -86,8 +85,8 @@ class LambdatestService {
             throw new Error(`tunnel on ${os.platform() + os.arch()} platform is not supported.`);
         }
         const zipLocation = `${LT_TUNNEL_BINARY_DIRECTORY}.zip`;
-        await downloadAndSave(`${LT_TUNNEL_BINARY_ORIGIN}/${downloadUrl}`, zipLocation);
-        await unzipFile(zipLocation, LT_TUNNEL_BINARY_DIRECTORY);
+        await utils.downloadAndSave(`${LT_TUNNEL_BINARY_ORIGIN}/${downloadUrl}`, zipLocation);
+        await utils.unzipFile(zipLocation, LT_TUNNEL_BINARY_DIRECTORY);
     }
 
     static async connectTunnel(runnerOptions) {
@@ -140,7 +139,7 @@ class LambdatestService {
             tunnelArgs = [...tunnelArgs, '--mitm'];
         }
 
-        LambdatestService.tunnel = spawn('./LT', tunnelArgs, { cwd: LT_TUNNEL_BINARY_DIRECTORY });
+        LambdatestService.tunnel = childProcess.spawn('./LT', tunnelArgs, { cwd: LT_TUNNEL_BINARY_DIRECTORY });
 
         let stdoutResult = '';
         let stderrResult = '';
@@ -155,7 +154,7 @@ class LambdatestService {
 
         // verify that LT tunnel strated successfully
         try {
-            const ltInfo = await runWithRetries(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), 30, 2000);
+            const ltInfo = await utils.runWithRetries(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), 30, 2000);
             logger.info('LT tunnel info', ltInfo);
         } catch (err) {
             logger.error('Failed to start LT tunnel', { err, stdoutResult, stderrResult });
@@ -170,7 +169,7 @@ class LambdatestService {
         return new Promise((resolve, reject) => {
             LambdatestService.tunnel.on('close', (code) => {
                 if (code) {
-                    reject();
+                    reject(new Error(`tunnel process exited with code ${code}`));
                 }
                 resolve();
             });