@testim/testim-cli 3.289.0 → 3.290.1-beta

package/player/stepActions/specialKeyStepAction.js

@@ -1,52 +0,0 @@
-'use strict';
-
-const { extractElementId } = require('../../utils');
-const StepAction = require('./stepAction');
-
-const keyMap = {
-    8: '\uE008', // (Backspace)
-    9: '\uE004', // (tab)
-    13: '\uE007', // (enter)
-    27: '\uE00C', // (esc)
-    33:	'\uE00E', // (page up)
-    34: '\uE00F', // (page down)
-    35: '\uE010', // (end)
-    36: '\uE011', // (home)
-    45:	'\uE016', // (insert)
-    112: '\uE031', // (f1)
-    113: '\uE032', // (f2)
-    114: '\uE033', // (f3)
-    115: '\uE034', // (f4)
-    116: '\uE035', // (f5)
-    117: '\uE036', // (f6)
-    118: '\uE037', // (f7)
-    119: '\uE038', // (f8)
-    120: '\uE039', // (f9)
-    121: '\uE03A', // (f10)
-    122: '\uE03B', // (f11)
-    123: '\uE03C', // (f12)
-};
-
-class SpecialKeyStepAction extends StepAction {
-    setWithValueApi(keys) {
-        const target = this.getTarget();
-        if (target?.seleniumElement) {
-            return this.driver.elementIdValue(extractElementId(target.seleniumElement), keys);
-        }
-        return Promise.reject(new Error('missing selenium element'));
-    }
-
-    performAction() {
-        const keys = [];
-        const keyCode = this.step.events[0].eventData.keyCode;
-
-        if (keyCode >= 32 && keyCode <= 127) {
-            keys.push(String.fromCharCode(keyCode));
-        } else {
-            keys.push(keyMap[keyCode]);
-        }
-        return this.setWithValueApi(keys);
-    }
-}
-
-module.exports = SpecialKeyStepAction;

package/player/stepActions/stepAction.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const { getSessionPlayer } = require('../../commons/getSessionPlayerRequire');
-
-/** @typedef {typeof import('clickim/src/background/stepActions/stepAction').StepAction} ClickimStepActionCtor */
-/** @typedef {ConstructorParameters<ClickimStepActionCtor>} ClickimStepActionCtorParams */
-/** @typedef {InstanceType<ClickimStepActionCtor>} ClickimStepAction */
-
-class StepAction {
-    /** @type {(...args: ClickimStepActionCtorParams) => this} */
-    constructor(
-        step,
-        context,
-        frameHandler,
-        exportsGlobal = {},
-        stepActionUtils = undefined,
-        locateElementPlayer = undefined,
-        exportsTest = {},
-    ) {
-        this.step = step;
-        this.context = context;
-        this.frameHandler = frameHandler;
-        this.frameId = 0;
-        /** @type {import('../utils/stepActionUtils'))} */
-        this.stepActionUtils = stepActionUtils;
-        this.locateElementPlayer = locateElementPlayer;
-        this.exportsGlobal = exportsGlobal;
-        this.exportsTest = exportsTest;
-    }
-
-    get driver() {
-        return this.stepActionUtils.driver;
-    }
-
-    /** @protected */
-    get sessionPlayerInit() {
-        return getSessionPlayer();
-    }
-
-    async performAction() {
-        throw new Error('not implemented');
-    }
-
-    getTarget() {
-        const targetId = this.step.targetId || 'targetId';
-        return this.context.data[targetId];
-    }
-
-    /** @type {ClickimStepAction['execute']} */
-    async execute(stepActionFactory, step) {
-        try {
-            const res = await this.performAction(stepActionFactory, step);
-            return { success: true, ...res };
-        } catch (err) {
-            const errorMsg = err?.message || err?.seleniumStack?.message;
-            const displayMsg = err?.displayMessage;
-            return {
-                success: false,
-                reason: errorMsg,
-                exception: err,
-                errorType: this.sessionPlayerInit.commonConstants.stepResult.ACTION_EXCEPTION,
-                resultInfo: {
-                    exception: `selenium exception: ${errorMsg}`,
-                    // clickim -> playbackStepResultHandler.js -> FAILURE_REASON_MAPPING -> ACTION_EXCEPTION
-                    // expects resultInfo.error or resultInfo.reason
-                    error: displayMsg || errorMsg,
-                },
-            };
-        }
-    }
-}
-
-module.exports = StepAction;

package/player/stepActions/stepActionRegistrar.js

