@testim/testim-cli 3.241.0 → 3.244.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.241.0",
+  "version": "3.244.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -47,8 +47,8 @@
     "multer": "1.4.4"
   },
   "dependencies": {
-    "@applitools/eyes-sdk-core": "13.2.0",
-    "@applitools/visual-grid-client": "15.11.0",
+    "@applitools/eyes-sdk-core": "13.6.23",
+    "@applitools/visual-grid-client": "15.12.34",
     "@testim/coralogix-logger": "1.1.27-beta.1",
     "@testim/webdriverio": "0.0.5",
     "abort-controller": "3.0.0",
@@ -116,7 +116,7 @@
     "test": "IS_UNIT_TEST=1 ../../node_modules/mocha/bin/_mocha --timeout 2000  --reporter spec --exit --recursive \"./src/**/*.test.js\" --exclude ./src/codim/template.js/tests/examples/**/*.test.js",
     "test:watch": "IS_UNIT_TEST=1 ../../node_modules/mocha/bin/_mocha --timeout 2000 --exit --recursive \"./src/**/*.test.js\"  --exclude ./src/codim/template.js/tests/examples/**/*.test.js --watch",
     "test:cov": "nyc --reporter=lcov --reporter=text yarn test",
-    "upload-bundle-s3": "scripts/upload.js",
+    "upload-bundle-s3": "ts-node-transpile-only scripts/upload.js",
     "prepare-version": "rm -rf ./deploy && mkdir -p deploy && gulp prepare-version-on-prem",
     "make-onprem-deps": "cp ../../yarn.lock deploy && cd deploy && yarn install --production && bundle-deps",
     "pack-onprem": "yarn prepare-version && yarn make-onprem-deps && cd deploy && npm pack && zip -r testim-cli.zip testim-cli-*.tgz",

package/player/services/playbackTimeoutCalculator.js

@@ -1,12 +1,11 @@
-"use strict";
-var COMMUNICATION_BUFFER_TIME = 1000;
+'use strict';
+
 const _ = require('lodash');
-const logger = require('../../commons/logger').getLogger('playback-timeout-calculator');
 
-let warnedAboutDebugger = false;
+const COMMUNICATION_BUFFER_TIME = 1000;
+const UI_VERIFICATION_STEPS = ['simple-ui-verification', 'wait-for-simple-ui-verification'];
 
 class PlaybackTimeoutCalculator {
-
     constructor(isDebuggerConnected) {
         this.resetStepVariables();
         this.resetRetryVariables();
@@ -18,13 +17,13 @@ class PlaybackTimeoutCalculator {
         this.totalStepTime = totalStepTime || 0;
         this.totalStepTimesReport = [];
         this.currentRetryTimesReport = {};
-        var now = Date.now();
+        const now = Date.now();
         this.currentRetryStart = now;
         this.lastUpdateTime = now;
     }
 
     resetRetryVariables() {
-        var now = Date.now();
+        const now = Date.now();
         this.currentRetryStart = now;
         this.lastUpdateTime = now;
         this.totalStepTimesReport.push(this.currentRetryTimesReport);
@@ -32,7 +31,7 @@ class PlaybackTimeoutCalculator {
     }
 
     initStepRun(stepPlayback) {
-        var getRetryTimeoutSuggestions = (totalStepTime) => {
+        const getRetryTimeoutSuggestions = (totalStepTime) => {
             const timeToPlayStep = this.getTotalStepTimeLeftToPlay(stepPlayback, totalStepTime);
             const MINIMAL_RETRY_TIME = 5000;
             if (timeToPlayStep <= MINIMAL_RETRY_TIME) {
@@ -42,7 +41,7 @@ class PlaybackTimeoutCalculator {
         };
         stepPlayback.setStartTimestamp();
         const totalStepTime = this.getTotalStepRunTime(stepPlayback);
-        var currentRetryTimes = ["simple-ui-verification", "wait-for-simple-ui-verification", "custom-validation"].includes(stepPlayback.stepType) ? [totalStepTime] : getRetryTimeoutSuggestions(totalStepTime);
+        const currentRetryTimes = [...UI_VERIFICATION_STEPS, 'custom-validation'].includes(stepPlayback.stepType) ? [totalStepTime] : getRetryTimeoutSuggestions(totalStepTime);
         this.resetStepVariables(totalStepTime, currentRetryTimes);
         stepPlayback.context.data.maxTotalStepTime = totalStepTime;
     }
@@ -57,9 +56,12 @@ class PlaybackTimeoutCalculator {
     }
 
     getTotalStepRunTime(stepPlayback) {
-        return (stepPlayback.step.useStepTimeout && stepPlayback.step.stepTimeout) ?
-            stepPlayback.step.stepTimeout :
-            stepPlayback.context.config.stepTimeout;
+        const HALF_HOUR_IN_MS = 30 * 60 * 1000;
+        let fallbackTimeout = stepPlayback.context.config.stepTimeout;
+        if (UI_VERIFICATION_STEPS.includes(stepPlayback.stepType)) {
+            fallbackTimeout = stepPlayback.context.config.applitoolsStepTimeout || HALF_HOUR_IN_MS;
+        }
+        return (stepPlayback.step.useStepTimeout && stepPlayback.step.stepTimeout) ? stepPlayback.step.stepTimeout : fallbackTimeout;
     }
     getTotalStepTimeLeftToPlay(stepPlayback, totalStepTime = this.totalStepTime) {
         const playTimeSoFar = Date.now() - stepPlayback.startTimestamp;
@@ -71,7 +73,7 @@ class PlaybackTimeoutCalculator {
             this.getTotalStepTimeLeftToPlay(stepPlayback);
     }
     getTotalCurrentRetryTimeLeft(stepPlayback) {
-        var totalRetryTime = Date.now() - this.currentRetryStart;
+        const totalRetryTime = Date.now() - this.currentRetryStart;
         return this.getCurrentRetryTime(stepPlayback) - totalRetryTime + COMMUNICATION_BUFFER_TIME;
     }
     getTabTimeout(stepPlayback) {
@@ -97,7 +99,6 @@ class PlaybackTimeoutCalculator {
         }
 
         return (stepPlayback.step.events.length * timePerEvent) + buffer;
-
     }
 
     getActionTimeout(stepPlayback) {
@@ -108,10 +109,10 @@ class PlaybackTimeoutCalculator {
         const actionType = stepPlayback.step.type;
         const MIN_ACTION_PLAYBACK_TIME = 30000;
 
-        var actionTime;
-        if (actionType === "sleep") {
+        let actionTime;
+        if (actionType === 'sleep') {
             actionTime = stepPlayback.step.durationMS + SLEEP_ERROR_MARGIN_MS;
-        } else if (actionType === "android-scroll") {
+        } else if (actionType === 'android-scroll') {
             actionTime = Math.max(this.calcAndroidScrollTimeout(stepPlayback), MIN_ACTION_PLAYBACK_TIME);
         } else {
             actionTime = Math.max(this.getTotalStepTimeLeftToPlay(stepPlayback), MIN_ACTION_PLAYBACK_TIME);
@@ -120,34 +121,34 @@ class PlaybackTimeoutCalculator {
     }
 
     setStepPhaseTime(phase) {
-        var now = Date.now();
-        var totalTime = now - this.lastUpdateTime;
+        const now = Date.now();
+        const totalTime = now - this.lastUpdateTime;
         this.lastUpdateTime = now;
         this.currentRetryTimesReport[phase] = totalTime;
     }
 
     reportGetTabTime() {
-        this.setStepPhaseTime("tab");
+        this.setStepPhaseTime('tab');
     }
 
     reportGetFrameTime() {
-        this.setStepPhaseTime("frame");
+        this.setStepPhaseTime('frame');
     }
 
     reportCalcConditionTime() {
-        this.setStepPhaseTime("condition");
+        this.setStepPhaseTime('condition');
     }
 
     reportPreLocateActionsTime() {
-        this.setStepPhaseTime("pre-locate");
+        this.setStepPhaseTime('pre-locate');
     }
 
     reportFindElementsTime() {
-        this.setStepPhaseTime("locate");
+        this.setStepPhaseTime('locate');
     }
 
     reportStepActionTime() {
-        this.setStepPhaseTime("action");
+        this.setStepPhaseTime('action');
     }
 }
 

package/player/stepActions/evaluateExpressionStepAction.js

@@ -1,14 +1,15 @@
-"use strict";
+'use strict';
+
 const Promise = require('bluebird');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 const StepAction = require('./stepAction');
+
 const constants = sessionPlayer.commonConstants.stepResult;
 const { stepParamBuilder } = sessionPlayer;
 const logger = require('../../commons/logger').getLogger('evaluate-expression-step-action');
 const _ = require('lodash');
 
 class EvaluateExpressionStepAction extends StepAction {
-
     execute() {
         const step = this.step;
         const context = this.context;
@@ -25,8 +26,8 @@ class EvaluateExpressionStepAction extends StepAction {
 
                 const params = ['context', ...incomingParams.as.functionParameters];
                 const args = [context, ...incomingParams.as.functionArguments];
-                const expressionToEvaluate = step.subType === "text" ? "'" + step.expression.replace(/'/g, "\\\'") + "'" : step.expression;
-                const code = ("return " + expressionToEvaluate).replace(/\n/g, "\\n");
+                const expressionToEvaluate = step.subType === 'text' ? `'${step.expression.replace(/'/g, "\\\'")}'` : step.expression;
+                const code = (`return ${expressionToEvaluate}`).replace(/\n/g, '\\n');
                 const textEvaluateFunction = Function.apply(Function, params.concat([code]));
                 const evaluatedText = textEvaluateFunction.apply(null, args);
 
@@ -38,8 +39,8 @@ class EvaluateExpressionStepAction extends StepAction {
 
                 const result = {
                     success: true,
-                    evaluatedText: evaluatedText,
-                    data: context.data
+                    evaluatedText,
+                    data: context.data,
                 };
 
                 resolve(result);
@@ -48,7 +49,6 @@ class EvaluateExpressionStepAction extends StepAction {
             }
         });
     }
-
 }
 
 module.exports = EvaluateExpressionStepAction;

package/player/stepActions/scripts/doClick.js

@@ -1,4 +1,6 @@
-"use strict";
+/* globals getLocatedElement, dispatchFocus */
+
+'use strict';
 
 var doClick = function (eventData, done) {
     var eventConstructorSupported = typeof Event === 'function';

package/player/stepActions/scripts/html5dragAction.js

@@ -1,4 +1,6 @@
-"use strict";
+/* global getLocatedElement */
+
+'use strict';
 
 var html5dndAction = function(eventData) {
     var data = {};

package/player/stepActions/scripts/html5dragActionV2.js

@@ -1,4 +1,6 @@
-"use strict";
+/* global getLocatedElement */
+
+'use strict';
 
 var html5dndAction = function (eventData, done) {
     var mouseEventConstructorSupported = typeof MouseEvent === 'function';

package/player/stepActions/scripts/runCode.js

@@ -3,23 +3,40 @@
 'use strict';
 
 const runCode = function (eventData, preCompiledCode) {
+    typeof Object.tstassign !== 'function' && (Object.tstassign = function (n, t) {
+        'use strict';
 
-    "function"!=typeof Object.tstassign&&(Object.tstassign=function(n,t){"use strict";if(null==n)throw new TypeError("Cannot convert undefined or null to object");for(var r=Object(n),e=1;e<arguments.length;e++){var o=arguments[e];if(null!=o)for(var a in o)Object.prototype.hasOwnProperty.call(o,a)&&(r[a]=o[a])}return r});
-    Object.assign = typeof Object.assign !== "function" ? Object.tstassign : Object.assign;
+        if (n == null) throw new TypeError('Cannot convert undefined or null to object'); for (var r = Object(n), e = 1; e < arguments.length; e++) { var o = arguments[e]; if (o != null) for (var a in o)Object.prototype.hasOwnProperty.call(o, a) && (r[a] = o[a]); } return r;
+    });
+    Object.assign = typeof Object.assign !== 'function' ? Object.tstassign : Object.assign;
 
     function appendToStorage(name, data) {
         const sessionItem = 'data-testim-' + name;
+
+        const nativeFuncErrMsg = 'Native sessionStorage is not available';
+        function isNativeFunction(fn) {
+            if (!fn || !fn.toString) {
+                return false;
+            }
+            return fn.toString().indexOf('[native code]') > -1;
+        }
         try {
+            if (![window.sessionStorage.setItem, window.sessionStorage.getItem].every(isNativeFunction)) {
+                throw new Error(nativeFuncErrMsg);
+            }
             const oldData = JSON.parse(window.sessionStorage.getItem(sessionItem) || '{}');
             const newData = Object.tstassign({}, oldData, data);
             window.sessionStorage.setItem(sessionItem, JSON.stringify(newData));
         } catch (err) {
-            // any vernation QuotaExceededError from browsers
+            // any variation QuotaExceededError from browsers
             const isQuotaExceededError = err.message.toLowerCase().indexOf('quota') > -1;
+            const isNativeFunctionError = err.message === nativeFuncErrMsg;
+
             if (err.message.indexOf('sessionStorage') > -1 || // Chrome + Firefox
                 err.message.indexOf('The operation is insecure') > -1 || // Safari
                 err.message.indexOf('SecurityError') > -1 || // Edge
-                isQuotaExceededError
+                isQuotaExceededError ||
+                isNativeFunctionError
             ) {
                 var storage = document.head.querySelector('#testim-storage-backup');
                 if (!storage) {
@@ -30,13 +47,13 @@ const runCode = function (eventData, preCompiledCode) {
                 const oldData = JSON.parse(storage.getAttribute(sessionItem) || '{}');
                 const newData = Object.tstassign({}, oldData, data);
                 storage.setAttribute(sessionItem, JSON.stringify(newData));
-                if (isQuotaExceededError) {
+                if (isQuotaExceededError || isNativeFunctionError) {
                     try {
                         window.sessionStorage.removeItem(sessionItem);
                     } catch (e) {
                         // Prevents future retries from looking in sessionStorage with old data
                     }
-                    window.TSTA.useFallbackStorage = true;
+                    (window.TSTA = window.TSTA || {}).useFallbackStorage = true;
                 }
                 return;
             }

package/player/stepActions/scripts/scroll.js

@@ -1,9 +1,4 @@
-// Disabling the eslint to keep this in a format which works on IE 11.
-/* eslint-disable no-var */
-/* eslint-disable no-redeclare */
-/* eslint-disable object-shorthand */
-/* eslint-disable one-var */
-/* eslint-disable operator-linebreak */
+/* globals getLocatedElement, elementScrollTo */
 
 'use strict';
 

package/player/stepActions/scripts/setText.js

@@ -1,4 +1,7 @@
-"use strict";
+/* globals getLocatedElement, dispatchFocus */
+
+'use strict';
+
 /*global KeyboardEvent */
 var setText = function (eventData, done) {
     var eventConstructorSupported = typeof Event === 'function';

package/processHandler.js

@@ -2,18 +2,18 @@
 
 'use strict';
 
+const Promise = require('bluebird');
 const logger = require('./commons/logger').getLogger('process-handler');
 
 const exitHooks = [];
-const Promise = require('bluebird');
 
-module.exports = function (onExit) {
+module.exports = function (onExit, _process = process) {
     async function cleanup(err) {
         // give cleanup and socket reports a chance to run
         await Promise.all(exitHooks.map(x => x())).timeout(10000).catch(() => {});
         onExit(err);
     }
-    process.on('uncaughtException', async (err) => {
+    _process.on('uncaughtException', async (err) => {
         logger.error('Caught exception', { err });
         console.log('Uncaught exception');
         if (err.message) {
@@ -25,7 +25,7 @@ module.exports = function (onExit) {
         await cleanup(err);
     });
 
-    process.on('unhandledRejection', (reason) => {
+    _process.on('unhandledRejection', (reason) => {
         // rollout manages promises incorrectly and generates unhandled rejections from within their code
         logger.fatal('Caught unhandled promise rejection', reason);
         //TODO(benji) - this is a pretty shitty way to detect this error since rollout can change their API endpoint
@@ -37,11 +37,11 @@ module.exports = function (onExit) {
         throw reason;
     });
 
-    process.on('rejectionHandled', () => {
+    _process.on('rejectionHandled', () => {
         logger.error('Caught rejection handled');
     });
 
-    process.once('SIGTERM', () => {
+    _process.once('SIGTERM', () => {
         const msg = 'Runner aborted - SIGTERM event';
         const err = new Error(msg);
         logger.error(msg);
@@ -49,7 +49,7 @@ module.exports = function (onExit) {
         throw err;
     });
 
-    process.once('SIGINT', () => {
+    _process.once('SIGINT', () => {
         const msg = 'Runner aborted - SIGINT event';
         const err = new Error(msg);
         logger.error(msg);
@@ -58,12 +58,15 @@ module.exports = function (onExit) {
     });
 
     // One time self-call is expected :(
-    process.once('exit', (e) => {
+    _process.once('exit', (e) => {
         onExit(e);
     });
 };
 
-
 module.exports.registerExitHook = function (hook) {
     exitHooks.push(hook);
 };
+
+module.exports.reset = function () {
+    exitHooks.splice(0, exitHooks.length);
+};

package/processHandler.test.js

@@ -0,0 +1,56 @@
+
+const { delay } = require('bluebird');
+const EventEmitter = require('events');
+const { expect, sinon } = require('../test/utils/testUtils');
+const processHandler = require('./processHandler');
+
+
+class Process extends EventEmitter {
+    constructor() {
+        super();
+        this.stdout = new EventEmitter();
+        this.stderr = new EventEmitter();
+    }
+}
+
+describe('testimTunnel', () => {
+    let process;
+    let onExitMock;
+
+    beforeEach(() => {
+        process = new Process();
+        onExitMock = sinon.spy();
+        processHandler(onExitMock, process);
+    });
+
+    afterEach(async () => {
+        await delay(10);
+        expect(onExitMock).to.have.been.calledOnce;
+        processHandler.reset();
+    });
+
+
+    it('should register a SIGTERM handler', (done) => {
+        processHandler.registerExitHook(done);
+        expect(() => process.emit('SIGTERM')).to.throw('Runner aborted - SIGTERM event');
+    });
+    it('should register a SIGINT handler', (done) => {
+        processHandler.registerExitHook(done);
+        expect(() => process.emit('SIGINT')).to.throw('Runner aborted - SIGINT event');
+    });
+    it('should register a unhandledRejection handler', () => {
+        expect(() => process.emit('unhandledRejection', new Error('reason'))).to.throw('reason');
+        onExitMock();
+    });
+    it('should register a uncaughtException handler', (done) => {
+        processHandler.registerExitHook(done);
+        expect(() => process.emit('uncaughtException', new Error())).not.to.throw();
+    });
+    it('should do nothing on rejectionHandled', () => {
+        expect(() => process.emit('rejectionHandled')).not.to.throw();
+        onExitMock();
+    });
+    it('should register a exit handler', () => {
+        expect(() => process.emit('exit')).not.to.throw();
+    });
+});

package/testRunStatus.js

@@ -17,7 +17,6 @@ const { calculateCoverage } = require('./coverage/jsCoverage');
 const featureAvailabilityService = require('./commons/featureAvailabilityService');
 const featureFlags = require('./commons/featureFlags');
 const { mapFilesToLocalDrive } = require('./services/localRCASaver');
-const { removeHiddenParamsInTestData } = require('./commons/testimServicesApi');
 
 const gitBranch = utils.getEnvironmentGitBranch();
 const gitCommit = process.env.GIT_COMMIT || process.env.CIRCLE_SHA1 || process.env.TRAVIS_COMMIT;
@@ -125,13 +124,6 @@ RunStatus.prototype.addRetryTestResult = async function ({
 
     this.testRunStatus[newResultId] = newTestResult;
 
-    const { projectData } = this.options;
-
-
-    if (newTestResult.config.testData) {
-        newTestResult.config.testData = removeHiddenParamsInTestData(newTestResult.config.testData, projectData.defaults);
-    }
-
     return servicesApi.addTestRetry({
         projectId,
         runId: executionId,

package/utils.js

@@ -71,20 +71,16 @@ function getRunConfigByBrowserName(browser, saucelabs, browserstack) {
     return _.merge(selectedBrowser, selectedOS);
 }
 
-function handleAngularURIComponent(part) {
-    return part.replace(/(~|\/)/g, m => ({ '~': '~~', '/': '~2F' }[m]));
-}
-
 function getTestUrl(editorUrl, projectId, testId, resultId, branch) {
     let testUrl = '';
-    branch = branch ? handleAngularURIComponent(branch) : 'master';
+    branch = branch ? encodeURIComponent(branch) : 'master';
     if (projectId && testId) {
         testUrl = `${editorUrl}/#/project/${projectId}/branch/${branch}/test/${testId}`;
         if (resultId) {
             testUrl += `?result-id=${resultId}`;
         }
     }
-    return encodeURI(testUrl);
+    return testUrl;
 }
 
 function isPromise(obj) {

package/utils.test.js

@@ -32,7 +32,7 @@ describe('utils', () => {
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'normal-branch-name'))
                 .to.equal('http://localhost:8080/#/project/project/branch/normal-branch-name/test/test?result-id=result');
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch/with/slashes'))
-                .to.equal('http://localhost:8080/#/project/project/branch/branch~2Fwith~2Fslashes/test/test?result-id=result');
+                .to.equal('http://localhost:8080/#/project/project/branch/branch%2Fwith%2Fslashes/test/test?result-id=result');
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch with spaces'))
                 .to.equal('http://localhost:8080/#/project/project/branch/branch%20with%20spaces/test/test?result-id=result');
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'encoded%20branch'))