@testim/testim-cli 3.289.0 → 3.290.1-beta

package/player/services/windowCreationListener.js

@@ -1,8 +0,0 @@
-"use strict";
-
-// Only for extension mode
-class WindowCreationListener {
-    on(){}
-}
-
-module.exports =  new WindowCreationListener();

package/player/stepActions/RefreshStepAction.js

@@ -1,16 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-
-class RefreshStepAction extends StepAction {
-    async execute() {
-        try {
-            await this.driver.reloadTab();
-            return { success: true };
-        } catch (error) {
-            return { success: false, reason: error.message };
-        }
-    }
-}
-
-module.exports = RefreshStepAction;

package/player/stepActions/apiStepAction.js

@@ -1,89 +0,0 @@
-// @ts-check
-
-'use strict';
-
-const StepAction = require('./stepAction');
-
-class ApiStepAction extends StepAction {
-    async runApiInAut(eventData) {
-        eventData.withCredentials = true;
-        const timeout = this.context.data.timeToPlayStep + 3000;
-        const { apiCall } = this.sessionPlayerInit;
-        try {
-            const autRes = await this.driver.executeCodeAsync(apiCall, timeout, eventData);
-            const resp = autRes?.value;
-            return resp || {};
-        } catch (err) {
-            if (err?.message?.includes('Javascript execution context no longer exists')) {
-                throw new Error(
-                    'The page refreshed or changed while executing this step. Please consider unchecking "Send via web page" if this is expected.');
-            }
-            throw err;
-        }
-    }
-
-    runApiInBg(eventData) {
-        const { apiCall } = this.sessionPlayerInit;
-        return new Promise(resolve => { apiCall(eventData, resolve); });
-    }
-
-    async performAction() {
-        const { commonConstants } = this.sessionPlayerInit;
-        /** @type {import('clickim/src/common/models/apiStep').ApiStep} */
-        const step = this.step;
-        const context = this.context;
-
-        const eventData = {
-            id: step.id,
-            url: context.apiUrl,
-            method: step.method,
-            headers: context.apiHeaders,
-            body: context.apiBody,
-            timeout: context.data.maxTotalStepTime,
-            omitCookies: step.omitCookies,
-            formData: step.formData,
-            fileUrls: context.fileUrls,
-        };
-
-        let resp;
-        if (step.sendViaWebApp) {
-            resp = await this.runApiInAut(eventData);
-        } else {
-            resp = await this.runApiInBg(eventData);
-        }
-        const result = resp.result || {};
-        const resultInfo = {
-            method: step.method,
-            status: result.status,
-            url: step.url,
-        };
-        if (resp.success) {
-            if (result.status === 0) {
-                return {
-                    result,
-                    resultInfo,
-                    shouldRetry: false,
-                    success: false,
-                    reason: 'Connection problem',
-                    errorType: commonConstants.stepResult.API_REQUEST_NETWORK_ERROR,
-                };
-            }
-            return {
-                result,
-                resultInfo,
-                shouldRetry: false,
-                success: true,
-            };
-        }
-        return {
-            result,
-            resultInfo,
-            shouldRetry: false,
-            success: false,
-            reason: result.error || commonConstants.error.REQUEST_TIMED_OUT,
-            errorType: result.error ? commonConstants.stepResult.API_FAILURE : commonConstants.stepResult.API_REQUEST_NETWORK_ERROR,
-        };
-    }
-}
-
-module.exports = ApiStepAction;

package/player/stepActions/baseCliJsStepAction.js