@@ -1,111 +0,0 @@
-// @ts-check
-
-'use strict';
-
-const LocateStepAction = require('./locateStepAction');
-const ScrollStepAction = require('./scrollStepAction');
-const MouseStepAction = require('./mouseStepAction');
-const TextValidationStepAction = require('./textValidationStepAction');
-const EvaluateExpressionStepAction = require('./evaluateExpressionStepAction');
-const TextStepAction = require('./textStepAction');
-const JsCodeStepAction = require('./jsCodeStepAction');
-const JsConditionStepAction = require('./jsConditionStepAction');
-const SpecialKeyStepAction = require('./specialKeyStepAction');
-const SelectOptionStepAction = require('./selectOptionStepAction');
-const SubmitStepAction = require('./submitStepAction');
-const HoverStepAction = require('./hoverStepAction');
-const WheelStepAction = require('./wheelStepAction');
-const DropFileStepAction = require('./dropFileStepAction');
-const InputFileStepAction = require('./inputFileStepAction');
-const NavigationStepAction = require('./navigationStepAction');
-const SleepStepAction = require('./sleepStepAction');
-const RefreshStepAction = require('./RefreshStepAction');
-const ApiStepAction = require('./apiStepAction');
-const ExtractTextStepAction = require('./extractTextStepAction');
-const TdkHybridStepAction = require('./tdkHybridStepAction');
-const PixelValidationStepAction = require('./pixelValidationStepAction');
-const CliJsStepAction = require('./cliJsStepAction');
-const CliConditionStepAction = require('./cliConditionStepAction');
-const NodePackageStepAction = require('./nodePackageStepAction');
-const ExtensionOnlyStepAction = require('./extensionOnlyStepAction');
-const SfdcStepAction = require('./sfdcStepAction');
-const SfdcRecordedStepAction = require('./sfdcRecordedStepAction');
-
-function register(stepActionByType, stepActionFactory) {
-    Object.keys(stepActionByType).forEach(type => {
-        stepActionFactory.registerStepAction(type, stepActionByType[type]);
-    });
-}
-
-const STEP_ACTION_MAPPING = {
-    locate: LocateStepAction,
-    scroll: ScrollStepAction,
-    mouse: MouseStepAction,
-    submit: SubmitStepAction,
-    text: TextStepAction,
-    'special-key': SpecialKeyStepAction,
-    'user-code': JsCodeStepAction,
-    'validation-code-step': JsCodeStepAction,
-    'wait-for-code-step': JsCodeStepAction,
-    'action-code-step': JsCodeStepAction,
-    'condition-step': JsConditionStepAction,
-    'skip-code-step': JsConditionStepAction,
-    'element-code-step': JsConditionStepAction,
-    'evaluate-expression': EvaluateExpressionStepAction,
-    'text-validation': TextValidationStepAction,
-    'wait-for-text-validation': TextValidationStepAction,
-    'select-option': SelectOptionStepAction,
-    'drop-file': DropFileStepAction,
-    'input-file': InputFileStepAction,
-    hover: HoverStepAction,
-    navigation: NavigationStepAction,
-    wheel: WheelStepAction,
-    sleep: SleepStepAction,
-    refresh: RefreshStepAction,
-    'api-validation': ApiStepAction,
-    '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,
-    'network-validation-step': ExtensionOnlyStepAction,
-
-    'cli-validation-code-step': CliJsStepAction,
-    'cli-wait-for-code-step': CliJsStepAction,
-    'cli-action-code-step': CliJsStepAction,
-    'cli-api-code-step': CliJsStepAction,
-
-    'cli-condition-step': CliConditionStepAction,
-    'node-package': NodePackageStepAction,
-
-    'email-code-step': JsCodeStepAction,
-    'cli-email-code-step': CliJsStepAction,
-    'tdk-hybrid': TdkHybridStepAction,
-
-    'sfdc-recorded-step': SfdcRecordedStepAction,
-    '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-sobjectedit': SfdcStepAction,
-    'sfdc-step-sobjectvalidate': SfdcStepAction,
-    'sfdc-step-launchapp': SfdcStepAction,
-    'sfdc-step-closeconsoletabs': SfdcStepAction,
-    'sfdc-step-relatedlistaction': SfdcStepAction,
-};
-
-/**
- * @param {import('../webdriver')} driver
- * @param {import('clickim/src/background/stepActions/stepActionFactory').StepActionFactory} stepActionFactory
-*/
-module.exports = function (driver, stepActionFactory, runMode) {
-    register(STEP_ACTION_MAPPING, stepActionFactory);
-    if (stepActionFactory.registerLocateStepActionUtils) {
-        stepActionFactory.registerLocateStepActionUtils(LocateStepAction.getUtils(driver));
-    }
-};

