@testim/testim-cli 3.289.0 → 3.290.0-beta

package/workers/WorkerSelenium.js

@@ -1,253 +0,0 @@
-'use strict';
-
-const utils = require('../utils');
-const BaseWorker = require('./BaseWorker');
-const reporter = require('../reports/reporter');
-const perf = require('../commons/performance-logger');
-const WindowUtils = require('../player/utils/windowUtils');
-const SeleniumTestPlayer = require('../player/seleniumTestPlayer');
-const { getLogger } = require('../commons/logger');
-const { PageNotAvailableError } = require('../errors');
-const { preloadTests } = require('../commons/preloadTests');
-const { timeoutMessages } = require('../commons/constants');
-const { getSessionPlayer } = require('../commons/getSessionPlayerRequire');
-
-const logger = getLogger('worker-selenium');
-
-// this navigation timeout is handled from outside the worker, so don't pass a small timeout to navigate
-const NO_NAVIGATION_TIME_LIMIT = 1e9;
-
-class WorkerSelenium extends BaseWorker {
-    /**
-     * @override
-     * @param {import('../testRunHandler')} testRunHandler
-     */
-    initPlayer(testRunHandler) {
-        return new SeleniumTestPlayer(
-            this.id,
-            testRunHandler.runParams,
-            this.options.shouldMonitorPerformance,
-            testRunHandler.automationMode,
-            undefined,
-            testRunHandler.retryCount,
-            testRunHandler.previousTestResultId,
-        );
-    }
-
-    /**
-     * @override
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {string=} customExtensionLocalLocation
-     * @param {SeleniumTestPlayer} seleniumTestPlayer
-     * @param {Awaited<ReturnType<import('../services/gridService')['handleHybridOrVendorIfNeeded']>>} gridInfo
-     */
-    async getBrowserOnce(testRunHandler, customExtensionLocalLocation, seleniumTestPlayer, gridInfo) {
-        perf.log('in WorkerSelenium getBrowserOnce');
-        reporter.onGetSession(this.id, this.testName, testRunHandler.runMode);
-        const { driver } = seleniumTestPlayer;
-
-        this.windowUtils = new WindowUtils(this.id, driver);
-        seleniumTestPlayer.clearSessionTabs();
-
-        const { browserValue } = this.testRunConfig;
-        const baseUrl = testRunHandler.baseUrl;
-
-        try {
-            const fastInit = this.options.useLocalChromeDriver;
-            await driver.init(
-                this.options,
-                this.testName,
-                this.testRunConfig,
-                gridInfo,
-                customExtensionLocalLocation,
-                this.executionId,
-                this.testResultId,
-                testRunHandler.seleniumPerfStats,
-                fastInit,
-                this.lambdatestService,
-            );
-            perf.log('in WorkerSelenium after driver.init');
-            await seleniumTestPlayer.addTab(undefined, { skipLoadInfo: fastInit });
-            perf.log('in WorkerSelenium after addTab');
-            if (!fastInit) {
-                await this.windowUtils.navigate(baseUrl, NO_NAVIGATION_TIME_LIMIT);
-            }
-            await this.windowUtils.validatePageIsAvailable();
-            perf.log('in WorkerSelenium after navigate');
-        } catch (err) {
-            const firefoxPageNotAvailable = err.message && (err.message.startsWith('Malformed URL') || err.message.includes('Reached error page: about:neterror')) &&
-                browserValue === 'firefox';
-
-            const invalidURL = (err.message && err.message === 'invalid argument');
-
-            if (err instanceof PageNotAvailableError || firefoxPageNotAvailable || invalidURL) {
-                throw new PageNotAvailableError(`Page '${baseUrl}' is not available`);
-            }
-
-            logger.error('failed to navigate to page', { err });
-            throw err;
-        }
-    }
-
-    /**
-     * @override
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {import('../player/seleniumTestPlayer')} seleniumTestPlayer
-     */
-    async runTestOnce(testRunHandler, seleniumTestPlayer) {
-        const sessionPlayerInit = getSessionPlayer();
-        const { driver, sessionPlayer } = seleniumTestPlayer;
-
-        const version = sessionPlayerInit.manifestVersion || 'runner';
-
-        reporter.onWaitToTestComplete(this.id, this.isCodeMode);
-
-        setupCliPerformanceMonitoring(sessionPlayer);
-
-        sessionPlayer.playbackManager.executionId = testRunHandler.executionId;
-        sessionPlayer.playbackManager.executionName = testRunHandler.executionName;
-
-        sessionPlayer.setLightweightMode(this.options.lightweightMode);
-        if (testRunHandler.sfdcCredential) {
-            sessionPlayer.setSfdcCredential(testRunHandler.sfdcCredential);
-        }
-        if (sessionPlayerInit.localAssetService) {
-            sessionPlayerInit.localAssetService.initialize({ serverUrl: this.options.localRCASaver });
-        }
-
-        let preloadedTest = null;
-        if (this.options.lightweightMode?.preloadTests) {
-            const preloadedTests = await preloadTests(this.options);
-            preloadedTest = preloadedTests[this.testId];
-        }
-
-        const runSeleniumTest = async () => {
-            if (testRunHandler.automationMode === 'codeful') {
-                // Testim Development Kit test;
-                if (!sessionPlayer.callOrderScheduler) { // old session player
-                    await testRunHandler.waitForExecutionStartedFinished();
-                } else {
-                    sessionPlayer.callOrderScheduler.schedule(
-                        () => testRunHandler.waitForExecutionStartedFinished(),
-                        // this key is shared by clickim and this ensures that we do wait for the execution to be created before we do this.
-                        { key: `test-result:${this.userData.projectId}:${this.testResultId}` },
-                    );
-                }
-                perf.log('right before playTestByCode');
-                // TODO: Fix promise constructor anti-pattern
-                const playTestByCodePromise = new Promise((resolve, reject) => {
-                    sessionPlayer.playTestByCode(
-                        this.testId,
-                        this.executionId,
-                        this.testResultId,
-                        this.baseUrl,
-                        this.userData,
-                        version,
-                        resolve,
-                        false,
-                        this.overrideTestConfigId,
-                        this.branch,
-                        testRunHandler.code,
-                        testRunHandler.testName,
-                    ).catch(reject);
-                });
-                return utils
-                    .promiseTimeout(
-                        playTestByCodePromise.then((testResult) => {
-                            perf.log('right after playTestByCode');
-                            return testResult;
-                        }),
-                        this.testRunTimeout,
-                        timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG,
-                    )
-                    .catch(err => {
-                        if (err instanceof utils.TimeoutError) {
-                            sessionPlayer.stopPlayingOnTestTimeout?.();
-                        }
-                        throw err;
-                    })
-                    .then(testResult => {
-                        testResult.resultId = this.testResultId;
-                        return testResult;
-                    });
-            }
-            const INCOGNITO = false;
-
-            return utils.promiseTimeout(
-                // TODO: Fix promise constructor anti-pattern
-                new Promise((resolve, reject) => {
-                    sessionPlayer.playByTestId(
-                        this.testId,
-                        this.executionId,
-                        this.testResultId,
-                        this.baseUrl,
-                        this.userData,
-                        version,
-                        resolve,
-                        false,
-                        this.overrideTestConfigId,
-                        this.branch,
-                        INCOGNITO,
-                        testRunHandler.remoteRunId,
-                        undefined,
-                        undefined,
-                        preloadedTest,
-                    ).catch(reject);
-                }),
-                this.testRunTimeout,
-                timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG,
-            )
-                .catch((err) => {
-                    if (err instanceof utils.TimeoutError) {
-                        sessionPlayer.stopPlayingOnTestTimeout?.();
-                    }
-                    throw err;
-                })
-                .then(async (testResult) => {
-                    if (sessionPlayerInit.localAssetService) {
-                        await sessionPlayerInit.localAssetService.drain();
-                    }
-                    testResult.stepsResults = null;
-                    testResult.resultId = this.testResultId;
-                    if (!driver.isAlive()) {
-                        logger.warn(`possible grid unresponsive for test ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
-                        testResult.gridIssues = 'could not validate grid is alive';
-                    }
-                    const maxKeepAliveGap = driver.maxKeepAliveGap();
-                    const MAX_KEEP_ALIVE_GAP = 30000;
-                    if (maxKeepAliveGap >= MAX_KEEP_ALIVE_GAP) {
-                        logger.warn(`possible browser keep alive issue ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
-                        testResult.keepAliveIssue = maxKeepAliveGap;
-                    }
-                    const resultWithStats = { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
-                    if (this.lambdatestService.isLambdatestRun()) {
-                        await driver.executeJS(`lambda-status=${!resultWithStats.success ? 'failed' : 'passed'}`).catch(() => {});
-                    }
-                    return resultWithStats;
-                });
-        };
-
-        driver.start();
-
-        perf.log('right before super.runTestOnce in workerSelenium');
-        try {
-            await super.runTestOnce(testRunHandler, seleniumTestPlayer);
-            perf.log('right after super.runTestOnce in workerSelenium');
-            await runSeleniumTest();
-            perf.log('right after runSeleniumTest');
-        } catch (err) {
-            logger.error('failed to run test once', { err });
-            throw err;
-        }
-    }
-}
-function setupCliPerformanceMonitoring(sessionPlayer) {
-    const { playback } = getSessionPlayer().commonConstants;
-    function monitorEvent(event) {
-        sessionPlayer.playbackManager.on(event, () => {
-            perf.log(`Got event ${event}`);
-        });
-    }
-    Object.values(playback).forEach(monitorEvent);
-}
-module.exports = WorkerSelenium;

package/workers/workerUtils.js

@@ -1,20 +0,0 @@
-const gridService = require('../services/gridService');
-const logger = require('../commons/logger').getLogger('worker-utils');
-
-const releaseGridSlot = async (workerId, releaseSlotOnTestFinished, projectId) => {
-    if (!releaseSlotOnTestFinished) {
-        return;
-    }
-    await gridService.releaseGridSlot(workerId, projectId);
-};
-
-const releasePlayer = async (workerId, releaseSlotOnTestFinished, projectId, player) => {
-    logger.info('releasing player', { hasPlayer: Boolean(player) });
-    try {
-        await player?.onDone();
-    } finally {
-        await releaseGridSlot(workerId, releaseSlotOnTestFinished, projectId);
-    }
-};
-
-module.exports.releasePlayer = releasePlayer;