@@ -1,51 +0,0 @@
-'use strict';
-
-const utils = require('../../utils');
-const BaseJsStepAction = require('./baseJsStepAction');
-const service = require('../../agent/routers/cliJsCode/service');
-
-class BaseCliJsStepAction extends BaseJsStepAction {
-    async executeCliCode() {
-        const { step, context } = this;
-        const isMobile = this.stepActionUtils.driver.isMobile;
-        const hasCliAction = context.company?.activePlan?.premiumFeatures?.cliAction;
-
-        if (!hasCliAction && !isMobile) {
-            return {
-                success: 'skipped',
-                reason: 'CLI action is not enabled in your current plan',
-            };
-        }
-
-        const { code, id } = step;
-        const { incomingParams, testResultId, retryIndex, stepResultId } = context;
-        const contextData = {
-            config: context.config,
-            data: context.data,
-        };
-        const runTimeout = context.data.timeToPlayStep;
-        const data = await service.runCodeWithPackages(code, id, incomingParams, contextData, testResultId, retryIndex, stepResultId, runTimeout);
-        return await this.checkCodeResponse(data);
-    }
-
-    async performAction() {
-        try {
-            return await this.executeCliCode();
-        } catch (err) {
-            const { stepResult } = this.sessionPlayerInit.commonConstants;
-            if (err instanceof utils.TimeoutError) {
-                return {
-                    success: false,
-                    errorType: stepResult.ACTION_TIMEOUT,
-                };
-            }
-            return {
-                success: false,
-                reason: err.message,
-                exception: err,
-            };
-        }
-    }
-}
-
-module.exports = BaseCliJsStepAction;

package/player/stepActions/baseJsStepAction.js

