@testim/testim-cli 3.289.0 → 3.290.1-beta

package/workers/BaseWorker.test.js

@@ -1,186 +0,0 @@
-const proxyquire = require('proxyquire');
-
-const { expect, sinon } = require('../../test/utils/testUtils');
-const gridService = require('../services/gridService');
-const reporter = require('../reports/reporter');
-const { PageNotAvailableError, GridError, GetBrowserError } = require('../errors');
-const servicesApi = require('../commons/testimServicesApi');
-const utils = require('../utils');
-
-
-describe('BaseWorker', () => {
-    let worker;
-    let handleHybridStub;
-    let getGridSlotStub;
-    let runTestOnceStub = sinon.stub();
-    let testRunHandlerMock;
-    let testPlayerMock;
-    const onTestStartedStub = sinon.stub();
-    const sandbox = sinon.createSandbox();
-
-    beforeEach(() => {
-        const BaseWorker = proxyquire.noCallThru()('./BaseWorker', {
-            './workerUtils': {
-                releasePlayer: () => sinon.stub().resolves({}),
-            },
-        });
-
-        worker = new BaseWorker(null, {}, null, null, onTestStartedStub, null, () => { /* noop */ });
-        worker.userData = {};
-        worker.options = { gridData: {}, browser: 'chrome', company: { companyId: 'companyId' }, getBrowserTimeout: 1000, getSessionTimeout: 100, getBrowserRetries: 10 };
-        worker.testRunConfig = {};
-
-        testRunHandlerMock = { executionId: 'executionId', testResultId: 'testResultId' };
-        testPlayerMock = { onDone: sinon.spy() };
-
-        sinon.stub(worker, 'initPlayer').returns(testPlayerMock);
-        sinon.stub(worker, 'getBrowserOnce').returns({});
-        runTestOnceStub = sinon.stub(worker, 'runTestOnce');
-        handleHybridStub = sinon.stub(gridService, 'handleHybridOrVendorIfNeeded').callThrough();
-        getGridSlotStub = sinon.stub(gridService, 'getGridSlot').resolves({});
-
-
-        sandbox.stub(utils, 'delay').returns(Promise.resolve());
-        sandbox.stub(reporter);
-    });
-
-    afterEach(() => {
-        handleHybridStub.restore();
-        getGridSlotStub.restore();
-
-        sandbox.restore();
-    });
-
-    describe('getTestPlayer', () => {
-        describe('getSlot', () => {
-            it('should get grid slot from server', async () => {
-                await worker.getTestPlayer(testRunHandlerMock);
-                sinon.assert.calledOnce(getGridSlotStub);
-                sinon.assert.notCalled(utils.delay);
-            });
-            it('should retry getting slot until it succeeds', async () => {
-                getGridSlotStub.onFirstCall().rejects();
-                getGridSlotStub.onSecondCall().resolves({});
-
-                await worker.getTestPlayer(testRunHandlerMock);
-                sinon.assert.calledTwice(getGridSlotStub);
-                sinon.assert.calledOnce(utils.delay);
-            });
-            it('should not proceed to getting browser if all retries used for getting a slot', async () => {
-                getGridSlotStub.resolves({});
-                worker.options.getBrowserRetries = 0;
-                await expect(worker.getTestPlayer(testRunHandlerMock)).to.eventually.be.rejectedWith('No free browser slots in desired grid');
-                sinon.assert.calledOnce(getGridSlotStub);
-                sinon.assert.notCalled(worker.getBrowserOnce);
-                sinon.assert.notCalled(worker.initPlayer);
-                sinon.assert.notCalled(utils.delay);
-            });
-        });
-
-        describe('getBrowserOnce', () => {
-            it('should get browser from grid', async () => {
-                await worker.getTestPlayer(testRunHandlerMock);
-                sinon.assert.calledOnce(getGridSlotStub);
-                sinon.assert.calledOnce(worker.getBrowserOnce);
-                sinon.assert.calledOnce(worker.initPlayer);
-                sinon.assert.notCalled(utils.delay);
-            });
-            it('should retry getting browser until it succeeds', async () => {
-                worker.getBrowserOnce.onFirstCall().rejects();
-                worker.getBrowserOnce.onSecondCall().resolves({});
-
-                await worker.getTestPlayer(testRunHandlerMock);
-                sinon.assert.calledOnce(getGridSlotStub);
-                sinon.assert.calledTwice(worker.getBrowserOnce);
-                sinon.assert.calledTwice(worker.initPlayer);
-                sinon.assert.calledOnce(testPlayerMock.onDone);
-                sinon.assert.calledOnce(utils.delay);
-            });
-            it('should not retry if page is not available', async () => {
-                worker.getBrowserOnce.throws(() => new PageNotAvailableError());
-
-                await expect(worker.getTestPlayer(testRunHandlerMock)).to.eventually.be.rejectedWith(Error);
-                sinon.assert.calledOnce(getGridSlotStub);
-                sinon.assert.calledOnce(worker.getBrowserOnce);
-                sinon.assert.calledOnce(testPlayerMock.onDone);
-                sinon.assert.notCalled(utils.delay);
-            });
-            it('should handle get grid error', async () => {
-                worker.getBrowserOnce.throws(() => new GridError());
-                worker.options.getBrowserRetries = 1;
-
-                await expect(worker.getTestPlayer(testRunHandlerMock)).to.eventually.be.rejectedWith(GetBrowserError);
-                sinon.assert.calledOnce(testPlayerMock.onDone);
-            });
-        });
-
-        describe('hybrid grid', () => {
-            let getHybridGridProviderStub;
-
-            beforeEach(() => {
-                getHybridGridProviderStub = sinon.stub(servicesApi, 'getHybridGridProvider');
-                handleHybridStub.callThrough();
-            });
-            afterEach(() => {
-                getHybridGridProviderStub.restore();
-            });
-
-            it('should not get hybrid provider for non hybrid grid types', async () => {
-                getGridSlotStub.resolves({ type: 'testim', gridId: 'gridId' });
-
-                await worker.getTestPlayer(testRunHandlerMock);
-                sinon.assert.notCalled(getHybridGridProviderStub);
-                sinon.assert.calledOnce(handleHybridStub);
-
-                expect(worker.getBrowserOnce.getCall(0).args[3]).to.shallowDeepEqual({ type: 'testim', gridId: 'gridId' });
-            });
-
-            it('should get hybrid provider after getting grid slot', async () => {
-                getGridSlotStub.resolves({ type: 'testimHybrid', gridId: 'gridId' });
-                getHybridGridProviderStub.resolves({ provider: 'loacker', connectionDetails: { host: 'localhost' } });
-
-                await worker.getTestPlayer(testRunHandlerMock);
-                sinon.assert.calledOnce(handleHybridStub);
-                sinon.assert.calledWith(handleHybridStub, worker.options, { type: 'testimHybrid', gridId: 'gridId' });
-
-                expect(worker.getBrowserOnce.getCall(0).args[3]).to.shallowDeepEqual({ type: 'testimHybrid', gridId: 'gridId', provider: 'loacker', host: 'localhost' });
-            });
-
-            it('should get browser from different provider on each retry', async () => {
-                getGridSlotStub.resolves({ type: 'testimHybrid', gridId: 'gridId' });
-
-                getHybridGridProviderStub.onFirstCall().resolves({ provider: 'loacker', connectionDetails: { host: 'localhost', external: { user: 'user', key: 'password' } } });
-                getHybridGridProviderStub.onSecondCall().resolves({ provider: 'nitzan', connectionDetails: { host: 'google.com', port: 443 } });
-                getHybridGridProviderStub.onThirdCall().resolves({ provider: 'a', connectionDetails: { host: 'google.com', port: 4444 } });
-                worker.getBrowserOnce.onFirstCall().rejects(new Error());
-                worker.getBrowserOnce.onSecondCall().rejects(new Error());
-                worker.getBrowserOnce.onThirdCall().resolves({});
-
-                await worker.getTestPlayer(testRunHandlerMock);
-                sinon.assert.calledThrice(handleHybridStub);
-                sinon.assert.calledWith(handleHybridStub, worker.options, { type: 'testimHybrid', gridId: 'gridId' });
-
-                expect(worker.getBrowserOnce.getCall(0).args[3]).to.shallowDeepEqual({ type: 'testimHybrid', gridId: 'gridId', provider: 'loacker', host: 'localhost', user: 'user', key: 'password' });
-                expect(worker.getBrowserOnce.getCall(1).args[3]).to.shallowDeepEqual({ type: 'testimHybrid', gridId: 'gridId', provider: 'nitzan', host: 'google.com', user: undefined, key: undefined, port: 443 });
-                expect(worker.getBrowserOnce.getCall(2).args[3]).to.shallowDeepEqual({ type: 'testimHybrid', gridId: 'gridId', provider: 'a', host: 'google.com', user: undefined, key: undefined, port: 4444 });
-            });
-        });
-
-        describe('runTest', () => {
-            it('should call the runTestOnc with the base url of the test object we acquired from onTestStarted', async () => {
-                const testRunHandler = {
-                    _baseUrl: 'https://testim.io',
-                    testRunHandler: () => sinon.stub().returns(42),
-                    clearTestResult: () => sinon.stub().returns(42),
-                };
-                onTestStartedStub.returns({
-                    config: {
-                        baseUrl: 'http://demo.testim.io/',
-                    },
-                });
-                await worker.runTest(testRunHandler);
-                expect(runTestOnceStub.firstCall.firstArg._baseUrl).to.equals('http://demo.testim.io/');
-            });
-        });
-    });
-});

