@testim/testim-cli 3.289.0 → 3.290.0

package/services/gridService.test.js

@@ -1,357 +0,0 @@
-const { expect, sinon } = require('../../test/utils/testUtils');
-const gridService = require('./gridService');
-const servicesApi = require('../commons/testimServicesApi');
-
-describe('gridService', () => {
-    describe('handleHybridOrVendorIfNeeded', () => {
-        let getHybridGridProviderStub;
-        let ltServiceMock;
-
-        beforeEach(() => {
-            ltServiceMock = { enableIfNeeded: sinon.stub().resolves(), disable: sinon.stub().resolves() };
-            getHybridGridProviderStub = sinon.stub(servicesApi, 'getHybridGridProvider');
-        });
-        afterEach(() => {
-            getHybridGridProviderStub.restore();
-        });
-
-        it('should return grid if no grid id or grid type', async () => {
-            const grid = { name: 'grid' };
-            const result = await gridService.handleHybridOrVendorIfNeeded();
-            expect(result).to.eql({});
-            sinon.assert.notCalled(getHybridGridProviderStub);
-        });
-
-        it('should return grid if it is not a hybrid grid', async () => {
-            const grid = { type: 'not hybrid', gridId: 'gridId' };
-            const result = await gridService.handleHybridOrVendorIfNeeded({ company: {} }, grid);
-            expect(result).to.equal(grid);
-            sinon.assert.notCalled(getHybridGridProviderStub);
-        });
-
-        it('should return grid if it is hybrid with insufficient data to get its provider', async () => {
-            const grid = { type: 'testimHybrid', gridId: 'gridId' };
-            const result = await gridService.handleHybridOrVendorIfNeeded({ company: { companyId: 'companyId' }, browser: 'chrome' }, grid);
-            expect(result).to.equal(grid);
-            sinon.assert.notCalled(getHybridGridProviderStub);
-        });
-
-        it('should get grid provider for hybrid grids', async () => {
-            getHybridGridProviderStub.resolves({ provider: 'provider' });
-            const grid = { type: 'testimHybrid', gridId: 'gridId' };
-            const result = await gridService.handleHybridOrVendorIfNeeded({ company: { companyId: 'companyId' }, browser: 'chrome' }, grid, {}, ltServiceMock, { currentRetry: 1, maxRetries: 1 });
-            expect(result).to.shallowDeepEqual({ ...grid, provider: 'provider' });
-            sinon.assert.calledOnce(getHybridGridProviderStub);
-        });
-
-        it('should enable lambda test service if lambda test grid', async () => {
-            const grid = { type: 'testimLambdaTest', gridId: 'gridId' };
-            await gridService.handleHybridOrVendorIfNeeded({ company: {} }, grid, {}, ltServiceMock);
-            sinon.assert.calledOnce(ltServiceMock.enableIfNeeded);
-            sinon.assert.notCalled(getHybridGridProviderStub);
-        });
-
-        it('should enable lambda test service if hybrid grid and lambda test provider', async () => {
-            getHybridGridProviderStub.resolves({ provider: 'lambdatest' });
-            const grid = { type: 'testimHybrid', gridId: 'gridId' };
-            await gridService.handleHybridOrVendorIfNeeded({ company: { companyId: 'companyId' }, browser: 'chrome' }, grid, {}, ltServiceMock, { currentRetry: 1, maxRetries: 1 });
-            sinon.assert.calledOnce(ltServiceMock.enableIfNeeded);
-        });
-
-        it('should disable lambda test service if hybrid grid and not lambda test provider', async () => {
-            getHybridGridProviderStub.resolves({ provider: 'provider' });
-            const grid = { type: 'testimHybrid', gridId: 'gridId' };
-            await gridService.handleHybridOrVendorIfNeeded({ company: { companyId: 'companyId' }, browser: 'chrome' }, grid, {}, ltServiceMock, { currentRetry: 1, maxRetries: 1 });
-            sinon.assert.calledOnce(ltServiceMock.disable);
-            sinon.assert.notCalled(ltServiceMock.enableIfNeeded);
-        });
-
-        it('should return hybrid grid tunnel credentials if set', async () => {
-            getHybridGridProviderStub.resolves({ provider: 'provider', connectionDetails: { hybrid: { tunnel: 'provider', external: { provider: { user: 'username', key: 'password' } } } } });
-            const grid = { type: 'testimHybrid', gridId: 'gridId' };
-            const result = await gridService.handleHybridOrVendorIfNeeded({ company: { companyId: 'companyId' }, browser: 'chrome' }, grid, {}, ltServiceMock, { currentRetry: 1, maxRetries: 1 });
-            expect(result).to.shallowDeepEqual({ ...grid, provider: 'provider', key: undefined, user: undefined, tunnelUser: 'username', tunnelKey: 'password' });
-        });
-
-        it('should ignore hybrid grid tunnel credentials if tunnel set to a different provider', async () => {
-            getHybridGridProviderStub.resolves({ provider: 'provider', connectionDetails: { hybrid: { tunnel: 'otherprovider', external: { provider: { user: 'username', key: 'password' } } } } });
-            const grid = { type: 'testimHybrid', gridId: 'gridId' };
-            const result = await gridService.handleHybridOrVendorIfNeeded({ company: { companyId: 'companyId' }, browser: 'chrome' }, grid, {}, ltServiceMock, { currentRetry: 1, maxRetries: 1 });
-            expect(result).to.shallowDeepEqual({ ...grid, provider: 'provider', key: undefined, user: undefined, tunnelUser: undefined, tunnelKey: undefined });
-        });
-    });
-
-    describe('getGridData', () => {
-        let getAllGridsStub;
-        let getTestPlanStub;
-
-        beforeEach(() => {
-            getAllGridsStub = sinon.stub(servicesApi, 'getAllGrids');
-            getTestPlanStub = sinon.stub(servicesApi, 'getTestPlan').resolves([{ gridId: 'gridId' }]);
-        });
-        afterEach(() => {
-            getAllGridsStub.restore();
-            getTestPlanStub.restore();
-        });
-
-        it('should not access server when using useLocalChromeDriver flag', async () => {
-            const grid = await gridService.getGridData({ useLocalChromeDriver: true });
-            expect(grid).to.eql({ mode: 'local' });
-            sinon.assert.notCalled(getAllGridsStub);
-        });
-
-        it('should not access server when using useChromeLauncher flag', async () => {
-            const grid = await gridService.getGridData({ useChromeLauncher: true });
-            expect(grid).to.eql({ mode: 'local' });
-            sinon.assert.notCalled(getAllGridsStub);
-        });
-
-        it('should return fixed grid when passing host and port', async () => {
-            const grid = await gridService.getGridData({ host: 'localhost', port: 4444 });
-            expect(grid).to.shallowDeepEqual({ type: 'hostAndPort', host: 'localhost', port: 4444 });
-            sinon.assert.notCalled(getAllGridsStub);
-        });
-
-        it('should get grid from server when passing grid id', async () => {
-            getAllGridsStub.resolves([{ _id: 'gridId', type: 'gridId' }]);
-            const grid = await gridService.getGridData({ gridId: 'gridId', company: { companyId: 'companyId' } });
-            expect(grid).to.shallowDeepEqual({ type: 'gridId', gridId: 'gridId' });
-            sinon.assert.calledOnce(getAllGridsStub);
-        });
-
-        it('should use existing grid list if passed when passing grid id', async () => {
-            const grid = await gridService.getGridData({ gridId: 'gridId', company: { companyId: 'companyId' }, allGrids: [{ _id: 'gridId', type: 'gridId' }] });
-            expect(grid).to.shallowDeepEqual({ type: 'gridId', gridId: 'gridId' });
-            sinon.assert.notCalled(getAllGridsStub);
-        });
-
-        it('should handle grid not found error when passing grid id', async () => {
-            getAllGridsStub.resolves([{ _id: 'gridId', type: 'gridId' }]);
-            await expect(gridService.getGridData({ gridId: 'gridId1', company: { companyId: 'companyId' } }))
-                .to.eventually.be.rejectedWith('Failed to find grid id: gridId1');
-        });
-
-        it('should get grid from server when passing grid name', async () => {
-            getAllGridsStub.resolves([{ name: 'GRIDNAME', type: 'gridName' }]);
-            const grid = await gridService.getGridData({ grid: 'gridName', company: { companyId: 'companyId' } });
-            expect(grid).to.shallowDeepEqual({ type: 'gridName', name: 'GRIDNAME' });
-            sinon.assert.calledOnce(getAllGridsStub);
-        });
-
-        it('should use existing grid list if passed when passing grid name', async () => {
-            const grid = await gridService.getGridData({ grid: 'gridName', company: { companyId: 'companyId' }, allGrids: [{ name: 'GRIDNAME', type: 'gridName' }] });
-            expect(grid).to.shallowDeepEqual({ type: 'gridName', name: 'GRIDNAME' });
-            sinon.assert.notCalled(getAllGridsStub);
-        });
-
-        it('should handle grid not found error when passing grid name', async () => {
-            getAllGridsStub.resolves([{ type: 'gridName' }]);
-            await expect(gridService.getGridData({ grid: 'gridName', company: { companyId: 'companyId' } }))
-                .to.eventually.be.rejectedWith('Failed to find grid name: gridName');
-        });
-
-        it('should not assign a grid when using a test plan', async () => {
-            const grid = await gridService.getGridData({ testPlan: ['testPlan'], company: { companyId: 'companyId' }, allGrids: [{ _id: 'gridId', type: 'gridId' }] });
-            expect(grid).to.be.undefined;
-        });
-
-        it('should not assign a grid when using a test plan id', async () => {
-            const grid = await gridService.getGridData({ testPlanIds: ['testPlan'], company: { companyId: 'companyId' }, allGrids: [{ _id: 'gridId', type: 'gridId' }] });
-            expect(grid).to.be.undefined;
-        });
-
-        it('should throw when no grid selected', async () => {
-            await expect(gridService.getGridData({ company: { companyId: 'companyId' } }))
-                .to.eventually.be.rejectedWith('Missing host or grid configuration');
-        });
-    });
-
-    describe('getGridSlot', () => {
-        let getGridByIdStub;
-        let getGridByNameStub;
-        let addItemToGridCacheStub;
-
-        beforeEach(() => {
-            getGridByIdStub = sinon.stub(servicesApi, 'getGridById').resolves({ grid: { gridId: 'gridId', type: 'gridId' }, status: 'success' });
-            getGridByNameStub = sinon.stub(servicesApi, 'getGridByName').resolves({ grid: { gridId: 'gridId', type: 'gridName' }, status: 'success' });
-            addItemToGridCacheStub = sinon.stub(gridService, 'addItemToGridCache').callThrough();
-        });
-        afterEach(() => {
-            getGridByIdStub.restore();
-            getGridByNameStub.restore();
-            addItemToGridCacheStub.restore();
-        });
-
-        it('should not access server when using useLocalChromeDriver flag', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', { useLocalChromeDriver: true }, 'workerId');
-            expect(slot).to.eql({ mode: 'local' });
-            sinon.assert.notCalled(getGridByIdStub);
-            sinon.assert.notCalled(getGridByNameStub);
-            sinon.assert.notCalled(addItemToGridCacheStub);
-        });
-
-        it('should not access server when using useChromeLauncher flag', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', { useChromeLauncher: true }, 'workerId');
-            expect(slot).to.eql({ mode: 'local' });
-            sinon.assert.notCalled(getGridByIdStub);
-            sinon.assert.notCalled(getGridByNameStub);
-            sinon.assert.notCalled(addItemToGridCacheStub);
-        });
-
-        it('should return fixed grid when passing host and port', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', { host: 'localhost', port: 4444 }, 'workerId');
-            expect(slot).to.shallowDeepEqual({ type: 'hostAndPort', host: 'localhost', port: 4444 });
-            sinon.assert.notCalled(getGridByIdStub);
-            sinon.assert.notCalled(getGridByNameStub);
-            sinon.assert.notCalled(addItemToGridCacheStub);
-        });
-
-        it('should get grid from server when passing grid id', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId');
-            expect(slot).to.shallowDeepEqual({ type: 'gridId', gridId: 'gridId' });
-            sinon.assert.calledOnce(getGridByIdStub);
-            sinon.assert.notCalled(getGridByNameStub);
-            sinon.assert.calledOnce(addItemToGridCacheStub);
-        });
-
-        it('should get grid from server when passing grid name', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', { grid: 'gridName' }, 'workerId');
-            expect(slot).to.shallowDeepEqual({ type: 'gridName', gridId: 'gridId' });
-            sinon.assert.calledOnce(getGridByNameStub);
-            sinon.assert.notCalled(getGridByIdStub);
-            sinon.assert.calledOnce(addItemToGridCacheStub);
-        });
-
-        it('should handle grid not found error', async () => {
-            getGridByIdStub.resolves({ status: 'error', code: 'not-found' });
-            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
-                .to.eventually.be.rejectedWith('The specified grid is not available');
-        });
-
-        it('should handle no available slot error', async () => {
-            getGridByIdStub.resolves({ status: 'error', code: 'no-available-slot' });
-            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
-                .to.eventually.be.rejectedWith('Failed to run test on browser - concurrency limit reached');
-        });
-
-        it('should handle getGridSlot request error', async () => {
-            getGridByIdStub.rejects({ status: 'error', code: 'not-found' });
-            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
-                .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
-        });
-
-        it('should throw when no grid selected', async () => {
-            await expect(gridService.getGridSlot('browser', 'executionId', {}, 'workerId'))
-                .to.eventually.be.rejectedWith('Missing host or grid configuration');
-        });
-
-        it('should handle unkonwn errors', async () => {
-            getGridByIdStub.resolves({ status: 'error', code: 'bla bla' });
-            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
-                .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
-        });
-
-        it('should handle no status', async () => {
-            getGridByIdStub.resolves({ code: 'bla bla' });
-            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
-                .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
-        });
-    });
-
-    describe('releaseGridSlot', () => {
-        let releaseGridSlotStub;
-        beforeEach(() => {
-            releaseGridSlotStub = sinon.stub(servicesApi, 'releaseGridSlot').resolves();
-        });
-        afterEach(() => {
-            releaseGridSlotStub.restore();
-        });
-
-        it('should call releaseGridSlot with the correct parameters', async () => {
-            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
-            await gridService.releaseGridSlot('workerId', 'projectId');
-            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId', 'gridId', 'chrome');
-        });
-
-        it('should not call releaseGridSlot if the workerId is not in the cache', async () => {
-            await gridService.releaseGridSlot('workerId', 'projectId');
-            sinon.assert.notCalled(releaseGridSlotStub);
-        });
-
-        it('should not call releaseGridSlot if no slotId', async () => {
-            gridService.addItemToGridCache('workerId', 'companyId', 'gridId');
-            await gridService.releaseGridSlot('workerId', 'projectId');
-            sinon.assert.notCalled(releaseGridSlotStub);
-        });
-
-        it('should handle releaseGridSlot request error', async () => {
-            releaseGridSlotStub.rejects({ });
-            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
-            await gridService.releaseGridSlot('workerId', 'projectId');
-            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId', 'gridId', 'chrome');
-        });
-    });
-
-    describe('keepAlive', () => {
-        let clock;
-        let keepAliveStub;
-        let releaseGridSlotStub;
-        beforeEach(() => {
-            clock = sinon.useFakeTimers();
-            keepAliveStub = sinon.stub(servicesApi, 'keepAliveGrid').resolves();
-            releaseGridSlotStub = sinon.stub(servicesApi, 'releaseGridSlot').resolves();
-        });
-        afterEach(() => {
-            clock.restore();
-            keepAliveStub.restore();
-            releaseGridSlotStub.restore();
-        });
-
-        it('should send keepAlive to server on an interval', async () => {
-            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
-            await gridService.keepAlive.start('projectId');
-            clock.tick(10010);
-            sinon.assert.calledOnceWithExactly(keepAliveStub, 'projectId', [{ gridId: 'gridId', companyId: 'companyId', slotId: 'slotId', browser: 'chrome' }]);
-            await gridService.releaseGridSlot('workerId', 'projectId');
-        });
-
-        it('should send keepAlive to server every 10 seconds', async () => {
-            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
-            await gridService.keepAlive.start('projectId');
-            clock.tick(30010);
-            sinon.assert.calledThrice(keepAliveStub);
-            await gridService.releaseGridSlot('workerId', 'projectId');
-        });
-
-        it('should not send keepAlive if there is no grid', async () => {
-            await gridService.keepAlive.start('projectId');
-            clock.tick(10010);
-            sinon.assert.notCalled(keepAliveStub);
-        });
-
-        it('should handle keepAlive request error', async () => {
-            keepAliveStub.rejects({ });
-            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
-            await gridService.keepAlive.start('projectId');
-            clock.tick(10010);
-            sinon.assert.calledOnce(keepAliveStub);
-            await gridService.releaseGridSlot('workerId', 'projectId');
-        });
-
-        it('should release all slots when ending', async () => {
-            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
-            gridService.addItemToGridCache('workerId1', 'companyId', 'gridId', 'slotId1', 'firefox');
-            await gridService.keepAlive.start('projectId');
-            await gridService.keepAlive.end('projectId');
-            sinon.assert.calledTwice(releaseGridSlotStub);
-            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId', 'gridId', 'chrome');
-            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId1', 'gridId', 'firefox');
-        });
-
-        it('should not release slots if there is no slots in use', async () => {
-            await gridService.keepAlive.start('projectId');
-            await gridService.keepAlive.end('projectId');
-            sinon.assert.notCalled(releaseGridSlotStub);
-        });
-    });
-});