package/player/stepActions/submitStepAction.js

@@ -1,12 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-
-class SubmitStepAction extends StepAction {
-    async performAction() {
-        await this.driver.submitForm(this.getTarget().seleniumElement);
-    }
-}
-
-module.exports = SubmitStepAction;
-

package/player/stepActions/tdkHybridStepAction.js

@@ -1,18 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const { execute } = require('../../stepPlayers/hybridStepPlayback');
-
-class TdkHybridStepAction extends StepAction {
-    async performAction() {
-        return await execute(
-            this.step,
-            this.context,
-            this.driver,
-            this.stepActionUtils.testimServicesApi.authenticationManager.getLoggedUserInfo(),
-            this.frameHandler.frameManager
-        );
-    }
-}
-
-module.exports = TdkHybridStepAction;

package/player/stepActions/textStepAction.js

@@ -1,110 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const setTextScript = require('./scripts/setText');
-const dispatchFocus = require('./scripts/focusElement');
-const { extractElementId, delay } = require('../../utils');
-
-class TextStepAction extends StepAction {
-    async setValueNative() {
-        const context = this.context;
-        const target = this.getTarget();
-        if (!this.step.delayBetweenChars) {
-            return this.driver.setValue(target.seleniumElement, context.stepText);
-        }
-
-        await this.driver.elementIdClear(extractElementId(target.seleniumElement));
-        return await this.setTextDelayed();
-    }
-
-    async setValueJS() {
-        const step = this.step;
-        const context = this.context;
-        const target = context.data[step.targetId || 'targetId'];
-        const timeout = context.data.timeToPlayStep + 3000;
-        const events = step.events;
-
-        const { setTextDraftJs } = this.sessionPlayerInit.codeSnippets;
-        if (target.isDraftEditor && setTextDraftJs) {
-            return this.driver.executeJS(setTextDraftJs(target.locatedElement, context.stepText));
-        }
-
-        if (!events?.length) {
-            return undefined;
-        }
-
-        const eventMessage = {
-            eventType: step.type,
-            events,
-            quirks: step.quirks,
-            locatedElement: target.locatedElement,
-            isRoot: target.isRoot,
-            elementToFocusLocatedElement: target.elementToFocusLocatedElement,
-        };
-
-        const setTextCode = `
-            var getLocatedElement = ${this.sessionPlayerInit.codeSnippets.getLocatedElementCode};
-            var dispatchFocus = ${dispatchFocus};
-            var setText = ${setTextScript.toString()};
-            var eventData = arguments[0];
-            var done = arguments[1];
-            return setText.call(null, eventData, done);
-        `;
-
-        const result = await this.driver.executeCodeAsync(setTextCode, timeout, eventMessage);
-        return { success: Boolean(result.value?.success) };
-    }
-
-    async setTextDelayed() {
-        const letters = this.context.stepText;
-        const target = this.getTarget();
-        for (let i = 0; i < letters.length; i++) {
-            await this.driver.elementIdValue(extractElementId(target.seleniumElement), letters[i]);
-            // don't delay on last step.
-            if (i < letters.length - 1) {
-                await delay(this.step.delayBetweenChars);
-            }
-        }
-    }
-
-    async setValueAppendNative() {
-        const keys = [];
-        const context = this.context;
-        const target = this.getTarget();
-
-        if (target?.seleniumElement) {
-            if (!this.step.delayBetweenChars) {
-                keys.push(Array.from(context.stepText));
-                return this.driver.elementIdValue(extractElementId(target.seleniumElement), keys);
-            }
-
-            return this.setTextDelayed();
-        }
-        throw new Error('missing selenium element');
-    }
-
-    async performAction() {
-        const target = this.getTarget();
-        const forceJsEvent = this.driver.isSafari() &&
-            target.locatedElement && target.locatedElement.shadowPath &&
-            Array.isArray(target.locatedElement.shadowPath) && target.locatedElement.shadowPath.length > 1;
-
-        if (this.step.appendText) {
-            if (this.step.nativeEvents) {
-                return this.setValueAppendNative();
-            }
-            const { stepResult } = this.sessionPlayerInit.commonConstants;
-            return {
-                success: false,
-                errorType: stepResult.TEXT_ACTION_FAILURE,
-                resultInfo: { error: "'Append Text' is only supported in Native Mode" },
-            };
-        }
-        if (this.step.nativeEvents && !forceJsEvent) {
-            return this.setValueNative();
-        }
-        return this.setValueJS();
-    }
-}
-
-module.exports = TextStepAction;