package/workers/WorkerAppium.js

@@ -1,180 +0,0 @@
-'use strict';
-
-const jsdom = require('jsdom');
-const BaseWorker = require('./BaseWorker');
-const config = require('../commons/config');
-const reporter = require('../reports/reporter');
-const AppiumTestPlayer = require('../player/appiumTestPlayer');
-const testimServicesApi = require('../commons/testimServicesApi');
-const desiredCapabilitiesBuilder = require('../commons/testimDesiredCapabilitiesBuilder');
-const { getSessionPlayer } = require('../commons/getSessionPlayerRequire');
-const { getLogger } = require('../commons/logger');
-
-const logger = getLogger('worker-appium');
-
-class WorkerAppium extends BaseWorker {
-    /**
-     * @override
-     * @param {import('../testRunHandler')} testRunHandler
-     */
-    initPlayer(testRunHandler) {
-        return new AppiumTestPlayer(
-            this.id,
-            testRunHandler.runParams,
-            this.options.shouldMonitorPerformance,
-            testRunHandler.automationMode,
-            undefined,
-            testRunHandler.retryCount,
-            testRunHandler.previousTestResultId,
-        );
-    }
-
-    async getBrowserOnce(testRunHandler, customExtensionLocalLocation, appiumTestPlayer, gridInfo) {
-        reporter.onGetSession(this.id, this.testName, testRunHandler.runMode);
-        const { driver } = appiumTestPlayer;
-        const projectType = this.options.projectData.type;
-        const nativeApp = await testRunHandler.getNativeAppData();
-        const androidActivityWait = projectType === 'android' ? testRunHandler.androidActivityWait : null;
-        let appPath = testRunHandler.nativeAppLink;
-        if (this.options.appId) {
-            const { project: projectId, appId } = this.options;
-            const mobileApp = await testimServicesApi.getAppDetails({ appId, projectId });
-            if (!mobileApp) {
-                logger.error('mobile app not found', { appId, projectId });
-                throw new Error('mobile app not found');
-            }
-            appPath = `${config.SERVICES_HOST}/storage${mobileApp.filePath}?access_token=${this.options.authData.token}`;
-        }
-        try {
-            const capabilities = desiredCapabilitiesBuilder.buildAppiumOptions({
-                projectType,
-                gridInfo,
-                testRunConfig: this.testRunConfig,
-                nativeApp,
-                options: this.options,
-                appPath,
-                androidActivityWait,
-            });
-
-            const activeSession = await driver.remote(capabilities);
-            driver.activeSession = activeSession;
-            await this.updateDeviceInfo(testRunHandler, activeSession);
-            logger.info(`init new appium session testName: ${this.testName}`, { sessionId: activeSession.sessionId, testResultId: this.testResultId, nativeApp });
-        } catch (err) {
-            //TODO:  catch app status validation
-            logger.error('failed to start application', { err });
-            throw err;
-        }
-    }
-
-    getServerAddressFromGrid(testRunHandler) {
-        const { host, port, accessToken } = testRunHandler._options.gridData;
-        return `https://${host}:${port}/v0/${accessToken}/wd/hub`;
-    }
-
-    async updateDeviceInfo(testRunHandler, activeSession) {
-        const {
-            _executionId, _testId, _testResultId,
-            _options: { project: projectId },
-        } = testRunHandler;
-        const { projectData: { type: projectType }, company: { companyId }, gridData: { gridId } } = this.options;
-
-        const selectedDeviceArr = await testimServicesApi.getMobileDevicesFromGrid({ projectId, projectType, companyId, gridId, selectors: `device_id:${activeSession.capabilities.udid}` });
-        const deviceName = selectedDeviceArr[0]?.name;
-
-        const device = {
-            name: deviceName,
-            model: activeSession.capabilities.deviceModel,
-            osVersion: activeSession.capabilities.platformVersion,
-            udid: activeSession.capabilities.udid,
-            osType: activeSession.capabilities.platformName,
-            scaleFactor: activeSession.capabilities.pixelRatio,
-            virtual: false,
-        };
-        await testimServicesApi.updateTestStatus(
-            projectId,
-            _executionId,
-            _testId,
-            _testResultId,
-            'RUNNING',
-            { device },
-        );
-    }
-
-    getDirectAddressConnection(activeSessionCapabilities) {
-        const { directConnectProtocol: protocol, directConnectHost: host, directConnectPort: port, directConnectPath: path } = activeSessionCapabilities;
-        if (protocol && host && port && path) {
-            return `${protocol}://${host}:${port}${path}`;
-        }
-        return undefined;
-    }
-
-    /**
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {import('../player/appiumTestPlayer')} appiumTestPlayer
-     */
-    async runTestOnce(testRunHandler, appiumTestPlayer) {
-        const sessionPlayerInit = getSessionPlayer();
-        const { driver, sessionPlayer } = appiumTestPlayer;
-        const version = sessionPlayerInit.manifestVersion || 'runner';
-
-        reporter.onWaitToTestComplete(this.id, this.isCodeMode);
-
-        sessionPlayer.playbackManager.executionId = testRunHandler.executionId;
-        sessionPlayer.playbackManager.executionName = testRunHandler.executionName;
-
-        const serverAddress = this.getDirectAddressConnection(driver.activeSession.capabilities) || this.getServerAddressFromGrid(testRunHandler);
-        const DOMParser = new jsdom.JSDOM('').window.DOMParser;
-        sessionPlayer.playbackManager.appiumApi = new sessionPlayerInit.AppiumApi(serverAddress, driver.activeSession.sessionId, DOMParser);
-        if (sessionPlayerInit.localAssetService) {
-            sessionPlayerInit.localAssetService.initialize({ serverUrl: this.options.localRCASaver });
-        }
-        async function runAppiumTest() {
-            try {
-                const INCOGNITO = false;
-                const testResult = await new Promise((resolve, reject) =>
-                    // eslint-disable-next-line no-promise-executor-return
-                    sessionPlayer.playByTestId(
-                        this.testId,
-                        this.executionId,
-                        this.testResultId,
-                        this.baseUrl,
-                        this.userData,
-                        version,
-                        resolve,
-                        false,
-                        this.overrideTestConfigId,
-                        this.branch,
-                        INCOGNITO,
-                        testRunHandler.remoteRunId,
-                        undefined,
-                        undefined,
-                        undefined,
-                    ).catch(reject),
-                );
-                if (sessionPlayerInit.localAssetService) {
-                    await sessionPlayerInit.localAssetService.drain();
-                }
-                testResult.stepsResults = null;
-                testResult.resultId = this.testResultId;
-                const resultWithStats = { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
-                return resultWithStats;
-            } catch (err) {
-                //TODO: add test timeout and handle Timeout Error TBD
-                // if (err instanceof TimeoutError && sessionPlayer.stopPlayingOnTestTimeout) {
-                //     sessionPlayer.stopPlayingOnTestTimeout();
-                // }
-                logger.error('error while running appium tests', { err });
-                throw err;
-            }
-        }
-        try {
-            await super.runTestOnce(testRunHandler, appiumTestPlayer);
-            return await runAppiumTest.call(this);
-        } catch (err) {
-            logger.error('failed to run test once', { err });
-            throw err;
-        }
-    }
-}
-module.exports = WorkerAppium;

package/workers/WorkerExtension.js

@@ -1,192 +0,0 @@
-'use strict';
-
-const BaseWorker = require('./BaseWorker');
-const reporter = require('../reports/reporter');
-const perf = require('../commons/performance-logger');
-const ExtensionTestPlayer = require('../player/extensionTestPlayer');
-const ChromeLauncherTestPlayer = require('../player/chromeLauncherTestPlayer');
-const { TimeoutError } = require('../errors');
-const { promiseTimeout } = require('../utils');
-const { getLogger } = require('../commons/logger');
-const { timeoutMessages, stepResult } = require('../commons/constants');
-
-const logger = getLogger('worker-ext');
-
-class WorkerExtension extends BaseWorker {
-    /** @override */
-    initPlayer() {
-        if (this.options.useChromeLauncher) {
-            return new ChromeLauncherTestPlayer(this.id);
-        }
-        return new ExtensionTestPlayer(this.id);
-    }
-
-    /**
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {string=} customExtensionLocalLocation
-     * @param {import('../player/extensionTestPlayer')} player
-     * @param {Awaited<ReturnType<import('../services/gridService')['getGridSlot']>>} gridInfo
-     */
-    async _getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
-        const { driver } = player;
-        try {
-            return await driver.init(
-                this.options,
-                this.testName,
-                this.testRunConfig,
-                gridInfo,
-                customExtensionLocalLocation,
-                this.executionId,
-                this.testResultId,
-                testRunHandler.seleniumPerfStats,
-                this.options.lightweightMode?.general,
-                this.lambdatestService
-            );
-        } catch (err) {
-            logger.error('failed to get browser', {
-                err,
-                gridInfo,
-                testId: testRunHandler.testId,
-                resultId: testRunHandler.testResultId,
-            });
-            throw err;
-        }
-    }
-
-    /** @override */
-    async getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
-        reporter.onGetSession(this.id, this.testName, testRunHandler.runMode);
-        return this._getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo);
-    }
-
-    /**
-     * @override
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {import('../player/extensionTestPlayer') | import('../player/chromeLauncherTestPlayer')} player
-     */
-    async runTestOnce(testRunHandler, player) {
-        const { driver } = player;
-        const { testResultId, executionId, testId } = this;
-        perf.log('WorkerExtension runTestOnce');
-
-        const runViaCdpOrFallbackToAPI = async () => {
-            const testTimeout = this.options.timeoutWasGiven ? Math.max(10000, this.options.timeout) : this.options.testStartTimeout;
-            try {
-                return await promiseTimeout(testRunHandler.runTestUsingCDP(driver.cdpTestRunner), testTimeout, timeoutMessages.TEST_START_TIMEOUT_MSG);
-            } catch (err) {
-                if (!(err instanceof TimeoutError)) {
-                    throw err;
-                }
-                logger.warn('timeout while running test using CDP. Running checkViaRestAPIIfTestStarted', { testResultId });
-                return await testRunHandler.checkViaRestAPIIfTestStarted();
-            }
-        };
-        const navigateChromeSessionToRunTestim = async (url, startStatusDetails) => {
-            try {
-                const res = await driver.url(url);
-                startStatusDetails.driverUrlFinished = true;
-                return res;
-            } catch (err) {
-                logger.error('error from driver.url', { err, testResultId, executionId, testId, url, urlLength: url.length });
-                throw err;
-            }
-        };
-        const updateRunHandlerThatTestStartedAndChangeStatusDetails = async (startStatusDetails) => {
-            const res = await testRunHandler.onStarted(this.options.testStartTimeout);
-            startStatusDetails.testRunHandlerOnStartedHadFinished = true;
-            return res;
-        };
-
-        const runExtTest = async () => {
-            perf.log('WorkerExtension runExtTest');
-            const disableRemoteStep = this.options.lightweightMode?.disableRemoteStep || this.options.disableSockets;
-            if (!disableRemoteStep) {
-                testRunHandler.listenToRemoteStep(driver);
-            }
-            if (this.options.useChromeLauncher) {
-                reporter.onWaitToTestStart(this.id);
-                reporter.onWaitToTestComplete(this.id, this.isCodeMode);
-                try {
-                    const testResult = await runViaCdpOrFallbackToAPI();
-                    return { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
-                } catch (err) {
-                    logger.warn('failed to run test via CDP', { err });
-                    throw err;
-                }
-            }
-
-            const startStatusDetails = { driverUrlFinished: false, testRunHandlerOnStartedHadFinished: false }; //for logging / debugging purposes
-
-            try {
-                const url = await testRunHandler.getRunTestUrl();
-                reporter.onWaitToTestStart(this.id);
-                try {
-                    await promiseTimeout(Promise.all([
-                        navigateChromeSessionToRunTestim(url, startStatusDetails),
-                        updateRunHandlerThatTestStartedAndChangeStatusDetails(startStatusDetails),
-                    ]), this.options.testStartTimeout, timeoutMessages.TEST_START_TIMEOUT_MSG);
-                } catch (err) {
-                    if (!(err instanceof TimeoutError)) {
-                        throw err;
-                    }
-                    logger.warn('timeout occurred (see log\'s payload). Running checkViaRestAPIIfTestStarted', { testResultId, executionId, testId, ...startStatusDetails });
-                    await testRunHandler.checkViaRestAPIIfTestStarted();
-                }
-
-                reporter.onWaitToTestComplete(this.id, this.isCodeMode);
-                const onBrowserClosed = (err) => {
-                    testRunHandler.onCompletedCleanup();
-                    logger.warn('on browser closed error detected', { err, testResultId, executionId, testId });
-                    driver.unregisterToClosedBrowser(onBrowserClosed);
-                    err.type = stepResult.BROWSER_CLOSED;
-                    throw err;
-                };
-                driver.registerToClosedBrowser(onBrowserClosed);
-                try {
-                    const testResult = await promiseTimeout(testRunHandler.onCompleted(), this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG);
-                    driver.unregisterToClosedBrowser(onBrowserClosed);
-                    if (this.lambdatestService.isLambdatestRun()) {
-                        await driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => { });
-                    }
-                    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;
-                    }
-                    return { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
-                } catch (err) {
-                    logger.warn('timeout wait until test completed', { err, testResultId, executionId, testId });
-                    // complete time out
-                    throw new Error(err);
-                } finally {
-                    driver.unregisterToClosedBrowser(onBrowserClosed);
-                }
-            } catch (err) {
-                logger.warn('failed to start url', { err });
-                throw new Error(err);
-            }
-        };
-
-        driver.start();
-
-        try {
-            await super.runTestOnce(testRunHandler, player);
-            perf.log('WorkerExtension super.runTestOnce');
-            return await runExtTest();
-        } catch (err) {
-            logger.error('failed to run test', {
-                err,
-                testId: testRunHandler.testId,
-                resultId: testRunHandler.testResultId,
-            });
-            throw err;
-        }
-    }
-}
-
-module.exports = WorkerExtension;

