@testim/testim-cli 3.289.0 → 3.290.1-beta

package/stepPlayers/nodePackageStepPlayback.js

@@ -1,28 +0,0 @@
-'use strict';
-
-const service = require('../agent/routers/cliJsCode/service');
-const { NpmPackageError } = require('../errors');
-const utils = require('../utils');
-
-module.exports.run = async (browser, step) => {
-    const { stepId, testResultId, retryIndex, stepResultId, packageData, timeout } = step.data;
-    try {
-        const data = await service.installPackage(stepId, testResultId, retryIndex, packageData, stepResultId, timeout);
-        return { data, success: true };
-    } catch (err) {
-        if (err instanceof NpmPackageError) {
-            return {
-                success: false,
-                code: 'invalid-node-package',
-                message: err.message,
-            };
-        }
-        if (err instanceof utils.TimeoutError) {
-            return {
-                success: false,
-                code: 'timeout',
-            };
-        }
-        throw err;
-    }
-};

package/stepPlayers/playwrightHybridStepPlayback.js

@@ -1,61 +0,0 @@
-'use strict';
-
-const lazyRequire = require('../commons/lazyRequire');
-const { AbortError } = require('../commons/AbortError');
-const { last } = require('lodash');
-const { getArgumentsFromContext } = require('../codim/hybrid-utils');
-
-module.exports.execute = async function executePlaywrightFunction(player, hybridFunction, step, testimContext, source, abortSignal) {
-    let onAbort;
-
-    try {
-        const playwright = await lazyRequire('playwright');
-
-        if (abortSignal.aborted) {
-            throw new AbortError();
-        }
-
-        const browser = await playwright.chromium.connect({
-            wsEndpoint: player.driver.cdpUrl,
-        });
-
-        if (abortSignal.aborted) {
-            browser.disconnect();
-            throw new AbortError();
-        }
-
-        onAbort = function onAbort() {
-            // this will make any future browser action to fail
-            browser.disconnect();
-        }
-        abortSignal.addEventListener("abort", onAbort);
-
-        //TODO(Benji) https://github.com/microsoft/playwright/issues/1985
-
-        const playwrightContext = await browser.newContext({viewport: null })
-        const pages = await playwrightContext.pages();
-        const page = last(pages);
-        function getLocator(arg) {
-            return page.$(arg.selector);
-        }
-        const args = await getArgumentsFromContext(step, testimContext, getLocator);
-        const fn = hybridFunction.bind(null, page, ...args);
-
-        await fn();
-        return { success: true }
-    } catch (e) {
-        if (abortSignal.aborted) {
-            return { success: false, shouldRetry: false, reason: "aborted" };
-        }
-
-        return {
-            success: false,
-            reason: (e && e.message || e) ,
-            extraInfo: e && e.constructor && e.constructor.name
-        };
-    } finally {
-        if (onAbort) {
-            abortSignal.removeEventListener("abort", onAbort);
-        }
-    }
-}

package/stepPlayers/puppeteerHybridStepPlayback.js

@@ -1,76 +0,0 @@
-'use strict';
-
-const lazyRequire = require('../commons/lazyRequire');
-const { AbortError } = require('../commons/AbortError');
-const { last } = require("lodash");
-const { getArgumentsFromContext } = require('../codim/hybrid-utils');
-
-module.exports.execute = async function executePuppeteerFunction(player, hybridFunction, step, context, source, abortSignal) {
-    let onAbort;
-
-    try {
-        /**
-         * @type {typeof import("puppeteer")}
-         */
-        const puppeteer = await lazyRequire('puppeteer');
-
-        if (abortSignal.aborted) {
-            throw new AbortError();
-        }
-
-        const browser = await puppeteer.connect({
-            browserWSEndpoint: player.driver.cdpUrl,
-            defaultViewport: null, // disable puppeteer resize
-            product: 'chrome', //
-        });
-
-        if (abortSignal.aborted) {
-            browser.disconnect();
-            throw new AbortError();
-        }
-
-        onAbort = function onAbort() {
-            // this will make puppeteer action to fail
-            browser.disconnect();
-        }
-
-        abortSignal.addEventListener("abort", onAbort);
-
-        const pages = await browser.pages();
-        let foundMainPage;
-
-        for (const page of pages) {
-            if (await page.evaluate(function () {
-                return window.__isMainTestimTab;
-            })) {
-                foundMainPage = page;
-                break;
-            }
-        }
-
-        const page = foundMainPage ? foundMainPage : last(pages);
-        function getLocator(arg) {
-            return page.$(arg.selector);
-        }
-
-        const args = await getArgumentsFromContext(step, context, getLocator);
-        const fn = hybridFunction.bind(null, page, ...args);
-
-
-        await fn();
-        return { success: true }
-    } catch (e) {
-        if (abortSignal.aborted) {
-            return { success: false, shouldRetry: false, reason: "aborted" };
-        }
-
-        return {
-            success: false,
-            shouldRetry: false,
-            reason: (e && e.message || e),
-            extraInfo: e && e.constructor && e.constructor.name
-        };
-    } finally {
-        abortSignal.removeEventListener("abort", onAbort);
-    }
-}