package/player/stepActions/textValidationStepAction.js

@@ -1,64 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-
-class TextValidationStepAction extends StepAction {
-    async performAction(stepActionFactory) {
-        const { step, context, frameHandler, sessionPlayerInit: { paramEvaluator, utils, commonConstants } } = this;
-        const target = this.getTarget();
-
-        try {
-            const text = await this.stepActionUtils.extractTargetText(target);
-            let actual;
-            let expected;
-            if (paramEvaluator) {
-                const evaluation = paramEvaluator.computeExpression(
-                    step.expression2,
-                    context,
-                    this.exportsGlobal,
-                    this.exportsTest,
-                );
-                actual = text;
-                expected = evaluation.evaluatedText;
-            } else {
-                const res = await stepActionFactory.executeStep(
-                    step.expression2,
-                    context,
-                    frameHandler,
-                    this.exportsGlobal,
-                    this.locateElementPlayer,
-                    this.exportsTest,
-                );
-                actual = text;
-                expected = res.evaluatedText;
-            }
-            try {
-                const compareResult = utils.compareOrMatch(expected, actual);
-                if (compareResult) {
-                    return { success: true };
-                }
-                return {
-                    success: false,
-                    errorType: commonConstants.stepResult.TEXT_COMPARE_FAILURE,
-                    resultInfo: { expected: String(expected), actual },
-                };
-            } catch (err) {
-                return {
-                    success: false,
-                    errorType: commonConstants.stepResult.TEXT_COMPARE_FAILURE,
-                    resultInfo: { expected: expected.toString(), actual },
-                };
-            }
-        } catch (err) {
-            return {
-                success: false,
-                reason: err.message,
-                exception: err,
-                shouldRetry: true,
-            };
-        }
-    }
-}
-
-module.exports = TextValidationStepAction;
-

package/player/stepActions/wheelStepAction.js

@@ -1,41 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const wheelScript = require('./scripts/wheel');
-
-class WheelStepAction extends StepAction {
-    async performAction() {
-        const step = this.step;
-        const context = this.context;
-        const events = step.events;
-
-        if (!events?.length) {
-            return undefined;
-        }
-
-        const eventMessage = {
-            events,
-            eventData: {
-                modifiers: step.modifiers,
-                button: step.button,
-            },
-            locatedElement: this.getTarget().locatedElement,
-        };
-
-        const timeout = context.data.timeToPlayStep + 3000;
-
-        const wheelCode = `
-            var getLocatedElement = ${this.sessionPlayerInit.codeSnippets.getLocatedElementCode};
-            var wheel = ${wheelScript.toString()};
-            var eventData = arguments[0];
-            var done = arguments[1];
-            return wheel.call(null, eventData, done);
-        `;
-
-        const result = await this.driver.executeCodeAsync(wheelCode, timeout, eventMessage);
-        return { success: result.value?.state === 'success' };
-    }
-}
-
-module.exports = WheelStepAction;
-

package/player/utils/cookieUtils.js

@@ -1,39 +0,0 @@
-"use strict";
-
-const logger = require('../../commons/logger').getLogger('cookies-utils');
-
-module.exports = function (driver) {
-    class CookieUtils {
-        set(cookie) {
-            let domain = cookie.domain;
-            if(!cookie.hostOnly) {
-                if (domain && !domain.startsWith('.')) {
-                    domain = `.${domain}`;
-                }
-            }
-            return driver.setCookie(cookie.name, cookie.value, domain, cookie.httpOnly, cookie.secure, cookie.path, cookie.expirationDate)
-                .catch(err => {
-                    logger.error("failed to set cookie", {err});
-                    throw err;
-                });
-        }
-
-        get(cookie) {
-            return driver.getCookie(cookie.name)
-                .catch(err => {
-                    logger.error("failed to get cookie", {err});
-                    throw err;
-                });
-        }
-
-        remove(cookie) {
-            return driver.deleteCookie(cookie.name)
-                .catch(err => {
-                    logger.error("failed to remove cookie", {err});
-                    throw err;
-                });
-        }
-    }
-
-    return new CookieUtils();
-};