package/services/labFeaturesService.js

@@ -1,64 +0,0 @@
-'use strict';
-
-const featureFlagService = require('../commons/featureFlags');
-const { getLabFeaturesByProjectId } = require('../commons/testimServicesApi');
-const _ = require('lodash');
-
-const logger = require('../commons/logger').getLogger('lab-features-service');
-
-class LabFeaturesService {
-    constructor() {
-        this.featuresForProject = [];
-        this.labBatman = false;
-    }
-
-    async loadLabFeatures(projectId, companyPlan) {
-        if (!companyPlan || !projectId) {
-            logger.error('missing companyPlan or projectId when loading lab features', { companyPlan, projectId });
-            this.featuresForProject = [];
-        }
-
-        try {
-            const labBatman = this.isLabsEnabledForCompany(companyPlan);
-            const features = labBatman ? (await getLabFeaturesByProjectId(projectId)) : [];
-            this.featuresForProject = features;
-            this.labBatman = labBatman;
-        } catch (err) {
-            logger.error('failed loading lab features', { err, companyPlan, projectId });
-            this.featuresForProject = [];
-        }
-    }
-
-    isFeatureAvailableForProject(featureFlagName) {
-        const featureFlag = featureFlagService.flags[featureFlagName];
-        this.validateAsLabFeatureFlag(featureFlag);
-        const ffValue = featureFlag.getValue();
-        if (ffValue === 'disabled') {
-            return false;
-        }
-        if (ffValue === 'enabled') {
-            return true;
-        }
-
-        const { featuresForProject: features, labBatman } = this;
-        const labFeature = features.find(f => f.featureFlagName === featureFlagName);
-        const featureEnabled = labFeature?.enabled;
-
-        return Boolean(labBatman && featureEnabled);
-    }
-
-    isLabsEnabledForCompany(companyPlan) {
-        return Boolean(companyPlan?.premiumFeatures?.enableLabFeatures);
-    }
-
-    validateAsLabFeatureFlag(featureFlag) {
-        if ('getValue' in featureFlag) {
-            return;
-        }
-
-        const msg = `Attempted querying a lab feature flag which isn't a variant. This means that a wrong configuration is being used in FeatureFlagsService (for feature flag: ${featureFlag.name}`;
-        logger.error(msg, { featureFlagName: featureFlag.name });
-        throw new Error(msg);
-    }
-}
-module.exports = new LabFeaturesService();