package/stepPlayers/remoteStepPlayback.js

@@ -1,80 +0,0 @@
-'use strict';
-
-const cliJsStepPlayback = require('./cliJsStepPlayback');
-const hybridStepPlayback = require('./hybridStepPlayback');
-const nodePackageStepPlayback = require('./nodePackageStepPlayback');
-const testimServicesApi = require('../commons/testimServicesApi');
-const { getLogger } = require('../commons/logger');
-
-const logger = getLogger('step-playback');
-
-const playbacks = {
-    'cli-validation-code-step': cliJsStepPlayback,
-    'cli-wait-for-code-step': cliJsStepPlayback,
-    'cli-action-code-step': cliJsStepPlayback,
-    'cli-api-code-step': cliJsStepPlayback,
-    'cli-condition-step': cliJsStepPlayback,
-    'cli-download-code-step': cliJsStepPlayback,
-    'node-package': nodePackageStepPlayback,
-    'tdk-hybrid': hybridStepPlayback,
-};
-
-async function saveRemoteStep(projectId, resultId, stepId, remoteStepData) {
-    try {
-        return await testimServicesApi.saveRemoteStep(projectId, resultId, stepId, remoteStepData);
-    } catch (e) {
-        logger.error('failed to report remote step state', { projectId, resultId, stepId });
-        return undefined;
-    }
-}
-
-async function onCompleted(projectId, resultId, stepId, runResult, sessionId) {
-    logger.info('finished to run remote step', { stepId, sessionId });
-    const remoteStepData = {
-        status: 'completed',
-        success: true,
-        failureReason: null,
-        data: runResult,
-    };
-
-    return await saveRemoteStep(projectId, resultId, stepId, remoteStepData);
-}
-
-async function onFailed(projectId, resultId, stepId, failureReason, sessionId) {
-    logger.info('failed to run remote step', { stepId, sessionId, failureReason });
-    const remoteStepData = {
-        status: 'completed',
-        success: false,
-        failureReason,
-    };
-
-    return await saveRemoteStep(projectId, resultId, stepId, remoteStepData);
-}
-
-async function executeStep(options, driver, step, resultId) {
-    if (!step?.type || step.status === 'completed') {
-        return undefined;
-    }
-
-    const { project: projectId, projectData, userData } = options;
-    const stepType = step.type;
-    const sessionId = driver.getSessionId();
-    const stepId = step.id;
-    logger.info('start play remote step', { stepType, stepId, sessionId });
-
-    const playback = playbacks[stepType];
-    if (!playback) {
-        return await onFailed(projectId, resultId, stepId, `Failed to find step type ${stepType}`, sessionId);
-    }
-
-    try {
-        const runResult = await playback.run(driver, step, projectData, userData);
-        return await onCompleted(projectId, resultId, stepId, runResult, sessionId);
-    } catch (err) {
-        return await onFailed(projectId, resultId, stepId, err.message, sessionId);
-    }
-}
-
-module.exports = {
-    executeStep,
-};

package/stepPlayers/seleniumHybridStepPlayback.js

