@testim/testim-cli 3.289.0 → 3.290.0-beta

package/utils/stringUtils.test.js

@@ -1,22 +0,0 @@
-const chai = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
-const stringUtils = require('./stringUtils');
-
-const expect = chai.expect;
-
-describe('stringUtils', () => {
-    describe('getTestUrl', () => {
-        it('should create properly escaped test URL', () => {
-            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test')).to.equal('http://localhost:8080/#/project/project/branch/master/test/test');
-            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result')).to.equal('http://localhost:8080/#/project/project/branch/master/test/test?result-id=result');
-            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', null)).to.equal('http://localhost:8080/#/project/project/branch/master/test/test?result-id=result');
-            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'normal-branch-name'))
-                .to.equal('http://localhost:8080/#/project/project/branch/normal-branch-name/test/test?result-id=result');
-            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch/with/slashes'))
-                .to.equal('http://localhost:8080/#/project/project/branch/branch%2Fwith%2Fslashes/test/test?result-id=result');
-            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch with spaces'))
-                .to.equal('http://localhost:8080/#/project/project/branch/branch%20with%20spaces/test/test?result-id=result');
-            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'encoded%20branch'))
-                .to.equal('http://localhost:8080/#/project/project/branch/encoded%2520branch/test/test?result-id=result');
-        });
-    });
-});

package/utils/timeUtils.js

@@ -1,25 +0,0 @@
-//@ts-check
-
-'use strict';
-
-const moment = require('moment');
-
-/**
- * @param {moment.DurationInputArg1} ms
- */
-function getDuration(ms) {
-    const duration = moment.duration(ms);
-    return `${duration.hours()}:${duration.minutes()}:${duration.seconds()}.${duration.milliseconds()}`;
-}
-
-/**
- * @param {moment.DurationInputArg1} ms
- */
-function getDurationSec(ms) {
-    return moment.duration(ms).asSeconds();
-}
-
-module.exports = {
-    getDuration,
-    getDurationSec,
-};

package/utils/utils.test.js

@@ -1,27 +0,0 @@
-const chai = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
-const utils = require('./index');
-
-const expect = chai.expect;
-
-describe('utils', () => {
-    describe('calcPercentile', () => {
-        it('should calc some precentiles', () => {
-            // Arrange:
-            const arr = [4, 5, 1, 2, 7, 8, 3, 6, 9, 10];
-
-            // Act:
-            const p0 = utils.calcPercentile(arr, 0);
-            const p50 = utils.calcPercentile(arr, 50);
-            const p90 = utils.calcPercentile(arr, 90);
-            const p95 = utils.calcPercentile(arr, 95);
-            const p100 = utils.calcPercentile(arr, 100);
-
-            // Assert:
-            expect(p0).to.eql(1);
-            expect(p50).to.eql(5);
-            expect(p90).to.eql(9);
-            expect(p95).to.eql(10);
-            expect(p100).to.eql(10);
-        });
-    });
-});

package/workers/BaseWorker.js

