@testim/testim-cli 3.245.0 → 3.248.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.245.0",
+  "version": "3.248.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -17,15 +17,11 @@
     "@types/node": "10.17.24",
     "@types/selenium-webdriver": "4.0.9",
     "bundle-deps": "1.0.0",
-    "chai": "4.3.6",
-    "chai-as-promised": "7.1.1",
     "gulp": "4.0.2",
     "gulp-cli": "2.3.0",
     "gulp-json-editor": "2.5.6",
     "gulp-preprocess": "3.0.3",
     "merge-stream": "2.0.0",
-    "mocha": "9.2.0",
-    "nyc": "15.1.0",
     "proxyquire": "2.1.3",
     "request": "2.88.2",
     "sinon": "9.0.2",

package/player/WebDriverHttpRequest.js

@@ -4,8 +4,8 @@ const _ = require('lodash');
 const httpRequest = require('../commons/httpRequest');
 const utils = require('../utils');
 const SeleniumProtocolError = require('./SeleniumProtocolError');
-const {SELENIUM_STATUS_CODES} = require('./constants');
-const logger = require('./../commons/logger').getLogger("WebDriverHttpRequest");
+const { SELENIUM_STATUS_CODES } = require('./constants');
+const logger = require('../commons/logger').getLogger('WebDriverHttpRequest');
 
 function isSuccessfulResponse(body, statusCode) {
     /**
@@ -56,37 +56,37 @@ class WebDriverHttpRequest {
     }
 
     handleFailedStatus(requestId, response, err = {}) {
-        const {body, statusCode, headers, text} = response;
+        const { body, statusCode, headers, text } = response;
         const resBody = _.isEmpty(body) && text ? text : body;
         /**
          * in Appium you find sometimes more exact error messages in origValue
          */
         if (resBody && resBody.value && typeof resBody.value.origValue === 'string' && typeof resBody.value.message === 'string') {
-            resBody.value.message += ' ' + resBody.value.origValue;
+            resBody.value.message += ` ${resBody.value.origValue}`;
         }
 
         if (resBody && typeof resBody === 'string') {
-            throw new SeleniumProtocolError(resBody, {requestId});
+            throw new SeleniumProtocolError(resBody, { requestId });
         }
 
         if (resBody && resBody.value) {
             const errorCode = SELENIUM_STATUS_CODES[resBody.status] || (resBody.value && SELENIUM_STATUS_CODES[resBody.value.error]) || SELENIUM_STATUS_CODES[-1];
-            let error = {
+            const error = {
                 type: errorCode ? errorCode.id : 'unknown',
                 message: errorCode ? errorCode.message : 'unknown',
-                orgStatusMessage: resBody.value ? resBody.value.message : ''
+                orgStatusMessage: resBody.value ? resBody.value.message : '',
             };
 
-            throw new SeleniumProtocolError(error, {requestId});
+            throw new SeleniumProtocolError(error, { requestId });
         }
 
         // IEServer webdriver bug where the error is put into the Allow header
         // https://github.com/SeleniumHQ/selenium/issues/6828
         if (statusCode === 405) {
             const allowHeader = headers && headers.allow;
-            const err = new SeleniumProtocolError(allowHeader, {requestId});
-            if (err.message.match(/Command not found/)) {
-                throw err;
+            const _err = new SeleniumProtocolError(allowHeader, { requestId });
+            if (_err.message.match(/Command not found/)) {
+                throw _err;
             }
         }
 
@@ -94,12 +94,12 @@ class WebDriverHttpRequest {
             status: -1,
             type: err.code || 'ECONNREFUSED',
             orgStatusMessage: err.rawResponse || err.message,
-            message: err.rawResponse || "Couldn't connect to selenium server"
-        }, {requestId});
+            message: err.rawResponse || "Couldn't connect to selenium server",
+        }, { requestId });
     }
 
     processHttpOnSuccess(response, requestId) {
-        const {body, statusCode} = response;
+        const { body, statusCode } = response;
         if (isSuccessfulResponse(body, statusCode)) {
             return body;
         }
@@ -108,44 +108,49 @@ class WebDriverHttpRequest {
     }
 
     processHttpOnError(err, requestId) {
-        const response = err && err.response || {};
+        const response = (err && err.response) || {};
         return this.handleFailedStatus(requestId, response, err);
     }
 
     httpPostRequest(path, body = {}) {
         const requestId = utils.guid();
-        if (path === "/session") {
-            logger.info("POST REQUEST", {requestId, path, testResultId: this.testResultId});
+        if (path === '/session') {
+            logger.info('POST REQUEST', { requestId, path, testResultId: this.testResultId });
         } else {
-            logger.info("POST REQUEST", {requestId, path, body, testResultId: this.testResultId});
+            logger.info('POST REQUEST', { requestId, path, body, testResultId: this.testResultId });
         }
 
         return httpRequest.postFullRes(`${this.gridUrl}${path}`, body, this.headers, this.connectionRetryTimeout)
-            .tap((response) => logger.info("POST RESPONSE", {
-                requestId,
-                path,
-                res: JSON.stringify(response.body),
-                testResultId: this.testResultId
-            }))
+            .then(response => {
+                logger.info('POST RESPONSE', {
+                    requestId,
+                    path,
+                    res: JSON.stringify(response.body),
+                    testResultId: this.testResultId,
+                });
+                return response;
+            })
             .catch(err => this.processHttpOnError(err, requestId))
             .then((response) => this.processHttpOnSuccess(response, requestId));
     }
 
     httpGetRequest(path) {
         const requestId = utils.guid();
-        logger.info("GET REQUEST", {requestId, path, testResultId: this.testResultId});
+        logger.info('GET REQUEST', { requestId, path, testResultId: this.testResultId });
         const query = {};
         return httpRequest.getFullRes(`${this.gridUrl}${path}`, query, this.headers, this.connectionRetryTimeout)
-            .tap((response) => {
-                if (_.endsWith(path, "/screenshot")) {
-                    return logger.info("GET RESPONSE", {requestId, path, testResultId: this.testResultId});
+            .then(response => {
+                if (_.endsWith(path, '/screenshot')) {
+                    logger.info('GET RESPONSE', { requestId, path, testResultId: this.testResultId });
+                    return response;
                 }
-                logger.info("GET RESPONSE", {
+                logger.info('GET RESPONSE', {
                     requestId,
                     path,
                     res: JSON.stringify(response.body),
-                    testResultId: this.testResultId
+                    testResultId: this.testResultId,
                 });
+                return response;
             })
             .catch(err => this.processHttpOnError(err, requestId))
             .then((response) => this.processHttpOnSuccess(response, requestId));
@@ -153,14 +158,17 @@ class WebDriverHttpRequest {
 
     httpDeleteRequest(path) {
         const requestId = utils.guid();
-        logger.info("DELETE REQUEST", {requestId, path, testResultId: this.testResultId});
+        logger.info('DELETE REQUEST', { requestId, path, testResultId: this.testResultId });
         return httpRequest.deleteFullRes(`${this.gridUrl}${path}`, undefined, this.headers, this.connectionRetryTimeout)
-            .tap((response) => logger.info("DELETE RESPONSE", {
-                requestId,
-                path,
-                res: JSON.stringify(response.body),
-                testResultId: this.testResultId
-            }))
+            .then(response => {
+                logger.info('DELETE RESPONSE', {
+                    requestId,
+                    path,
+                    res: JSON.stringify(response.body),
+                    testResultId: this.testResultId,
+                });
+                return response;
+            })
             .catch(err => this.processHttpOnError(err, requestId))
             .then((response) => this.processHttpOnSuccess(response, requestId));
     }

package/player/chromeLauncherTestPlayer.js

@@ -23,8 +23,8 @@ class LauncherDriver {
         this.chrome.process.once('exit', () => { this._isAlive = false; });
         this.chrome.process.once('close', () => { this._isAlive = false; });
         this._isAlive = true;
-        const browserEndpoint = await httpRequest.get(`http://localhost:${this.chrome.port}/json/version`);
-        await this.cdpTestRunner.initSession(browserEndpoint.webSocketDebuggerUrl);
+        const webSocketDebuggerUrl = await utils.getCdpAddressForHost(`localhost:${this.chrome.port}`);
+        await this.cdpTestRunner.initSession(webSocketDebuggerUrl);
 
         registerExitHook(() => this.chrome.kill());
     }

package/player/services/playbackTimeoutCalculator.js

@@ -4,6 +4,7 @@ const _ = require('lodash');
 
 const COMMUNICATION_BUFFER_TIME = 1000;
 const UI_VERIFICATION_STEPS = ['simple-ui-verification', 'wait-for-simple-ui-verification'];
+const FULL_TIMEOUT_STEP_TYPES = [...UI_VERIFICATION_STEPS, 'custom-validation', 'sfdc-step-login'];
 
 class PlaybackTimeoutCalculator {
     constructor(isDebuggerConnected) {
@@ -41,7 +42,7 @@ class PlaybackTimeoutCalculator {
         };
         stepPlayback.setStartTimestamp();
         const totalStepTime = this.getTotalStepRunTime(stepPlayback);
-        const currentRetryTimes = [...UI_VERIFICATION_STEPS, 'custom-validation'].includes(stepPlayback.stepType) ? [totalStepTime] : getRetryTimeoutSuggestions(totalStepTime);
+        const currentRetryTimes = FULL_TIMEOUT_STEP_TYPES.includes(stepPlayback.stepType) ? [totalStepTime] : getRetryTimeoutSuggestions(totalStepTime);
         this.resetStepVariables(totalStepTime, currentRetryTimes);
         stepPlayback.context.data.maxTotalStepTime = totalStepTime;
     }
@@ -61,6 +62,9 @@ class PlaybackTimeoutCalculator {
         if (UI_VERIFICATION_STEPS.includes(stepPlayback.stepType)) {
             fallbackTimeout = stepPlayback.context.config.applitoolsStepTimeout || HALF_HOUR_IN_MS;
         }
+        if (stepPlayback.step.type.startsWith('sfdc-')) {
+            fallbackTimeout = stepPlayback.step.defaultTimeout;
+        }
         return (stepPlayback.step.useStepTimeout && stepPlayback.step.stepTimeout) ? stepPlayback.step.stepTimeout : fallbackTimeout;
     }
     getTotalStepTimeLeftToPlay(stepPlayback, totalStepTime = this.totalStepTime) {

package/player/stepActions/scripts/selectOption.js

@@ -1,13 +1,18 @@
+/* eslint-disable no-restricted-syntax */ // This code only runs in Safari, not in IE.
 module.exports = function (locatedElement, dispatchEventOnSelectElement) {
     function closest(el, selectors) {
+        var originalMatches = Element.prototype.matches;
+        /* eslint-disable-next-line no-proto, no-undef */ // Some customers override the native Element prototype, so we need to create a new one if they messed it up.
+        var matches = originalMatches && isNativeFunction(originalMatches) ? originalMatches : document.createElement(el.tagName).__proto__.matches;
         do {
-            if (Element.prototype.matches.call(el, selectors)) return el;
+            if (matches.call(el, selectors)) return el;
             el = el.parentElement || el.parentNode;
         } while (el !== null && el.nodeType === 1);
         return null;
     }
 
     try {
+        /* eslint-disable-next-line no-undef */ // This code depends on pre-injecting this function as well.
         var optionEl = getLocatedElement(locatedElement);
         if (!optionEl) {
             return { success: false, status: 'failed', result: 'option element not found' };

package/player/stepActions/selectOptionStepAction.js

@@ -2,42 +2,48 @@
 
 const StepAction = require('./stepAction');
 const { extractElementId } = require('../../utils');
-const { codeSnippets } = require('../../commons/getSessionPlayerRequire');
+const { codeSnippets, utils } = require('../../commons/getSessionPlayerRequire');
 const selectOption = require('./scripts/selectOption');
 const featureFlags = require('../../commons/featureFlags');
 
 class SelectOptionStepAction extends StepAction {
-    performAction() {
+    async performAction() {
         const target = this.context.data[this.step.targetId || 'targetId'];
         const { seleniumElement, locatedElement } = target;
 
-        return this.driver.getBrowserAndOS()
-            .then(browserAndOS => {
-                const browserMajor = browserAndOS.browserMajor;
-                const isSafari = this.driver.isSafari();
-                const isShadowed = Boolean(this.step.element && this.step.element.isShadowed);
+        const browserAndOS = await this.driver.getBrowserAndOS();
 
-                // TODO: Remove the special handling for safari < 12 after we upgrade our grid to safari 13.
-                // force use js code when element is shadow dom
-                if (!isSafari || (isSafari && browserMajor >= 13 && !isShadowed)) {
-                    return this.driver.elementIdClick(extractElementId(seleniumElement));
+        const browserMajor = browserAndOS.browserMajor;
+        const isSafari = this.driver.isSafari();
+        const isShadowed = Boolean(this.step.element && this.step.element.isShadowed);
+
+        // TODO: Remove the special handling for safari < 12 after we upgrade our grid to safari 13.
+        // force use js code when element is shadow dom
+        if (!isSafari || (isSafari && browserMajor >= 13 && !isShadowed)) {
+            try {
+                const res = await this.driver.elementIdClick(extractElementId(seleniumElement));
+                return res;
+            } catch (err) {
+                // If customer overrides the native Element prototype, this click will fail for this reason. in such a case, fallback to use js code.
+                if (!err.message.includes('Cannot check the displayedness of a non-Element argument')) {
+                    throw err;
                 }
+            }
+        }
+
+        const safariSelectOptionDispatchEventOnSelectElement = featureFlags.flags.safariSelectOptionDispatchEventOnSelectElement.isEnabled();
+        const selectOptionCode = `
+            var getLocatedElement = ${codeSnippets.getLocatedElementCode};
+            var isNativeFunction = ${utils.isNativeFunction.toString()};
+            var selectOption = ${selectOption.toString()};
+            return selectOption.apply(null, arguments);
+        `;
 
-                const safariSelectOptionDispatchEventOnSelectElement = featureFlags.flags.safariSelectOptionDispatchEventOnSelectElement.isEnabled();
-                const selectOptionCode = `
-                    var getLocatedElement = ${codeSnippets.getLocatedElementCode};
-                    var selectOption = ${selectOption.toString()};
-                    return selectOption.apply(null, arguments);
-                `;
-
-                return this.driver.executeJSWithArray(selectOptionCode, [locatedElement, safariSelectOptionDispatchEventOnSelectElement])
-                    .then(result => {
-                        if (result.value && result.value.success) {
-                            return { success: true };
-                        }
-                        return { success: false };
-                    });
-            });
+        const result = await this.driver.executeJSWithArray(selectOptionCode, [locatedElement, safariSelectOptionDispatchEventOnSelectElement]);
+        if (result.value && result.value.success) {
+            return { success: true };
+        }
+        return { success: false };
     }
 }
 

package/player/stepActions/sfdcStepAction.js

@@ -0,0 +1,27 @@
+const StepAction = require('./stepAction');
+const { sfdc } = require('../../commons/getSessionPlayerRequire');
+
+class SfdcStepAction extends StepAction {
+    async performAction() {
+        const page = sfdc.sfdcNewSePage(this.driver);
+        try {
+            const actions = this.context.sfdcTestActions;
+            if (actions === undefined) {
+                throw new Error('No test actions were compiled');
+            }
+            await sfdc.sfdcExecute(page, actions);
+            return { success: true };
+        } catch (err) {
+            return {
+                success: false,
+                reason: err.reason || err.message,
+                exception: err,
+                shouldRetry: false, // TODO - check this.  Our (bFormat) steps are probably not retryable?
+            };
+        } finally {
+            page.releaseObjects();
+        }
+    }
+}
+
+module.exports = SfdcStepAction;

package/player/stepActions/stepActionRegistrar.js

@@ -27,6 +27,7 @@ const CliJsStepAction = require('./cliJsStepAction');
 const CliConditionStepAction = require('./cliConditionStepAction');
 const NodePackageStepAction = require('./nodePackageStepAction');
 const ExtensionOnlyStepAction = require('./extensionOnlyStepAction');
+const SfdcStepAction = require('./sfdcStepAction');
 
 function register(stepActionByType, stepActionFactory) {
     Object.keys(stepActionByType).forEach(type => {
@@ -82,6 +83,17 @@ module.exports = function (driver, stepActionFactory, runMode) {
         'email-code-step': JsCodeStepAction,
         'cli-email-code-step': CliJsStepAction,
         'tdk-hybrid': TdkHybridStepAction,
+
+        'sfdc-step-login': SfdcStepAction,
+        'sfdc-step-logout': SfdcStepAction,
+        'sfdc-step-sobjectcreate': SfdcStepAction,
+        'sfdc-step-sobjectdelete': SfdcStepAction,
+        'sfdc-step-findrecord': SfdcStepAction,
+        'sfdc-step-quickaction': SfdcStepAction,
+        'sfdc-step-edit': SfdcStepAction,
+        'sfdc-step-sobjectvalidate': SfdcStepAction,
+        'sfdc-step-launchapp': SfdcStepAction,
+        'sfdc-step-closeconsoletabs': SfdcStepAction,
     };
 
     register(STEP_ACTION_MAPPING, stepActionFactory);