@@ -1,277 +0,0 @@
-'use strict';
-
-
-const _ = require('lodash');
-const utils = require('../../utils');
-const StepAction = require('./stepAction');
-const runnerUtils = require('../../utils');
-const runCodeScript = require('./scripts/runCode');
-const featureFlags = require('../../commons/featureFlags');
-const { getLogger } = require('../../commons/logger');
-
-const logger = getLogger('base-js-step-action');
-
-
-class BaseJsStepAction extends StepAction {
-    isExceedingMaxResultSize(data, context) {
-        try {
-            const shouldEnforceMaxSize = context.project.defaults.enforceMaximumJsResultSize;
-            const maximumJsResultSize = featureFlags.flags.maximumJsResultSize.getValue();
-            const dataSizeExceeded = JSON.stringify(data).length > maximumJsResultSize;
-            if (!shouldEnforceMaxSize) {
-                if (dataSizeExceeded) {
-                    logger.warn(`js result size exceeded ${maximumJsResultSize}, stepId: ${this.step.id}`);
-                }
-                return false;
-            }
-            return dataSizeExceeded;
-        } catch (e) {
-            return false;
-        }
-    }
-
-    executeGetStatus(transactionId) {
-        return this.driver.executeJS(_transactionId => {
-            /* eslint-disable no-undef */
-            const sessionItem = `data-testim-${_transactionId}`;
-            try {
-                return window.sessionStorage.getItem(sessionItem);
-            } catch (err) {
-                if (
-                    err.message.includes('sessionStorage') || // Chrome + Firefox
-                    err.message.includes('The operation is insecure') // Safari
-                ) {
-                    const storage = document.head.querySelector('#testim-storage-backup');
-                    if (!storage) {
-                        return '{}';
-                    }
-                    return storage.getAttribute(sessionItem);
-                }
-                throw err;
-            }
-            /* eslint-enable no-undef */
-        }, transactionId);
-    }
-
-    constructJSFunParams(eventData) {
-        const incomingParams = eventData.incomingParams;
-
-        const params = [
-            'context', ...incomingParams.as.functionParameters,
-            'exports', 'exportsTest', 'exportsGlobal',
-        ];
-
-        const args = [eventData.context, ...incomingParams.as.functionArguments];
-
-        params.push(eventData.code);
-        args.forEach(arg => {
-            if (_.isObject(arg)) {
-                runnerUtils.removePropertyFromObject(arg, 'seleniumElement', _.isEqual);
-            }
-        });
-        return {
-            function: {
-                params,
-                args,
-            },
-            transactionId: eventData.transactionId,
-            browser: eventData.browser,
-            browserMajor: eventData.browserMajor,
-        };
-    }
-
-
-    checkStatus(transactionId) {
-        const that = this;
-        const retryInterval = that.context.config.retryTimeout;
-        let timeToPlayStep = that.context.data.timeToPlayStep - retryInterval;
-        async function checkScriptStatus() {
-            let selRes;
-            try {
-                selRes = await that.executeGetStatus(transactionId);
-            } catch (err) {
-                logger.warn('failed to get js status', { err });
-                selRes = { value: { status: 'exception' } };
-            }
-            let res;
-            try {
-                res = JSON.parse(selRes ? selRes.value : '{}');
-            } catch (e) {
-                logger.warn('non object value', { selRes });
-                res = { status: 'exception' };
-            }
-            const abortReason = that.stepActionUtils.abortedSteps.find(abortedStep => abortedStep.id === that.step.id);
-            if (abortReason) {
-                return abortReason;
-            }
-            if (!res) {
-                return { success: true };
-            }
-            if (res.status && res.status === 'done') {
-                return res;
-            }
-            if (res.status && res.status === 'failed') {
-                return { success: false, shouldRetry: true, result: res.result };
-            }
-            if (timeToPlayStep - retryInterval <= 0) {
-                return Object.assign(res, { success: false, shouldRetry: true });
-            }
-            timeToPlayStep -= retryInterval;
-            await utils.delay(retryInterval);
-            return checkScriptStatus();
-        }
-
-        return checkScriptStatus();
-    }
-
-    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?.locatedElement));
-        let funcToRunString = 'undefined';
-        if (useExperimentalPreCompilation) {
-            const paramNames = rawParams.function.params.slice(0, -1);
-            funcToRunString = experimentalAsyncCustomCode ? `async function(${paramNames.join(',')}) {
-                ${eventMessage.code}
-            };` : `function(${paramNames.join(',')}) {
-                ${eventMessage.code}
-            };`;
-            // remove code from call.
-            rawParams.function.params.pop();
-        }
-
-        const { codeSnippets } = this.sessionPlayerInit;
-
-        const runCode = `
-            ${hasLocateParams ? `var getLocatedElement = ${codeSnippets.getLocatedElementCode};` : ';'}
-            var runCode = ${runCodeScript.toString()};
-            var eventData = arguments[0];
-            var funcToRun = ${funcToRunString};
-            return runCode.call(null, eventData, funcToRun);
-        `;
-        if (!useExperimentalPreCompilation) {
-            return this.driver.executeJS(runCode, rawParams);
-        }
-
-        return this.driver.executeJS(runCode, rawParams).catch(err => this.handleExecutionError(err));
-    }
-
-    codeExecDone(resp) {
-        const { stepResult: constants } = this.sessionPlayerInit.commonConstants;
-        const { context } = this;
-        const {
-            result = {}, tstConsoleLogs, nodeVersion, navigateToDifferentDomain,
-        } = resp;
-        if (result.exports) {
-            context.data.exports = result.exports;
-        }
-
-        const resultObj = {
-            nodeVersion,
-            tstConsoleLogs,
-            data: context.data,
-        };
-
-        if (this.isFailedResult(result.resultValue)) {
-            Object.assign(resultObj, {
-                success: false,
-                errorType: constants.JS_ASSERTION_FAILED,
-            });
-        } else if (this.isExceedingMaxResultSize({ result, tstConsoleLogs }, context)) {
-            Object.assign(resultObj, {
-                success: false,
-                errorType: constants.JS_RESULT_MAX_SIZE_EXCEEDED,
-            });
-        } else {
-            Object.assign(resultObj, {
-                success: true,
-                exportsTest: result.exportsTest,
-                exportsGlobal: result.exportsGlobal,
-            });
-            if (navigateToDifferentDomain) {
-                resultObj.navigateToDifferentDomain = navigateToDifferentDomain;
-            }
-        }
-        return Promise.resolve(resultObj);
-    }
-
-    codeExecFailed(resp) {
-        const { stepResult: constants } = this.sessionPlayerInit.commonConstants;
-        const { context } = this;
-        if (resp.type === 'promise') {
-            return Promise.resolve({
-                data: context.data,
-                success: false,
-                shouldRetry: true,
-                isPendingPromise: true,
-                errorType: constants.JS_ASSERTION_FAILED,
-            });
-        }
-        if (resp.reason === 'stopped') {
-            return Promise.resolve(Object.assign({}, resp, { errorType: constants.STOPPED }));
-        }
-        const { result = {}, tstConsoleLogs } = resp;
-        const message = {
-            tstConsoleLogs,
-            data: context.data,
-            exportsGlobal: result.exportsGlobal,
-            exportsTest: result.exportsTest,
-            success: false,
-            errorType: constants.UNWRAPPED_AUT_REJECT,
-            resultInfo: { error: result.resultValue },
-        };
-        return Promise.resolve(message);
-    }
-
-    checkCodeResponse(resp) {
-        return resp?.success ? this.codeExecDone(resp) : this.codeExecFailed(resp);
-    }
-
-    async performAction() {
-        const step = this.step;
-        const context = this.context;
-
-        this.startTimestamp = Date.now();
-
-        const eventMessage = {
-            transactionId: `${context.testResultId}:${step.id}`,
-            id: step.id,
-            eventType: step.type,
-            code: step.code,
-            incomingParams: context.incomingParams,
-            exportsGlobal: this.exportsGlobal,
-            exportsTest: this.exportsTest,
-            context: {
-                config: context.config,
-                data: context.data,
-            },
-            testResultId: context.testResultId,
-        };
-
-        const browserAndOS = await this.driver.getBrowserAndOS();
-        Object.assign(eventMessage, { browser: browserAndOS.browser, browserMajor: browserAndOS.browserMajor });
-
-        if (!this.context.isPendingPromise) {
-            await this.executeInAut(eventMessage);
-        }
-
-        const resp = await this.checkStatus(eventMessage.transactionId);
-        return await this.checkCodeResponse(resp);
-    }
-
-    handleExecutionError(err) {
-        const canExtractError = err?.seleniumStack && err.seleniumStack.type === 'JavaScriptError' &&
-            err.seleniumStack.orgStatusMessage;
-
-        if (canExtractError) {
-            const endOfMessage = err.seleniumStack.orgStatusMessage.indexOf('\nBuild info');
-            const reason = err.seleniumStack.orgStatusMessage.slice(0, endOfMessage === -1 ? undefined : endOfMessage);
-            throw new Error(reason);
-        }
-
-        throw err;
-    }
-}
-
-module.exports = BaseJsStepAction;