@@ -1,498 +0,0 @@
-'use strict';
-
-const moment = require('moment');
-const pRetry = require('p-retry');
-const ms = require('ms');
-
-const { timeoutMessages, testRunStatus, stepResult, runnerTestStatus, CLI_MODE } = require('../commons/constants');
-const logger = require('../commons/logger').getLogger('base-worker');
-const testResultService = require('../commons/socket/testResultService');
-const remoteStepService = require('../commons/socket/remoteStepService');
-const { isNetworkHealthy, didNetworkConnectivityTestFail } = require('../commons/httpRequest');
-const testimServicesApi = require('../commons/testimServicesApi');
-const gridService = require('../services/gridService');
-const LambdatestService = require('../services/lambdatestService');
-const reporter = require('../reports/reporter');
-const utils = require('../utils');
-const { releasePlayer } = require('./workerUtils');
-const featureFlags = require('../commons/featureFlags');
-const perf = require('../commons/performance-logger');
-const {
-    SeleniumError, StopRunOnError, GridError, GetBrowserError, NotImplementedError, PageNotAvailableError, GridConcurrencyError,
-} = require('../errors');
-
-const { GET_BROWSER_TIMEOUT_MSG, TEST_START_TIMEOUT_MSG, TEST_COMPLETE_TIMEOUT_MSG } = timeoutMessages;
-const { SETUP_TIMEOUT, NETWORK_ERROR, GRID_ERROR, BROWSER_CLOSED, SELENIUM_ERROR, UNKNOWN_ERROR } = stepResult;
-
-const DELAY_BETWEEN_TESTS = ms('1s');
-let ordinal = 1;
-
-/**
- * @param {string} testId
- * @param {string} testName
- * @param {string} resultId
- * @param {string} reason
- */
-function buildFailureResult(testId, testName, resultId, reason) {
-    return {
-        testId,
-        reason,
-        name: testName,
-        resultId,
-        success: false,
-    };
-}
-
-class BaseWorker {
-    /**
-     * @param {import('../executionQueue')} executionQueue
-     * @param {import('../runOptions').RunnerOptions} options
-     * @param {string=} customExtensionLocalLocation
-     * @param {string} executionId
-     * @param {(workerId: number, testId: string, resultId: string, isRerun: boolean | undefined, testRetryKey: `${number}:${number}` ) => Promise<any>} onTestStarted
-     * @param {(workerId: number, testId: string, testResult: any, sessionId: string, shouldRerun: boolean | undefined) => Promise<void>} onTestCompleted
-     * @param {import('../testRunStatus')['onGridSlot']} onGridSlot
-     * @param {(workerId: number, testResult: { name: string; testId: string; resultId: string; runnerStatus: 'SKIPPED'; testStatus: 'quarantine' }) => void} onTestIgnored
-     * @param {boolean=} releaseSlotOnTestFinished
-     */
-    constructor(executionQueue, options, customExtensionLocalLocation, executionId, onTestStarted, onTestCompleted, onGridSlot, onTestIgnored, releaseSlotOnTestFinished = true) {
-        this.lambdatestService = new LambdatestService();
-
-        this.id = BaseWorker.getWorkerId();
-        this.executionQueue = executionQueue;
-        this.customExtensionLocalLocation = customExtensionLocalLocation;
-
-        this.isCodeMode = options.files && options.files.length > 0;
-        this.baseUrl = options.baseUrl;
-        this.isRegressionBaselineRun = options.isRegressionBaselineRun;
-        this.testRunTimeout = options.timeout;
-        this.onTestStarted = onTestStarted;
-        this.onTestCompleted = onTestCompleted;
-        this.onGridSlot = onGridSlot;
-        this.onTestIgnored = onTestIgnored;
-        this.releaseSlotOnTestFinished = releaseSlotOnTestFinished;
-
-        this.userData = options.userData;
-        this.executionId = executionId;
-        this.options = options;
-    }
-
-    static getWorkerId() {
-        return ordinal++;
-    }
-
-    /**
-     * @param {string} browser
-     * @param {import('../testRunHandler')} testRunHandler
-     */
-    async getGridSlot(browser, testRunHandler) {
-        const slot = await gridService.getGridSlot(browser, testRunHandler.executionId, this.options, this.id);
-        this.onGridSlot(testRunHandler.testResultId, slot);
-        return slot;
-    }
-
-    /** @param {import('../testRunHandler')} testRunHandler */
-    async getSlotOnce(testRunHandler) {
-        const { browserValue } = this.testRunConfig;
-        reporter.onGetSlot(this.id, browserValue || 'chrome');
-        const gridInfo = await this.getGridSlot(browserValue, testRunHandler);
-        return gridInfo;
-    }
-
-    /**
-     * @abstract
-     * @returns {import('../player/appiumTestPlayer') | import('../player/seleniumTestPlayer')  | import('../player/extensionTestPlayer') | import('../player/chromeLauncherTestPlayer')}
-     */
-    initPlayer() {
-        throw new NotImplementedError(true);
-    }
-
-    async getBrowserOnce() {
-        throw new NotImplementedError(true);
-    }
-
-    /**
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {ReturnType<typeof this['initPlayer']>} player
-     */
-    async runTestOnce(testRunHandler, player) {
-        testRunHandler.sessionId = player.getSessionId();
-        logger.info('Test run started', {
-            testId: testRunHandler.testId,
-            resultId: testRunHandler.testResultId,
-            seleniumSession: player.getSessionId(),
-        });
-
-        return await testRunHandler.clearTestResult();
-    }
-
-    /** @param {import('../testRunHandler')} testRunHandler */
-    handleQuarantine(testRunHandler) {
-        if (!utils.isQuarantineAndNotRemoteRun({ testStatus: testRunHandler.testStatus }, this.options)) {
-            return undefined;
-        }
-        const testResult = {
-            name: testRunHandler.testName,
-            testId: testRunHandler.testId,
-            resultId: testRunHandler.testResultId,
-            runnerStatus: runnerTestStatus.SKIPPED,
-            testStatus: testRunHandler.testStatus,
-        };
-        this.onTestIgnored(this.id, testResult);
-        return testResult;
-    }
-
-    setSessionTimeout() {
-        if (this.options.mode === CLI_MODE.APPIUM) {
-            return Math.max(ms('180s'), this.options.getSessionTimeout);
-        }
-        return Math.max(this.lambdatestService.getSessionTimeout, this.options.getSessionTimeout);
-    }
-
-    /**
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {string=} customExtensionLocalLocation
-     */
-    async getTestPlayer(testRunHandler, customExtensionLocalLocation) {
-        const projectId = this.userData?.projectId;
-        let testPlayer;
-
-        try {
-            perf.log('before getSlotOnce retries');
-            let failedGetSlotAttempts = 0;
-
-            let gridInfo = await pRetry(async () => {
-                const startTime = Date.now();
-                try {
-                    return await utils.promiseTimeout(this.getSlotOnce(testRunHandler), this.options.getBrowserTimeout, timeoutMessages.GET_BROWSER_TIMEOUT_MSG);
-                } catch (error) {
-                    const logDetails = { testId: this.testId, testResultId: this.testResultId, executionId: this.executionId };
-                    if (error instanceof GridConcurrencyError) {
-                        logger.info('could not get grid slot due to concurrency issue', logDetails);
-                    } else {
-                        logger.error('error getting grid slot', { error, ...logDetails });
-                    }
-                    failedGetSlotAttempts++;
-                    await utils.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
-                    throw error;
-                }
-            }, { retries: this.options.getBrowserRetries - 1, minTimeout: 0, factor: 1 });
-            perf.log('after getSlotOnce retries');
-
-            perf.log('before getBrowserOnce retries');
-            const getBrowserRetriesNumber = this.options.getBrowserRetries - failedGetSlotAttempts;
-            if (!getBrowserRetriesNumber) {
-                throw new Error('No free browser slots in desired grid');
-            }
-            let failedGetBrowserAttempts = 0;
-            testPlayer = await pRetry(async () => {
-                const startTime = Date.now();
-                const player = this.initPlayer(testRunHandler);
-                try {
-                    gridInfo = await gridService.handleHybridOrVendorIfNeeded(
-                        this.options, gridInfo, this.testRunConfig, this.lambdatestService, { maxRetries: getBrowserRetriesNumber, currentRetry: failedGetBrowserAttempts + 1 },
-                    );
-                    this.options.gridData.provider = gridInfo.provider;
-                    this.options.gridData.host = gridInfo.host;
-                    this.options.gridData.failedGetBrowserAttempts = failedGetBrowserAttempts;
-                    const getSessionTimeout = this.setSessionTimeout();
-                    perf.log('before getBrowserOnce');
-                    const getBrowserRes = await utils.promiseTimeout(
-                        this.getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo),
-                        getSessionTimeout,
-                        timeoutMessages.GET_BROWSER_TIMEOUT_MSG,
-                    );
-                    perf.log('after getBrowserOnce');
-                    reporter.onGetBrowserSuccess(this.id, projectId);
-                    return player || getBrowserRes;
-                } catch (error) {
-                    const grid = { provider: gridInfo.provider, host: gridInfo.host, failedGetBrowserAttempts, id: this.options.gridData.gridId, type: gridInfo.type };
-                    const instanceType = this.options.mode === CLI_MODE.APPIUM ? 'device' : 'browser';
-                    logger.error(`error getting ${instanceType} from grid`, { error, testId: this.testId, testResultId: this.testResultId, executionId: this.executionId, grid });
-                    reporter.onGetBrowserFailure(this.id, projectId, ++failedGetBrowserAttempts);
-                    player.onDone();
-
-                    if (!(error instanceof PageNotAvailableError)) {
-                        await utils.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
-                    }
-                    throw error;
-                }
-            }, { retries: getBrowserRetriesNumber - 1, minTimeout: 0, factor: 1 });
-            perf.log('after getBrowserOnce retries');
-        } catch (err) {
-            await releasePlayer(this.id, this.releaseSlotOnTestFinished, projectId, testPlayer);
-            if (err instanceof PageNotAvailableError) {
-                throw err;
-            }
-            if (err instanceof GridError) {
-                throw new GetBrowserError(err, GRID_ERROR);
-            }
-            throw new GetBrowserError(err, SELENIUM_ERROR);
-        }
-
-        return testPlayer;
-    }
-
-    /**
-     * @param {import('../testRunHandler')} testRunHandler
-     * @param {string=} customExtensionLocalLocation
-     * @param {boolean=} shouldRerun
-     */
-    async runTest(testRunHandler, customExtensionLocalLocation, shouldRerun) {
-        perf.log('inside runTest');
-        const projectId = this.userData?.projectId;
-        const quarantineResult = this.handleQuarantine(testRunHandler);
-        if (quarantineResult) {
-            return quarantineResult;
-        }
-
-        perf.log('before runTest onTestStarted');
-        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);
-        try {
-            return await this.runTestOnce(testRunHandler, testPlayer);
-        } finally {
-            await releasePlayer(this.id, this.releaseSlotOnTestFinished, projectId, testPlayer);
-        }
-    }
-
-    async runTestCleanup() {
-        return undefined;
-    }
-
-    onQueueCompleted() {
-        return undefined;
-    }
-
-    run() {
-        const runNextTest = () => process.nextTick(() => this.run());
-
-        /**
-         * @param {*} testResult
-         * @param {import('../testRunHandler')} testRunHandler
-         * @param {Error=} err
-         */
-        const onRunComplete = async (testResult, testRunHandler, err) => {
-            if (utils.isQuarantineAndNotRemoteRun(testResult, this.options)) {
-                return runNextTest();
-            }
-            const sessionId = testRunHandler.sessionId;
-
-            const isTimeoutError = (timeoutMsg) => err.message.includes(timeoutMsg);
-            const isIgnoreErrors = err && (err instanceof GetBrowserError);
-            const isTimeoutErrors = err && (isTimeoutError(TEST_START_TIMEOUT_MSG) || isTimeoutError(TEST_COMPLETE_TIMEOUT_MSG));
-
-            const shouldRerun =
-                !testResult.success &&
-                (
-                    (testRunHandler.hasMoreRetries() && !isIgnoreErrors && !isTimeoutErrors) ||
-                    (isTimeoutErrors && testRunHandler.hasMoreTimeoutRetries())
-                );
-
-            try {
-                const testRetryKey = testRunHandler.retryKey;
-                testResult.testRetryKey = testRetryKey;
-                await this.onTestCompleted(this.id, this.testId, testResult, sessionId, shouldRerun);
-                if (this.executionQueue.hasMoreTests() && !this.options.lightweightMode?.general) {
-                    await utils.delay(DELAY_BETWEEN_TESTS);
-                }
-                await this.runTestCleanup();
-                if (shouldRerun) {
-                    if (isTimeoutErrors) {
-                        await testRunHandler.startNewTimeoutRetry();
-                    } else {
-                        await testRunHandler.startNewRetry();
-                    }
-                    logger.info(`retry test id: ${this.testId} name: ${this.testName} again`, {
-                        testId: this.testId,
-                        testName: this.testName,
-                        isTimeoutErrors,
-                        testRetryKey,
-                        totalRetries: testRunHandler._totalRetryCount,
-                    });
-                    this.testResultId = testRunHandler.testResultId;
-                    return await runTestAndCalcResult(testRunHandler, shouldRerun);
-                }
-                return await runNextTest();
-            } catch (error) {
-                if (error instanceof StopRunOnError) {
-                    return undefined;
-                }
-                logger.error('failed to process test result', { error });
-                runNextTest();
-                return undefined;
-            }
-        };
-        const getNetworkErrorMessage = () => 'Due to network connectivity issues, Testim CLI has been unable to connect to the grid.\n' +
-                                             `Please make sure the CLI has stable access to the internet. ${didNetworkConnectivityTestFail() ? '(Internal: network connectivity test failed)' : ''}`;
-
-        /**
-         * @param {Error} err
-         * @param {boolean} wasNetworkHealthy
-         */
-        const buildError = (err, wasNetworkHealthy) => {
-            const instanceType = this.options.mode === CLI_MODE.APPIUM ? 'device' : 'browser';
-            if (!wasNetworkHealthy && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
-                return {
-                    errorType: NETWORK_ERROR,
-                    reason: getNetworkErrorMessage(),
-                };
-            }
-
-            const msg = err instanceof Error ? err.message : err;
-            if (msg.includes(GET_BROWSER_TIMEOUT_MSG)) {
-                return { errorType: SETUP_TIMEOUT, reason: `Test couldn't get ${instanceType}` };
-            }
-            if (msg.includes(TEST_START_TIMEOUT_MSG)) {
-                return { errorType: SETUP_TIMEOUT, reason: "Test couldn't be started" };
-            }
-            if (msg.includes(TEST_COMPLETE_TIMEOUT_MSG)) {
-                if (!this.testRunTimeout) {
-                    return { errorType: SETUP_TIMEOUT, reason: 'Test timeout reached: test is too long' };
-                }
-                const duration = moment.duration(this.testRunTimeout, 'milliseconds');
-                const minutesCount = Math.floor(duration.asMinutes());
-                const secondsCount = duration.seconds();
-                const minutesTimeoutStr = minutesCount > 0 ? ` ${minutesCount} min` : '';
-                const secondsTimoutStr = secondsCount > 0 ? ` ${secondsCount} sec` : '';
-                return { errorType: SETUP_TIMEOUT, reason: `Test timeout reached (timeout:${minutesTimeoutStr}${secondsTimoutStr}): test is too long` };
-            }
-
-            if (err instanceof GetBrowserError && err.type) {
-                if (err.type === GRID_ERROR) {
-                    return { errorType: GRID_ERROR, reason: `Test couldn't get ${instanceType} from grid - ${err.message}` };
-                }
-                if (err.type === SELENIUM_ERROR) {
-                    return { errorType: SELENIUM_ERROR, reason: `Failed to create new session - ${err.message}` };
-                }
-            }
-
-            if (err.type === BROWSER_CLOSED) {
-                return { errorType: SELENIUM_ERROR, reason: 'Session terminated, it is possible that the cli could not connect to the grid to send keep-alive requests for a prolonged period' };
-            }
-            if (err.failure && err.failure instanceof SeleniumError) {
-                return { errorType: SELENIUM_ERROR, reason: `Test couldn't get ${instanceType} from grid - ${err.failure.message}` };
-            }
-            if (/SeleniumError: connect ECONNREFUSED/.test(err.message) || /Couldn't connect to selenium server/.test(err.message)) {
-                return { errorType: SELENIUM_ERROR, reason: 'Failed to connect to the grid, please check if the grid is accessible from your network' };
-            }
-            if (/terminated due to FORWARDING_TO_NODE_FAILED/.test(err.message)) {
-                return { errorType: SELENIUM_ERROR, reason: 'Session terminated, it is likely that the grid is out of memory or not responding, please try to rerun the test' };
-            }
-            if (/terminated due to PROXY_REREGISTRATION/.test(err.message)) {
-                return { errorType: SELENIUM_ERROR, reason: 'Session terminated, it is likely that the grid is not responding, please try to rerun the test' };
-            }
-            if (/forwarding the new session cannot find : Capabilities/.test(err.message)) {
-                return { errorType: SELENIUM_ERROR, reason: `Session could not be created, please check that the ${instanceType} you requested is supported in your plan` };
-            }
-            return { errorType: UNKNOWN_ERROR, reason: msg };
-        };
-
-        /**
-         * @param {Error} err
-         * @param {import('../testRunHandler')} testRunHandler
-         */
-        const onRunError = async (err, testRunHandler) => {
-            const wasNetworkHealthy = await isNetworkHealthy();
-            if (!wasNetworkHealthy && featureFlags.flags.warnOnBadNetwork.isEnabled()) {
-                // intentional, we want to log to stderr:
-                // eslint-disable-next-line no-console
-                console.warn(getNetworkErrorMessage());
-            }
-            logger.warn('error on run', { err });
-
-            const projectId = this.userData?.projectId;
-            const { errorType, reason } = buildError(err, wasNetworkHealthy);
-            testimServicesApi.updateTestResult(projectId, this.testResultId, this.testId, {
-                status: testRunStatus.COMPLETED,
-                success: false,
-                reason,
-                errorType,
-                testRetryKey: testRunHandler.retryKey,
-                setupStepResult: { status: testRunStatus.COMPLETED, success: false, reason, errorType },
-            }, testRunHandler.remoteRunId);
-            await onRunComplete(buildFailureResult(this.testId, this.testName, this.testResultId, reason), testRunHandler, err);
-        };
-
-        /**
-         * @param {Error} runError
-         * @param {import('../testRunHandler')} testRunHandler
-         */
-        const recoverTestResults = async (runError, testRunHandler) => {
-            const testId = this.testId;
-            const resultId = this.testResultId;
-            const projectId = this.userData?.projectId;
-            const branch = this.branch;
-            if (!testId || !resultId || !projectId || !branch) {
-                // Not enough data to call the API
-                logger.warn('Test failed. Not enough data to recover results via API', { err: runError });
-                return onRunError(runError, testRunHandler);
-            }
-
-            try {
-                const testResult = await testimServicesApi.getTestResults(testId, resultId, projectId, branch);
-                logger.warn('Test failed. Got results via API', { err: runError, testResult });
-                if (testResult && testResult.status === testRunStatus.COMPLETED) {
-                    return await onRunComplete(testResult, testRunHandler);
-                }
-                throw runError;
-            } catch (err) {
-                if (err !== runError) {
-                    logger.error('Failed to fetch test results from server', {
-                        testId,
-                        resultId,
-                        projectId,
-                        branch,
-                        err,
-                    });
-                }
-                return onRunError(runError, testRunHandler);
-            }
-        };
-
-        const disableResults = this.options.disableSockets || (this.options.lightweightMode?.disableResults && (this.options.useChromeLauncher || this.options.mode !== 'extension'));
-        const disableRemoteStep = this.options.disableSockets || (this.options.lightweightMode?.disableRemoteStep);
-
-        /**
-         * @param {import('../testRunHandler')} testRunHandler
-         * @param {boolean=} shouldRerun
-         */
-        const runTestAndCalcResult = async (testRunHandler, shouldRerun) => {
-            try {
-                await Promise.all([
-                    !disableRemoteStep && remoteStepService.joinToRemoteStep(this.testResultId),
-                    !disableResults && testResultService.joinToTestResult(this.testResultId, this.testId),
-                ]);
-                testRunHandler.validateRunConfig();
-                const testResult = await this.runTest(testRunHandler, this.customExtensionLocalLocation, shouldRerun);
-                const result = await onRunComplete(testResult, testRunHandler);
-                perf.log('After onRunComplete');
-                return result;
-            } catch (runError) {
-                return recoverTestResults(runError, testRunHandler);
-            } finally {
-                if (!disableRemoteStep) {
-                    remoteStepService.unlistenToRemoteStep(this.testResultId);
-                }
-            }
-        };
-
-        const testRunHandler = this.executionQueue.getNext();
-
-        if (!testRunHandler) { // no more tests to run
-            return this.onQueueCompleted();
-        }
-        this.testId = testRunHandler.testId;
-        this.testName = testRunHandler.testName;
-        this.testResultId = testRunHandler.testResultId;
-        this.overrideTestConfigId = testRunHandler.overrideTestConfigId;
-        this.testRunConfig = testRunHandler.runConfig;
-        this.branch = testRunHandler.branch;
-
-        return runTestAndCalcResult(testRunHandler);
-    }
-}
-
-module.exports = BaseWorker;