@@ -1,84 +0,0 @@
-'use strict';
-
-const lazyRequire = require('../commons/lazyRequire');
-const { getArgumentsFromContext } = require('../codim/hybrid-utils');
-
-module.exports.execute = async function executeSeleniumFunction(player, hybridFunction, step, context, source, abortSignal) {
-    let onAbort;
-
-    // with selenium - we don't have any instrumentation - so we just run the code.
-    try {
-        // selenium hybrid test
-        /**
-         * @type {import("selenium-webdriver")}
-         */
-        const { WebDriver } = await lazyRequire('selenium-webdriver');
-
-        if (abortSignal.aborted) {
-            throw new AbortError();
-        }
-
-        const { Executor, HttpClient } = require('selenium-webdriver/http');
-
-        const webdriverOptions = player.driver.client.requestHandler.defaultOptions;
-        const startPath = player.driver.client.requestHandler.startPath;
-        const seleniumServerUrl = `${webdriverOptions.protocol}://${webdriverOptions.hostname}:${webdriverOptions.port}`;
-        const seleniumUrl = seleniumServerUrl + startPath; // we do not add startPath since selenium-webdriver adds /wd/hub on its own + startPath;
-        const client = new HttpClient(seleniumUrl);
-        const webDriver = new WebDriver(player.getSessionId() , new Executor(client));
-
-        // find main tab
-        await fixSeleniumMainTab(webDriver, player.driver);
-
-        function getLocator(arg) {
-            return webDriver.findElement({ css: arg.selector });
-        }
-
-        const args = await getArgumentsFromContext(step, context, getLocator);
-        const fn = hybridFunction.bind(null, webDriver, ...args);
-
-        onAbort = function onAbort() {
-            // We don't have real way to abort user code,
-            // So we kill the http client of the WebDriver
-            client.send = async function send() {
-                throw new AbortError();
-            }
-        }
-        abortSignal.addEventListener("abort", onAbort);
-
-        await fn();
-        return { success: true };
-    } catch (e) {
-        if (abortSignal.aborted) {
-            return { success: false, shouldRetry: false, reason: "aborted" };
-        }
-
-        return {
-            success: false,
-            shouldRetry: false,
-            reason: (e && e.message || e),
-            extraInfo: e && e.constructor && e.constructor.name
-        };
-    } finally {
-        if (onAbort) {
-            abortSignal.removeEventListener("abort", onAbort);
-        }
-    }
-};
-
-async function fixSeleniumMainTab(webDriver, driver) {
-    if (!driver.cdpUrl) {
-        // remote run
-        return;
-    }
-    {
-        const contexts = await webDriver.getAllWindowHandles();
-        for(const context of contexts) {
-            await webDriver.switchTo().window(context);
-            const isMainTab = await webDriver.executeScript("return window.__isMainTestimTab");
-            if (isMainTab) {
-                break;
-            }
-        }
-    }
-}

package/stepPlayers/tdkHybridStepPlayback.js