package/player/stepActions/cliConditionStepAction.js

@@ -1,11 +0,0 @@
-'use strict';
-
-const BaseCliJsStepAction = require('./baseCliJsStepAction');
-
-class CliConditionStepAction extends BaseCliJsStepAction {
-    isFailedResult(resultValue) {
-        return !resultValue;
-    }
-}
-
-module.exports = CliConditionStepAction;

package/player/stepActions/cliJsStepAction.js

@@ -1,11 +0,0 @@
-'use strict';
-
-const BaseCliJsStepAction = require('./baseCliJsStepAction');
-
-class CliJsStepAction extends BaseCliJsStepAction {
-    isFailedResult(resultValue) {
-        return resultValue === false;
-    }
-}
-
-module.exports = CliJsStepAction;

package/player/stepActions/dropFileStepAction.js

@@ -1,34 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const featureFlagService = require('../../commons/featureFlags');
-const downloadFileAndFireDropEvent = require('./scripts/dropEvent');
-const { getLogger } = require('../../commons/logger');
-
-const logger = getLogger('drop-file-step-action');
-
-class DropFileStepAction extends StepAction {
-    async performAction() {
-        const { codeSnippets, utils } = this.sessionPlayerInit;
-        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 dropFileCode = `
-        var getLocatedElement = ${codeSnippets.getLocatedElementCode};
-        var createDropEvent = ${codeSnippets.createDropEvent.toString()};
-        var downloadFileAndFireDropEvent = ${downloadFileAndFireDropEvent.toString()};
-        return downloadFileAndFireDropEvent.apply(null, arguments)
-    `;
-
-        return await this.driver.executeJSWithArray(dropFileCode, [target.locatedElement, fileUrls]);
-    }
-}
-
-module.exports = DropFileStepAction;

package/player/stepActions/evaluateExpressionStepAction.js