package/services/lambdatestService.js

@@ -1,227 +0,0 @@
-const os = require('os');
-const childProcess = require('child_process');
-const pRetry = require('p-retry');
-const fse = require('fs-extra');
-const portfinder = require('portfinder');
-const ms = require('ms');
-const utils = require('../utils');
-const { gridTypes, CLI_MODE } = require('../commons/constants');
-const httpRequest = require('../commons/httpRequest');
-const { ArgError } = require('../errors');
-const servicesApi = require('../commons/testimServicesApi');
-const { getExtensionsUrl } = require('../runOptionsUtils');
-const featureFlagService = require('../commons/featureFlags');
-
-const logger = require('../commons/logger').getLogger('lambdatestService');
-
-const LT_TUNNEL_BINARY_ORIGIN = 'https://downloads.lambdatest.com/tunnel/v3';
-const LT_TUNNEL_BINARY_PATHNAME = {
-    win32ia32: 'windows/32bit/LT_Windows.zip',
-    win32x64: 'windows/64bit/LT_Windows.zip',
-    darwinia32: 'mac/32bit/LT_Mac.zip',
-    darwinx64: 'mac/64bit/LT_Mac.zip',
-    darwinarm64: 'mac/64bit/LT_Mac.zip',
-    linuxia32: 'linux/32bit/LT_Linux.zip',
-    linuxx64: 'linux/64bit/LT_Linux.zip',
-    freebsdia32: 'freebsd/32bit/LT_Freebsd.zip',
-    freebsdx64: 'freebsd/64bit/LT_Freebsd.zip',
-};
-const LT_TUNNEL_BINARY_DIRECTORY = `${os.tmpdir()}/LT`;
-const LT_TUNNEL_BINARY_LOCATION = `${LT_TUNNEL_BINARY_DIRECTORY}/LT`;
-
-const LT_MINIMUM_CONNECTION_RETRY_TIMEOUT = ms('15m');
-
-class LambdatestService {
-    constructor() {
-        this.isActive = false;
-    }
-
-    static isLambdatestGrid(gridData) {
-        return gridData.type === gridTypes.LAMBDATEST || (gridData.type === gridTypes.HYBRID && gridData.provider === 'lambdatest');
-    }
-
-    isLambdatestRun() {
-        return this.isActive;
-    }
-
-    async enableIfNeeded(gridData) {
-        if (!LambdatestService.isLambdatestGrid(gridData)) {
-            return;
-        }
-
-        LambdatestService.lambdatestConfigPromise = LambdatestService.lambdatestConfigPromise || servicesApi.fetchLambdatestConfig();
-        LambdatestService.lambdatestConfig = await LambdatestService.lambdatestConfigPromise;
-        this.isActive = true;
-    }
-
-    disable() {
-        this.isActive = false;
-    }
-
-    get getSessionTimeout() {
-        if (!this.isActive) {
-            return null;
-        }
-        return LT_MINIMUM_CONNECTION_RETRY_TIMEOUT;
-    }
-
-    get getSessionRetries() {
-        if (!this.isActive) {
-            return null;
-        }
-        return 1;
-    }
-
-    // https://www.lambdatest.com/support/docs/beta-lambda-tunnel-for-corporate-firewalls/
-    static async prepareTunnel() {
-        const isBinaryExist = await fse.pathExists(LT_TUNNEL_BINARY_LOCATION);
-        if (isBinaryExist) {
-            return;
-        }
-
-        const downloadUrl = LT_TUNNEL_BINARY_PATHNAME[os.platform() + os.arch()];
-        if (!downloadUrl) {
-            throw new Error(`tunnel on ${os.platform() + os.arch()} platform is not supported.`);
-        }
-        const zipLocation = `${LT_TUNNEL_BINARY_DIRECTORY}.zip`;
-        await utils.downloadAndSave(`${LT_TUNNEL_BINARY_ORIGIN}/${downloadUrl}`, zipLocation);
-        await utils.unzipFile(zipLocation, LT_TUNNEL_BINARY_DIRECTORY);
-    }
-
-    static async connectTunnel(runnerOptions) {
-        if (runnerOptions.externalLambdatestTunnelId) {
-            LambdatestService.tunnelName = runnerOptions.externalLambdatestTunnelId;
-            return;
-        }
-        await this.prepareTunnel();
-        const infoAPIPort = await portfinder.getPortPromise();
-        const { gridData = {}, gridUsername, gridPassword } = runnerOptions;
-        const proxyUri = global.proxyUri;
-        LambdatestService.tunnelName = utils.guid();
-
-        let tunnelArgs = [
-            '--tunnelName', LambdatestService.tunnelName,
-            '--infoAPIPort', infoAPIPort,
-        ];
-
-        if (runnerOptions.externalLambdatestUseWss) {
-            tunnelArgs = [...tunnelArgs, '--mode', 'ws'];
-        }
-        if (runnerOptions.externalLambdatestDisableAutomationTunneling) {
-            tunnelArgs = [...tunnelArgs, '--bypassHosts', 'run.testim.io,services.testim.io,api.coralogix.com,conf.rollout.io,statestore.rollout.io,push.rollout.io,analytic.rollout.io,res.cloudinary.com'];
-        }
-
-        if (gridData.tunnelUser && gridData.tunnelKey) {
-            tunnelArgs = [...tunnelArgs, '--user', gridData.tunnelUser, '--key', gridData.tunnelKey];
-        } else if (gridUsername && gridPassword) {
-            tunnelArgs = [...tunnelArgs, '--user', gridUsername, '--key', gridPassword];
-        } else {
-            throw new ArgError('tunnel requires username and password');
-        }
-
-        if (proxyUri) {
-            try {
-                const proxyUrl = new URL(proxyUri);
-                tunnelArgs = [...tunnelArgs, '--proxy-host', proxyUrl.hostname];
-                if (proxyUrl.port) {
-                    tunnelArgs = [...tunnelArgs, '--proxy-port', proxyUrl.port];
-                }
-                if (proxyUrl.username && proxyUrl.password) {
-                    tunnelArgs = [...tunnelArgs, '--proxy-user', proxyUrl.username, '--proxy-pass', proxyUrl.password];
-                }
-            } catch (e) {
-                throw new ArgError('proxy url is invalid');
-            }
-        }
-
-        if (runnerOptions.externalLambdatestMitm) {
-            tunnelArgs = [...tunnelArgs, '--mitm'];
-        }
-
-        LambdatestService.tunnel = childProcess.spawn('./LT', tunnelArgs, { cwd: LT_TUNNEL_BINARY_DIRECTORY });
-
-        let stdoutResult = '';
-        let stderrResult = '';
-
-        LambdatestService.tunnel.stdout.on('data', (data) => {
-            stdoutResult += data.toString();
-        });
-
-        LambdatestService.tunnel.stderr.on('data', (data) => {
-            stderrResult += data.toString();
-        });
-
-        // verify that LT tunnel strated successfully
-        try {
-            const ltInfo = await pRetry(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), { retries: 30, minTimeout: 2000 });
-            logger.info('LT tunnel info', ltInfo);
-        } catch (err) {
-            logger.error('Failed to start LT tunnel', { err, stdoutResult, stderrResult });
-            throw err;
-        }
-    }
-
-    static async disconnectTunnel(runnerOptions) {
-        if (runnerOptions.externalLambdatestTunnelId || !LambdatestService.tunnel) {
-            return undefined;
-        }
-        return new Promise((resolve, reject) => {
-            LambdatestService.tunnel.on('close', (code) => {
-                if (code) {
-                    reject(new Error(`tunnel process exited with code ${code}`));
-                }
-                resolve();
-            });
-            LambdatestService.tunnel.kill();
-        });
-    }
-
-    getCapabilities(runnerOptions, browser, executionId, testResultId, testName) {
-        if (!this.isActive) {
-            return {};
-        }
-
-        const defaultBrowserCaps = LambdatestService.lambdatestConfig.CAPABILITIES[browser] || {};
-
-
-        const tunnelCaps = {};
-        if (LambdatestService.tunnelName) {
-            tunnelCaps.tunnel = true;
-            tunnelCaps.tunnelName = LambdatestService.tunnelName;
-        }
-
-        let loadExtension = [];
-        const { mode, canary, ext, extensionPath, installCustomExtension } = runnerOptions;
-        if (mode === CLI_MODE.EXTENSION && !ext) {
-            const extUrls = getExtensionsUrl({ canary }, true);
-            if (!extensionPath && extUrls[browser]) {
-                loadExtension = [...loadExtension, extUrls[browser]];
-            }
-            if (extensionPath && utils.isURL(extensionPath)) {
-                loadExtension = [...loadExtension, extensionPath];
-            }
-        }
-        if (installCustomExtension && utils.isURL(installCustomExtension)) {
-            loadExtension = [...loadExtension, installCustomExtension];
-        }
-
-        return {
-            build: executionId,
-            name: `${testResultId} - ${testName}`,
-            platform: LambdatestService.lambdatestConfig.PLATFORM,
-            // eslint-disable-next-line camelcase
-            selenium_version: LambdatestService.lambdatestConfig.SELENIUM_VERSION,
-            resolution: LambdatestService.lambdatestConfig.RESOLUTION,
-            timezone: LambdatestService.lambdatestConfig.TIMEZONE,
-            ...defaultBrowserCaps,
-            loadExtension,
-            ...tunnelCaps,
-            console: true,
-            queueTimeout: 300, // time a session spends in the LT queue, in seconds (apparently 300 is the minimum)
-            // visual: true, // [NOTE]: activate LT screenshots feature (can slow test).
-            network: featureFlagService.flags.LTNetworkCapabilities.isEnabled(), // [NOTE]: activate LT capture network logs feature (can cause network issues).
-            // fixedIP: '10.80.34.143', // [NOTE]: this is for debug purposes with LT team.
-        };
-    }
-}
-module.exports = LambdatestService;