@testim/testim-cli 3.196.0 → 3.197.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.196.0",
+  "version": "3.197.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -48,6 +48,8 @@
     "multer": "1.4.2"
   },
   "dependencies": {
+    "@applitools/eyes-sdk-core": "12.23.12",
+    "@applitools/visual-grid-client": "15.8.31",
     "@testim/coralogix-logger": "1.1.27-beta",
     "@testim/webdriverio": "0.0.3",
     "abort-controller": "3.0.0",

package/player/stepActions/baseJsStepAction.js

@@ -44,6 +44,7 @@ class BaseJsStepAction extends StepAction {
     }
 
     executeGetStatus(transactionId) {
+        // eslint-disable-next-line prefer-arrow-callback
         return this.driver.executeJS(function (transactionId) {
             const sessionItem = 'data-testim-' + transactionId;
             try {
@@ -139,12 +140,15 @@ class BaseJsStepAction extends StepAction {
 
     executeInAut(eventMessage) {
         const useExperimentalPreCompilation = featureFlags.flags.experimentalPreCodeCompilation.isEnabled();
+        const experimentalAsyncCustomCode = featureFlags.flags.experimentalAsyncCustomCode.isEnabled();
         const rawParams = this.constructJSFunParams(eventMessage);
         const hasLocateParams = rawParams.function.args.some(x => Boolean(x && x.locatedElement));
         let funcToRunString = 'undefined';
         if (useExperimentalPreCompilation) {
             const paramNames = rawParams.function.params.slice(0, -1);
-            funcToRunString = `function(${paramNames.join(',')}) {
+            funcToRunString = (experimentalAsyncCustomCode && !this.driver.isIE()) ? `async function(${paramNames.join(',')}) {
+                ${eventMessage.code}
+            };` : `function(${paramNames.join(',')}) {
                 ${eventMessage.code}
             };`;
             // remove code from call.

package/player/stepActions/pixelValidationStepAction.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const StepAction = require('./stepAction');
+const { eyeSdkService } = require('../utils/eyeSdkService');
+const logger = require('../../commons/logger').getLogger('pixel-validation-step-action');
+
+
+class PixelValidationStepAction extends StepAction {
+    async performAction() {
+        const { shouldUseVisualGrid, applitoolsSdkConfig: config } = this.context;
+        this.runContext = this.context.getRunContext(undefined);
+        const eyeManager = await eyeSdkService.getManager(shouldUseVisualGrid, this.context.config.applitoolsConcurrency || 5);
+        const targetElementData = this.getTarget() || {};
+        try {
+            const openedEye = await eyeManager.openEyes({ driver: this.driver.client, config });
+            const region = (this.step.action === 'element' && targetElementData.seleniumElement) || undefined;
+            await openedEye.check({ settings: { region, fully: this.step.action === 'stitched' } });
+            const eyesResults = await openedEye.close();
+
+            return { isApplitoolsSdkResult: true, success: true, eyesResults };
+        } catch (err) {
+            logger.error('Applitools SDK step failed', { err, info: err.info });
+            return { isApplitoolsSdkResult: true, success: false, err };
+        }
+    }
+}
+
+module.exports = PixelValidationStepAction;

package/player/stepActions/salesforceAutoLoginStepAction.js

@@ -7,20 +7,22 @@ class SalesforceAutoLoginStepAction extends NavigationStepAction {
         try {
             salesforceUrl = await this.updateBaseUrl(salesforceUrl);
             await this.driver.url(salesforceUrl);
-            await Promise.delay(300); // wait a little for the page to load (fixes screenshots and clicking on elements in username verification screen)
+            await Promise.delay(1000); // wait a little for the page to load (fixes screenshots and clicking on elements in username verification screen)
             let newUrl = await this.driver.getUrl();
             // Verify username screen
             const isUsernameVerificationNeeded = newUrl.includes(this.step.USERNAME_VERIFICATION_PATH_ID);
+            const timeout = this.context.data.timeToPlayStep + 3000;
             if (isUsernameVerificationNeeded) {
                 await this.driver.executeCodeAsync(`
                     function ${this.step.handleUsernameVerificationAUTFunc.toString()}
                     handleUsernameVerificationAUTFunc();
                     var done = arguments[1];
                     done();
-                `);
-                await Promise.delay(500);
+                `, timeout);
+                await Promise.delay(1500);
                 newUrl = await this.driver.getUrl(); // If we managed to continue correctly we want to get the new redirected url
             }
+            await Promise.delay(700);
             return {
                 success: true,
                 newUrl,

package/player/stepActions/stepActionRegistrar.js

@@ -22,25 +22,13 @@ const ApiStepAction = require('./apiStepAction');
 const ExtractTextStepAction = require('./extractTextStepAction');
 const TdkHybridStepAction = require('./tdkHybridStepAction');
 const SalesforceAutoLoginStepAction = require('./salesforceAutoLoginStepAction');
+const PixelValidationStepAction = require('./pixelValidationStepAction');
 
 const CliJsStepAction = require('./cliJsStepAction');
 const CliConditionStepAction = require('./cliConditionStepAction');
 const NodePackageStepAction = require('./nodePackageStepAction');
 const ExtensionOnlyStepAction = require('./extensionOnlyStepAction');
 
-const MobileTapStepAction = require('./mobile/androidTapStepAction');
-const MobileGlobalActionStepAction = require('./mobile/androidGlobalActionStepAction');
-const MobileTextChangeStepAction = require('./mobile/androidTextChangeStepAction');
-
-const AndroidLocateStepAction = require('./mobile/android/androidLocateStepAction');
-const AndroidLongClickStepAction = require('./mobile/android/androidLongClickStepAction');
-const AndroidScrollStepAction = require('./mobile/android/androidScrollStepAction');
-const AndroidSwipeStepAction = require('./mobile/android/androidSwipeStepAction');
-const AndroidSpecialKeyStepAction = require('./mobile/android/androidSpecialKeyStepAction');
-
-const IosLocateStepAction = require('./mobile/ios/iosLocateStepAction');
-const IosScrollStepAction = require('./mobile/ios/iosScrollStepAction');
-
 function register(stepActionByType, stepActionFactory) {
     Object.keys(stepActionByType).forEach(type => {
         stepActionFactory.registerStepAction(type, stepActionByType[type]);
@@ -77,6 +65,8 @@ module.exports = function (driver, stepActionFactory, runMode) {
         'api-action': ApiStepAction,
         'api-code-step': JsCodeStepAction,
         'extract-text': ExtractTextStepAction,
+        'simple-ui-verification': PixelValidationStepAction,
+        'wait-for-simple-ui-verification': PixelValidationStepAction,
 
         'cli-validation-download-file': ExtensionOnlyStepAction,
         'cli-wait-for-download-file': ExtensionOnlyStepAction,
@@ -97,44 +87,9 @@ module.exports = function (driver, stepActionFactory, runMode) {
         'salesforce-autologin': SalesforceAutoLoginStepAction,
     };
 
-    const ANDROID_STEP_ACTION_MAPPING = {
-        locate: AndroidLocateStepAction,
-        'android-tap': MobileTapStepAction,
-        'android-long-click': AndroidLongClickStepAction,
-        'android-device-key': MobileGlobalActionStepAction,
-        'android-key-board-special-keys': AndroidSpecialKeyStepAction,
-        text: MobileTextChangeStepAction,
-        'android-swipe': AndroidSwipeStepAction,
-        'android-scroll': AndroidScrollStepAction,
-    };
-
-    const IOS_STEP_ACTION_MAPPING = {
-        locate: IosLocateStepAction,
-        'ios-tap': MobileTapStepAction,
-        'ios-device-key': MobileGlobalActionStepAction,
-        text: MobileTextChangeStepAction,
-        'ios-scroll': IosScrollStepAction,
-    };
-
     register(STEP_ACTION_MAPPING, stepActionFactory);
     if (stepActionFactory.registerLocateStepActionUtils) {
         stepActionFactory.registerLocateStepActionUtils(LocateStepAction.getUtils(driver));
     }
-
-    // override android actions
-    if (runMode === 'android') {
-        register(ANDROID_STEP_ACTION_MAPPING, stepActionFactory);
-        if (stepActionFactory.registerLocateStepActionUtils) {
-            stepActionFactory.registerLocateStepActionUtils(AndroidLocateStepAction.getUtils(driver));
-        }
-    }
-
-    // override ios actions
-    if (runMode === 'ios') {
-        register(IOS_STEP_ACTION_MAPPING, stepActionFactory);
-        if (stepActionFactory.registerLocateStepActionUtils) {
-            stepActionFactory.registerLocateStepActionUtils(IosLocateStepAction.getUtils(driver));
-        }
-    }
 };
 

package/player/utils/eyeSdkService.js

@@ -0,0 +1,230 @@
+// https://github.com/applitools/eyes.sdk.javascript1/blob/master/packages/eyes-webdriverio-4/src/spec-driver.ts
+
+const { makeSDK } = require('@applitools/eyes-sdk-core');
+const { W3C_ELEMENT_ID } = require('../constants');
+const _ = require('lodash');
+
+const LEGACY_ELEMENT_ID = 'ELEMENT';
+
+function extractElementId(element) {
+    if (_.has(element, 'elementId')) {
+        return element.elementId;
+    }
+    if (_.has(element, W3C_ELEMENT_ID)) {
+        return element[W3C_ELEMENT_ID];
+    }
+    if (_.has(element, LEGACY_ELEMENT_ID)) {
+        return element[LEGACY_ELEMENT_ID];
+    }
+    return undefined;
+}
+/** implements the ?? capability for backward compatibility */
+function getValueOrFallbackIfNullOrUndefined(value, fallback) {
+    if (value === null || value === undefined) {
+        return fallback;
+    }
+    return value;
+}
+
+/**
+ * @typedef {import('@applitools/types').SpecDriver} SpecDriver
+ * @implements {SpecDriver}
+ */
+class EyesSpec {
+    // #region UTILITY
+    isDriver(driver) {
+        return Boolean(driver && driver.getPrototype && driver.desiredCapabilities && driver.requestHandler);
+    }
+
+    isElement(element) {
+        if (!element) {
+            return false;
+        }
+        const elementToCheck = element.value || element;
+        return Boolean(elementToCheck[W3C_ELEMENT_ID] || elementToCheck[LEGACY_ELEMENT_ID]);
+    }
+
+    isSelector(selector) {
+        return _.isString(selector);
+    }
+
+    transformDriver(driver) {
+        return new Proxy(driver, {
+            get: (target, key) => {
+                if (key === 'then') {
+                    return undefined;
+                }
+                return Reflect.get(target, key);
+            },
+        });
+    }
+
+    transformElement(element) {
+        const elementId = extractElementId(element.value || element);
+        return { [W3C_ELEMENT_ID]: elementId, [LEGACY_ELEMENT_ID]: elementId };
+    }
+
+    transformSelector(selector) {
+        if (!_.has(selector, 'selector')) {
+            return selector;
+        }
+        if (!_.has(selector, 'type')) {
+            return selector.selector;
+        }
+        if (selector.type === 'css') {
+            return `css selector:${selector.selector}`;
+        }
+        return `${selector.type}:${selector.selector}`;
+    }
+
+    extractSelector(element) {
+        return _.has(element, 'selector') ? element.selector : undefined;
+    }
+
+    isStaleElementError(error, selector) {
+        if (!error) {
+            return false;
+        }
+        const errOrResult = error.originalError || error;
+        return errOrResult instanceof Error ?
+            errOrResult.seleniumStack && errOrResult.seleniumStack.type === 'StaleElementReference' :
+            errOrResult.value && errOrResult.selector && errOrResult.selector === selector;
+    }
+
+    isEqualElements(_browser, element1, element2) {
+        if (!element1 || !element2) {
+            return false;
+        }
+        const elementId1 = extractElementId(element1);
+        const elementId2 = extractElementId(element2);
+        return elementId1 === elementId2;
+    }
+    // #endregion
+
+    // #region COMMANDS
+    async executeScript(driver, script, arg) {
+        const { value } = await driver.execute(script, arg);
+        return value;
+    }
+
+    async mainContext(driver) {
+        await driver.frame(null);
+        return driver;
+    }
+
+    async parentContext(driver) {
+        await driver.frameParent();
+        return driver;
+    }
+
+    async childContext(driver, element) {
+        await driver.frame(element);
+        return driver;
+    }
+
+    async findElement(driver, selector, parent) {
+        const { value } = parent ? await driver.elementIdElement(extractElementId(parent), selector) : await driver.element(selector);
+        return value;
+    }
+
+    async findElements(driver, selector, parent) {
+        const { value } = parent ? await driver.elementIdElements(extractElementId(parent), selector) : await driver.elements(selector);
+        return value;
+    }
+
+    async getWindowSize(driver) {
+        const { value: size } = await driver.windowHandleSize();
+        return { width: size.width, height: size.height };
+    }
+
+    async setWindowSize(driver, size) {
+        await driver.windowHandlePosition({ x: 0, y: 0 });
+        await driver.windowHandleSize(size);
+    }
+
+    async getDriverInfo(driver) {
+        const desiredCapabilities = driver.desiredCapabilities;
+
+        return {
+            sessionId: driver.requestHandler.sessionID || driver.sessionId,
+            isMobile: driver.isMobile,
+            isNative: driver.isMobile && !desiredCapabilities.browserName,
+            deviceName: desiredCapabilities.deviceName,
+            platformName: desiredCapabilities.platformName || desiredCapabilities.platform,
+            platformVersion: desiredCapabilities.platformVersion,
+            browserName: getValueOrFallbackIfNullOrUndefined(desiredCapabilities.browserName, desiredCapabilities.name),
+            browserVersion: getValueOrFallbackIfNullOrUndefined(desiredCapabilities.browserVersion, desiredCapabilities.version),
+            pixelRatio: desiredCapabilities.pixelRatio,
+        };
+    }
+
+    async getTitle(driver) {
+        return driver.getTitle();
+    }
+
+    async getUrl(driver) {
+        return driver.getUrl();
+    }
+
+    async visit(driver, url) {
+        await driver.url(url);
+    }
+
+    async takeScreenshot(driver) {
+        return driver.saveScreenshot();
+    }
+
+    async click(driver, element) {
+        if (this.isSelector(element)) {
+            element = await this.findElement(driver, element);
+        }
+        await driver.elementIdClick(extractElementId(element));
+    }
+
+    async hover(driver, element, offset) {
+        if (this.isSelector(element)) {
+            element = await this.findElement(driver, element);
+        }
+        await driver.moveTo(extractElementId(element), offset && offset.x, offset && offset.y);
+    }
+
+    async type(driver, element, keys) {
+        if (this.isSelector(element)) {
+            element = await this.findElement(driver, element);
+        } else {
+            driver.elementIdValue(extractElementId(element), keys);
+        }
+    }
+
+    async scrollIntoView(driver, element, align = false) {
+        if (this.isSelector(element)) {
+            element = await this.findElement(driver, element);
+        }
+        await driver.execute('arguments[0].scrollIntoView(arguments[1])', element, align);
+    }
+
+    async waitUntilDisplayed(driver, selector, timeout) {
+        await driver.waitForVisible(selector, timeout);
+    }
+    // #endregion
+}
+
+class EyeSdkService {
+    constructor() {
+        /**
+         * @typedef {import('@applitools/types').Core} Core
+         * @type {Core}
+         */
+        this.sdk = makeSDK({
+            name: 'Testim.io',
+            version: '4.0.0',
+            spec: new EyesSpec(),
+            VisualGridClient: require('@applitools/visual-grid-client'),
+        });
+    }
+    getManager(useVisualGrid, concurrency) {
+        return this.sdk.makeManager({ type: useVisualGrid ? 'vg' : 'classic', concurrency });
+    }
+}
+
+exports.eyeSdkService = new EyeSdkService();

package/reports/consoleReporter.js

@@ -143,25 +143,9 @@ class ConsoleReporter {
     }
 
     onGetSession(workerId, testName, mode) {
-        if ([constants.CLI_MODE.DEVICE_FARM_APPIUM, constants.CLI_MODE.APPIUM].includes(mode)) {
-            this.printWorkerMessage(workerId, `Get device to run ${chalk.underline(testName)}`);
-            return;
-        }
         this.printWorkerMessage(workerId, `Get browser to run ${chalk.underline(testName)}`);
     }
 
-    onUploadApk(apkLocation, vendorAppId) {
-        if (vendorAppId) {
-            console.log(`Use existing app id: ${vendorAppId}`);
-            return;
-        }
-        console.log(`Upload apk file: ${apkLocation}`);
-    }
-
-    onUploadApkFinished(appId) {
-        console.log(`Finished to upload apk file id: ${appId}`);
-    }
-
     onWaitToTestStart(workerId) {
         this.printWorkerMessage(workerId, 'Wait for test start');
     }
@@ -175,10 +159,6 @@ class ConsoleReporter {
         }
     }
 
-    onWaitForDevice(workerId, executionId) {
-        this.printWorkerMessage(workerId, `Device is being prepared for execution ${executionId} (this may take a few minutes)`);
-    }
-
     onGetBrowserFailure(workerId, projectId, attempt) {
         if (attempt !== 2) {
             return; // we want to try 2 times before showing the message once

package/reports/reporter.js

@@ -58,14 +58,11 @@ addHook('onGetBrowserSuccess');
 addHook('onTestPlanStarted');
 addHook('onGetSlot');
 addHook('onGetSession');
-addHook('onUploadApkFinished');
-addHook('onUploadApk');
 addHook('onTestFinished');
 addHook('onTestFailed');
 addHook('onTestPassed');
 addHook('onTestStarted');
 addHook('onTestIgnored');
-addHook('onWaitForDevice');
 addHook('onWaitToTestStart');
 addHook('onWaitToTestComplete');
 
@@ -128,24 +125,6 @@ Reporter.prototype.onGetSession = function (workerId, testName, mode) {
     });
 };
 
-Reporter.prototype.onUploadApkFinished = function (appId) {
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onUploadApkFinished) {
-            return reporter.onUploadApkFinished(appId);
-        }
-        return undefined;
-    });
-};
-
-Reporter.prototype.onUploadApk = function (apkLocation, vendorAppId) {
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onUploadApk) {
-            return reporter.onUploadApk(apkLocation, vendorAppId);
-        }
-        return undefined;
-    });
-};
-
 Reporter.prototype.onWaitToTestComplete = function (workerId, isCodeMode, debuggerAddress) {
     return Promise.each(this.reporters, reporter => {
         if (reporter && reporter.onWaitToTestComplete) {