@@ -1,112 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const perfLogger = require('../commons/performance-logger');
-const { guid } = require('../utils');
-const { AbortError } = require('../commons/AbortError');
-const { getArgumentsFromContext } = require('../codim/hybrid-utils');
-const { getSessionPlayer } = require('../commons/getSessionPlayerRequire');
-
-module.exports.execute = async function executeTdkFunction(player, hybridFunction, context, loginData, frameManager, step, source, abortSignal) {
-    function onAbort() {
-        player.sessionPlayer.stopPlaying();
-    }
-
-    abortSignal.addEventListener('abort', onAbort);
-
-    function getLocator(arg) {
-        if (step.parameterValues) { // tdk is all grown up and can run real locators
-            const locateStep = step.parameterValues.find(param => param.type === 'locate' && param.id === arg.locatorId);
-            return { elementLocator: locateStep.elementLocator, id: locateStep.id, name: 'Hybrid Step Locator' };
-        }
-        if (!arg.locatedElement.shadowPath) {
-            return arg; // wat
-        }
-        // fallback to selector, this should never happen in practice except when there was
-        // no locator to begin with (like if we expose reverse-hybrid to TDK)
-        return arg.locatedElement.shadowPath[0];
-    }
-    const args = await getArgumentsFromContext(step, context, getLocator);
-    const fn = hybridFunction.bind(null, ...args);
-
-    // assign same framemanager
-    const testId = guid();
-    const executionId = guid(); // we don't use the same execution ID to not associate the run with the suite and trigger bugs in features like "rerun by failed run id"
-    const resultId = context.testResultId; // this isn't the TDK result id - it's the _parent_ result ID tdk nests under.
-    const baseUrl = context.config.baseUrl;
-    const userData = _.cloneDeep(context); // the context contains everything needed as userData except login data
-    userData.loginData = loginData;
-    const sessionPlayerInit = getSessionPlayer();
-    const version = sessionPlayerInit.manifestVersion || 'runner';
-    const isLocalRun = false;
-    const overrideTestConfigId = null;
-    const branch = 'master'; // With TDK - branches are meaningless
-    const testName = `Execute TDK Function '${step.functionName}'`;
-    const ignoreNavigation = true;
-
-
-    const codeTest = {
-        fn,
-        bypassSetup: true, // don't setup and resize according to the TestConfig when starting
-        isBeforeOrAfterTest: true, // not a full test - don't perform "must contain assertions" validation
-        name: testName,
-        sourceCode: fn.toString(),
-        sourceName: fn.name,
-        testId,
-        resultId: guid(), // we don't want to reuse the resultId of the parent for the child - we need a new resultId
-    };
-    const onlyLocalReporting = typeof hybridFunction.results === 'boolean' && !hybridFunction.results;
-    try {
-        perfLogger.log('tdkHybridStepPlayback before addAllTabs');
-        if (frameManager) { // we have a frameManager we can reuse
-            player.sessionPlayer.playbackAutUtils.frameManager = frameManager;
-            player.sessionPlayer.frameManager = frameManager;
-        } else {
-            // otherwise, we have to tell the session player about them tabs
-            //TODO(benji) call getEditorUrl?
-            await player.addAllTabs(null, { loadInfo: true, checkForMainTab: true, takeScreenshots: !onlyLocalReporting }, [player.driver.initialUrl]);
-        }
-        player.sessionPlayer.playbackManager.dontAssociateChildResult = true; // don't associate child result to this test result.
-        player.sessionPlayer.playbackManager.onlyLocalReporting = onlyLocalReporting;
-        perfLogger.log('tdkHybridStepPlayback before playTestByCode');
-        const testResult = await new Promise((resolve, reject) => {
-            if (source === 'agent') {
-                resolveOnTestResultAndNotAssetsUploaded(player, resolve);
-            }
-            function onAbort() {
-                reject(new AbortError());
-                abortSignal.removeEventListener('abort', onAbort);
-            }
-
-            abortSignal.addEventListener('abort', onAbort);
-
-            player.sessionPlayer.playTestByCode(
-                testId, executionId, resultId, baseUrl, userData, version, resolve, isLocalRun, overrideTestConfigId, branch, [codeTest], testName, ignoreNavigation,
-            ).catch(reject);
-        });
-        perfLogger.log('tdkHybridStepPlayback after playTestByCode');
-        // testResult.status?
-        return { success: testResult.success, shouldRetry: false, resultInfo: { testId, executionId, resultId: codeTest.resultId } };
-    } catch (e) {
-        return { success: false, error: e, shouldRetry: false };
-    } finally {
-        abortSignal.removeEventListener('abort', onAbort);
-    }
-};
-
-function resolveOnTestResultAndNotAssetsUploaded(player, resolve) {
-    const { commonConstants } = getSessionPlayer();
-    player.sessionPlayer.playbackManager.on(commonConstants.playback.START, ({ testResult }) => {
-        let runnerStatus = testResult.runnerStatus;
-        Object.defineProperty(testResult, 'runnerStatus', {
-            get() { return runnerStatus; },
-            set(value) {
-                runnerStatus = value;
-                if (value === 'FINISHED') {
-                    // resolve as soon as the runner is finished, before assets are uploaded
-                    resolve(testResult);
-                }
-            },
-        });
-    });
-}