package/workers/WorkerExtensionSingleBrowser.js

@@ -1,77 +0,0 @@
-'use strict';
-
-const { delay } = require('../utils');
-const { releasePlayer } = require('./workerUtils');
-const WorkerExtension = require('./WorkerExtension');
-const perf = require('../commons/performance-logger');
-const reporter = require('../reports/reporter');
-const logger = require('../commons/logger').getLogger('base-worker');
-
-const DELAY_BETWEEN_TESTS = 500;
-
-class WorkerExtensionSingleBrowser extends WorkerExtension {
-    async _releasePlayer() {
-        if (!this.testPlayer) {
-            return;
-        }
-        await releasePlayer(this.id, this.releaseSlotOnTestFinished, this.userData?.projectId, this.testPlayer);
-        this.testPlayer = null;
-    }
-
-    onQueueCompleted() {
-        return this._releasePlayer();
-    }
-
-    async getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
-        reporter.onGetSession(this.id, `worker ${this.id}`, testRunHandler.runMode);
-        return this._getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo);
-    }
-
-    /**
-     * @override
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {string=} customExtensionLocalLocation
-     */
-    async getTestPlayer(testRunHandler, customExtensionLocalLocation) {
-        if (this.testPlayer && !this.testPlayer.driver.isAlive()) {
-            logger.warn('WorkerExtensionSingleBrowser is releasing a dead player', { workerId: this.id });
-            await this._releasePlayer();
-        }
-        if (!this.testPlayer) {
-            this.testPlayer = await super.getTestPlayer(testRunHandler, customExtensionLocalLocation);
-        }
-        return this.testPlayer;
-    }
-
-    /**
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {string=} customExtensionLocalLocation
-     * @param {boolean=} shouldRerun
-     */
-    async runTest(testRunHandler, customExtensionLocalLocation, shouldRerun) {
-        const quarantineResult = this.handleQuarantine(testRunHandler);
-        if (quarantineResult) {
-            return quarantineResult;
-        }
-
-        perf.log('before runTest onTestStarted single browser');
-        const test = await this.onTestStarted(this.id, testRunHandler.testId, testRunHandler.testResultId, shouldRerun, testRunHandler.retryKey);
-        testRunHandler._baseUrl = test.config.baseUrl;
-        const testPlayer = await this.getTestPlayer(testRunHandler, customExtensionLocalLocation);
-
-        testRunHandler.markClearBrowser();
-        return await this.runTestOnce(testRunHandler, testPlayer);
-    }
-
-    async runTestCleanup() {
-        if (!this.executionQueue.hasMoreTests()) {
-            await this.onQueueCompleted();
-            return;
-        }
-        if (this.options.lightweightMode?.general) {
-            await delay(DELAY_BETWEEN_TESTS);
-        }
-    }
-}
-
-module.exports = WorkerExtensionSingleBrowser;