@@ -1,52 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const StepAction = require('./stepAction');
-const { getLogger } = require('../../commons/logger');
-
-const logger = getLogger('evaluate-expression-step-action');
-
-class EvaluateExpressionStepAction extends StepAction {
-    async execute() {
-        const step = this.step;
-        const context = this.context;
-        const exportsGlobal = this.exportsGlobal;
-        const exportsTest = this.exportsTest;
-
-        try {
-            logger.info('runner running incoming params evaluation');
-            let incomingParams = context.incomingParams || {};
-            if (_.isEmpty(incomingParams)) {
-                incomingParams = this.sessionPlayerInit.stepParamBuilder.getStepInputs(step, context, exportsGlobal, exportsTest);
-            }
-
-            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 textEvaluateFunction = Function.apply(Function, params.concat([code]));
-            const evaluatedText = textEvaluateFunction.apply(null, args);
-
-            context.data[step.targetName] = evaluatedText;
-            context.data[step.targetId] = evaluatedText;
-            if (context.internalParams) {
-                context.internalParams.add(step.targetId);
-            }
-
-            const result = {
-                success: true,
-                evaluatedText,
-                data: context.data,
-            };
-
-            return result;
-        } catch (e) {
-            const { stepResult } = this.sessionPlayerInit.commonConstants;
-            // TODO: Fix throwing non-error
-            // eslint-disable-next-line no-throw-literal
-            throw { errorType: stepResult.EVALUATE_EXPRESSION_EXCEPTION, resultInfo: { exception: e.toString() }, success: false };
-        }
-    }
-}
-
-module.exports = EvaluateExpressionStepAction;

package/player/stepActions/extensionOnlyStepAction.js

@@ -1,12 +0,0 @@
-const StepAction = require('./stepAction');
-
-class ExtensionOnlyStepAction extends StepAction {
-    async performAction() {
-        return {
-            success: 'skipped',
-            reason: 'This step can run only on Chrome',
-        };
-    }
-}
-
-module.exports = ExtensionOnlyStepAction;

package/player/stepActions/extractTextStepAction.js

@@ -1,19 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-
-class ExtractTextStepAction extends StepAction {
-    async performAction() {
-        const paramName = this.step.extractTextParamName;
-
-        const extractedText = await this.stepActionUtils.extractTargetText(this.getTarget());
-        this.context.data.exports = this.context.data.exports || {};
-        this.context.data.exports[paramName] = extractedText;
-        return {
-            success: true,
-            data: this.context.data,
-        };
-    }
-}
-
-module.exports = ExtractTextStepAction;

package/player/stepActions/hoverStepAction.js

@@ -1,55 +0,0 @@
-const StepAction = require('./stepAction');
-
-const toDOMRect = (height, width, x, y) => ({
-    x,
-    y,
-    width,
-    height,
-    get top() { return this.y; },
-    get left() { return this.x; },
-    get right() { return this.x + this.width; },
-    get bottom() { return this.y + this.height; },
-    toJSON() { },
-});
-
-class HoverStepAction extends StepAction {
-    getRect() {
-        return this.driver.isFirefox() ?
-            this.getTarget().rectWithoutFrameOffset :
-            this.getTarget().rect;
-    }
-
-    async performAction() {
-        const target = this.getTarget();
-        const { seleniumElement, rectWithoutFrameOffset, rect } = target;
-
-        const { width, height } = rect;
-
-        let clickOffsetX = width / 2;
-        let clickOffsetY = height / 2;
-
-        const offset = this.step.element.clickOffset;
-        if (offset && this.step.shouldAccountForMouseOffsetInHover) {
-            const { x, y } = offset;
-
-            if (this.sessionPlayerInit.utils.isWithinTargetRect(toDOMRect(height, width, 0, 0), x, y)) {
-                clickOffsetX = x;
-                clickOffsetY = y;
-            }
-        }
-
-        const offsets = {
-            frameOffset: {
-                x: rect.left - rectWithoutFrameOffset.left,
-                y: rect.top - rectWithoutFrameOffset.top,
-            },
-            rect: rectWithoutFrameOffset,
-            clickOffset: { x: Math.floor(clickOffsetX), y: Math.floor(clickOffsetY) },
-        };
-
-        await this.driver.hover(seleniumElement, offsets);
-        return { success: true };
-    }
-}
-
-module.exports = HoverStepAction;