@testim/testim-cli 3.235.0 → 3.236.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.235.0",
+  "version": "3.236.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{

package/player/stepActions/inputFileStepAction.js

@@ -4,7 +4,7 @@ const StepAction = require('./stepAction');
 const _ = require('lodash');
 const logger = require('../../commons/logger').getLogger('input-file-step-action');
 const { codeSnippets, utils } = require('../../commons/getSessionPlayerRequire');
-const { extractElementId } = require('../../utils');
+const { extractElementId, download } = require('../../utils');
 const inputFileUtils = require('../../inputFileUtils');
 const featureFlagService = require('../../commons/featureFlags');
 
@@ -41,18 +41,15 @@ class InputFileStepAction extends StepAction {
     }
 
     async uploadFilesAndForceVisibility(gridLocalFiles, target) {
-        const preUploadStep = this.driver.isSafari() ?
-            // in safari we force the visibility ahead of time because making it visible the second time around doesn't work
-            this.safariPreUploadActions(target) :
-            Promise.resolve();
-
         try {
-            await preUploadStep;
+            if (this.driver.isSafari()) {
+                await this.safariPreUploadActions(target);
+            }
             await this.uploadFiles(gridLocalFiles, target);
         } catch (err) {
             const edgeErrorEditableMessage = 'The element is not editable';
             const edgeErrorFocusableMessage = 'The element is not focusable';
-            const safariErrorVisibleMessege = 'An element command could not be completed because the element is not visible on the page.';
+            const safariErrorVisibleMessage = 'An element command could not be completed because the element is not visible on the page.';
             const elementNotInteractable = 'element not interactable';
             const elementNotPointerOrKeyboardInteractable = 'element is not pointer- or keyboard interactable';
             const invalidStateMsg = 'invalid element state: Element is not currently interactable and may not be manipulated';
@@ -64,7 +61,7 @@ class InputFileStepAction extends StepAction {
                 _.startsWith(errorMsg, mustBeVisibleMsg) ||
                 _.startsWith(errorMsg, edgeErrorEditableMessage) ||
                 _.startsWith(errorMsg, edgeErrorFocusableMessage) ||
-                _.startsWith(errorMsg, safariErrorVisibleMessege) ||
+                _.startsWith(errorMsg, safariErrorVisibleMessage) ||
                 _.includes(errorMsg, notReachableByKeyboard) ||
                 _.includes(errorMsg, elementNotInteractable) ||
                 _.includes(errorMsg, elementNotPointerOrKeyboardInteractable)
@@ -88,9 +85,18 @@ class InputFileStepAction extends StepAction {
     async performAction() {
         const target = this.context.data[this.step.targetId || 'targetId'];
         const overrideAzureStorageUrl = featureFlagService.flags.overrideAzureStorageUrl.isEnabled();
-
-        const fileUrls = await utils.addTokenToFileUrl(this.context.project.id, this.step.fileUrls, this.stepActionUtils.testimServicesApi, overrideAzureStorageUrl, logger);
         const useJsInputCodeInSafari = featureFlagService.flags.useJsInputCodeInSafari.isEnabled();
+        const downloadToBase64 = featureFlagService.flags.downloadToBase64.isEnabled();
+
+        let fileUrls = await utils.addTokenToFileUrl(this.context.project.id, this.step.fileUrls, this.stepActionUtils.testimServicesApi, overrideAzureStorageUrl, logger);
+
+        if (downloadToBase64) {
+            fileUrls = await Promise.all(fileUrls.map(async ({ name, url }) => {
+                const res = await download(url);
+                return { name, url: `data:${res.type};base64,${Buffer.from(res.body).toString('base64')}` };
+            }));
+        }
+
         if (this.driver.isSafari() && (useJsInputCodeInSafari || fileUrls.length > 1)) {
             await this.driver.executeJSWithArray(`
                 const getLocatedElement = ${codeSnippets.getLocatedElementCode};
@@ -165,15 +171,18 @@ function downloadAndUpload() {
             return new File([blob], name, { type: blob.type });
         }));
 
-        fileList.item = function(ind) { return this[ind]; };
+        const dt = new DataTransfer();
+        for (const file of fileList) {
+            dt.items.add(file);
+        }
+        element.files = dt.files;
+
         let changeWasFired = false;
         const changeFiredHandler = (e) => {
             changeWasFired = true;
         };
 
         element.addEventListener("change", changeFiredHandler, true);
-        Reflect.deleteProperty(element, 'files');
-        Reflect.defineProperty(element, 'files', { get() { return fileList; }, configurable: true });
         await Promise.resolve(); // wait microtick
         element.dispatchEvent(new Event("input", { bubbles: true }));
         if (!changeWasFired) {

package/player/stepActions/textValidationStepAction.js

@@ -1,5 +1,6 @@
 "use strict";
 
+
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 
 const StepAction = require('./stepAction');
@@ -7,6 +8,7 @@ const constants = sessionPlayer.commonConstants.stepResult;
 const paramEvaluator = sessionPlayer.stepParamExpressionEvaluator;
 const utils = sessionPlayer.utils;
 
+
 const Promise = require('bluebird');
 
 class TextValidationStepAction extends StepAction {
@@ -15,6 +17,7 @@ class TextValidationStepAction extends StepAction {
         var context = this.context;
         var target = this.getTarget();
         var frameHandler = this.frameHandler;
+        
 
         return new Promise(resolve => {
             var onFail = resultInfo => {

package/player/webdriver.js

@@ -59,6 +59,7 @@ class WebDriver extends WebDriverApi {
         this.cdpUrl = undefined;
         this.browserClosedCallbacks = [];
         this.browserClosedFailedKeepAlives = 0;
+        this.ignoreHiddenTagsText = false;
     }
 
     registerToClosedBrowser(callback) {
@@ -71,6 +72,7 @@ class WebDriver extends WebDriverApi {
 
     async init(browserOptions, testName, testRunConfig, gridInfo, customExtensionLocalLocation, executionId, testResultId, seleniumPerfStats = new SeleniumPerfStats(), fastInit = false, lambdatestService) {
         this.browserClosedFailedKeepAlives = 0;
+        this.ignoreHiddenTagsText = _(browserOptions).get('company.activePlan.premiumFeatures.ignoreHiddenTagsText');
         this.browserClosedCallbacks = [];
         const capabilities = desiredCapabilitiesBuilder.buildSeleniumOptions(browserOptions, testName, testRunConfig, gridInfo, customExtensionLocalLocation, executionId, testResultId, lambdatestService);
         if (capabilities.desiredCapabilities) {
@@ -360,7 +362,14 @@ class WebDriver extends WebDriverApi {
                         return element.shadowRoot.textContent.replace(/(\r\n|\n|\r)/gm, "");
                     }
                 } catch (err) { }
-                return element.textContent.replace(/(\r\n|\n|\r)/gm, "");
+                if (this.ignoreHiddenTagsText && Array.prototype.some.call(element.children, elem => elem.hidden)) {
+                    const dupElement = element.cloneNode(true);
+                    const hiddenChildren = Array.prototype.filter.call(dupElement.children, elem => elem.hidden);
+                    hiddenChildren.forEach(child => {
+                        dupElement.removeChild(child);
+                    });
+                    return dupElement.textContent.replace(/(\r\n|\n|\r)/gm, "");
+                } return element.textContent.replace(/(\r\n|\n|\r)/gm, "");
             }
 
             function getElementTextContent(element) {

package/runOptions.js

@@ -322,6 +322,7 @@ program
     // Agent mode
     .option('connect, --agent [enable-agent-mode]', 'enable Testim CLI agent mode', false)
     .option('start [enable-start]', 'Connect to testim and open the editor in a standalone browser', false)
+    .option('--download-browser', 'when used with the start option, downloads a fixed version to run Testim editor in', false)
     .option('--agent-port [agent-port]', 'set agent port', Number, 42543)
     .option('--agent-bind [agent-host-bind]', 'set agent host bind', '127.0.0.1')
 

package/runOptionsAgentFlow.js

@@ -5,12 +5,16 @@
 const { ArgError } = require('./errors');
 const _ = require('lodash');
 const runOptionsUtils = require('./runOptionsUtils');
+const analytics = require('./commons/testimAnalytics');
 
 /**
  *
  * @param {import("commander").CommanderStatic} program
  */
 function isAgentFlow(program) {
+    if (program.start) {
+        analytics.track(null, 'cli-start-command', { downloadBrowser: Boolean(program.downloadBrowser) });
+    }
     if (program.startV2 || program.start || program.agent) {
         return true;
     }
@@ -73,6 +77,7 @@ async function runAgentFlow(program) {
         canary: program.canary,
         playerPath: program.playerPath,
         playerRequirePath: program.playerRequirePath,
+        downloadBrowser: Boolean(program.downloadBrowser),
     };
 }
 

package/runner.js

@@ -25,7 +25,6 @@ const FREE_PLAN_MINIMUM_BROWSER_TIMEOUT = 30 * 60 * 1000;
 const TestPlanRunner = require('./runners/TestPlanRunner');
 const labFeaturesService = require('./services/labFeaturesService');
 const featureAvailabilityService = require('./commons/featureAvailabilityService');
-const featureFlagService = require('./commons/featureFlags');
 
 const logger = require('./commons/logger').getLogger('runner');
 
@@ -269,7 +268,7 @@ async function init(options) {
         await labFeaturesService.loadLabFeatures(projectById.id, companyByProjectId.activePlan);
     }
 
-    if (options.lightweightMode && options.lightweightMode.type === 'turboMode' && (featureFlagService.flags.highSpeedMode.getValue() === 'disabled' || options.company.planType === 'free')) {
+    if (options.lightweightMode && options.lightweightMode.type === 'turboMode' && (featureFlags.flags.highSpeedMode.getValue() === 'disabled' || options.company.planType === 'free')) {
         delete options.lightweightMode;
     }
 

package/runners/ParallelWorkerManager.js

@@ -8,7 +8,6 @@ const config = require('../commons/config');
 const ExecutionQueue = require('../executionQueue');
 
 const testimCustomToken = require('../commons/testimCustomToken');
-const testimServicesApi = require('../commons/testimServicesApi');
 const labFeaturesService = require('../services/labFeaturesService');
 const perf = require('../commons/performance-logger');
 const { StopRunOnError } = require('../errors');

package/runners/TestPlanRunner.js

@@ -20,7 +20,6 @@ const { getSuite, calcTestResultStatus, validateConfig } = require('./runnerUtil
 const { StopRunOnError, ArgError } = require('../errors');
 const Logger = require('../commons/logger');
 const perf = require('../commons/performance-logger');
-const featureFlags = require('../commons/featureFlags');
 
 const guid = utils.guid;
 const logger = Logger.getLogger('test-plan-runner');
@@ -35,14 +34,14 @@ class TestPlanRunner {
         const executionResults = {};
         const authData = testimCustomToken.getTokenV3UserData();
 
-        const runBeforeTests = (beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData) => {
+        const runBeforeTests = () => {
             const workerCount = 1;
             const stopOnError = true;
             return this.workerManager.runTests(beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError)
                 .then(beforeTestsResults => Object.assign(executionResults, beforeTestsResults));
         };
 
-        const runTestPlanTests = (tests, testStatus, executionId, executionName, tpOptions, branchToUse, authData) => {
+        const runTestPlanTests = () => {
             const workerCount = config.TESTIM_CONCURRENT_WORKER_COUNT || tpOptions.parallel;
             const stopOnError = false;
             perf.log('right before this.workerManager.runTests');
@@ -51,30 +50,30 @@ class TestPlanRunner {
                 .then(testsResults => Object.assign(executionResults, testsResults));
         };
 
-        const runAfterTests = (afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData) => {
+        const runAfterTests = () => {
             const workerCount = 1;
             const stopOnError = false;
             return this.workerManager.runTests(afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError)
                 .then(afterTestsResults => Object.assign(executionResults, afterTestsResults));
         };
 
-        function catchBeforeTestsFailed(executionId) {
+        function catchBeforeTestsFailed() {
             return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
         }
 
         const sessionType = utils.getSessionType(tpOptions);
         analyticsService.analyticsExecsStart({ authData, executionId, projectId: tpOptions.project, sessionType });
         perf.log('right before runBeforeTests');
-        return runBeforeTests(beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData)
+        return runBeforeTests()
             .log('right before runTestPlanTests')
-            .then(() => runTestPlanTests(tests, testStatus, executionId, executionName, tpOptions, branchToUse, authData))
+            .then(() => runTestPlanTests())
             .log('right after runTestPlanTests')
-            .then(() => runAfterTests(afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData))
+            .then(() => runAfterTests())
             .then(() => executionResults)
             .catch(err => {
                 logger.error('error running test plan', { err });
                 if (err instanceof StopRunOnError) {
-                    return catchBeforeTestsFailed(executionId);
+                    return catchBeforeTestsFailed();
                 }
                 throw err;
             })

package/services/lambdatestService.js

@@ -1,13 +1,12 @@
 const os = require('os');
-const { spawn } = require('child_process');
+const childProcess = require('child_process');
 const Promise = require('bluebird');
 const fse = require('fs-extra');
 const portfinder = require('portfinder');
 const ms = require('ms');
 
-const {
-    downloadAndSave, unzipFile, guid, runWithRetries, isURL,
-} = require('../utils');
+const { guid, isURL } = require('../utils');
+const utils = require('../utils');
 const { gridTypes, CLI_MODE } = require('../commons/constants');
 const httpRequest = require('../commons/httpRequest');
 const { ArgError } = require('../errors');
@@ -86,8 +85,8 @@ class LambdatestService {
             throw new Error(`tunnel on ${os.platform() + os.arch()} platform is not supported.`);
         }
         const zipLocation = `${LT_TUNNEL_BINARY_DIRECTORY}.zip`;
-        await downloadAndSave(`${LT_TUNNEL_BINARY_ORIGIN}/${downloadUrl}`, zipLocation);
-        await unzipFile(zipLocation, LT_TUNNEL_BINARY_DIRECTORY);
+        await utils.downloadAndSave(`${LT_TUNNEL_BINARY_ORIGIN}/${downloadUrl}`, zipLocation);
+        await utils.unzipFile(zipLocation, LT_TUNNEL_BINARY_DIRECTORY);
     }
 
     static async connectTunnel(runnerOptions) {
@@ -140,7 +139,7 @@ class LambdatestService {
             tunnelArgs = [...tunnelArgs, '--mitm'];
         }
 
-        LambdatestService.tunnel = spawn('./LT', tunnelArgs, { cwd: LT_TUNNEL_BINARY_DIRECTORY });
+        LambdatestService.tunnel = childProcess.spawn('./LT', tunnelArgs, { cwd: LT_TUNNEL_BINARY_DIRECTORY });
 
         let stdoutResult = '';
         let stderrResult = '';
@@ -155,7 +154,7 @@ class LambdatestService {
 
         // verify that LT tunnel strated successfully
         try {
-            const ltInfo = await runWithRetries(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), 30, 2000);
+            const ltInfo = await utils.runWithRetries(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), 30, 2000);
             logger.info('LT tunnel info', ltInfo);
         } catch (err) {
             logger.error('Failed to start LT tunnel', { err, stdoutResult, stderrResult });
@@ -170,7 +169,7 @@ class LambdatestService {
         return new Promise((resolve, reject) => {
             LambdatestService.tunnel.on('close', (code) => {
                 if (code) {
-                    reject();
+                    reject(new Error(`tunnel process exited with code ${code}`));
                 }
                 resolve();
             });

package/services/lambdatestService.test.js

@@ -1,11 +1,38 @@
 const { expect, sinon } = require('../../test/utils/testUtils');
 const servicesApi = require('../commons/testimServicesApi');
+const httpRequest = require('../commons/httpRequest');
 const LambdatestService = require('./lambdatestService');
+const utils = require('../utils');
+const fse = require('fs-extra');
+const os = require('os');
+const childProcess = require('child_process');
+const EventEmitter = require('events');
+const portfinder = require('portfinder');
+const { getExtensionsUrl } = require('../runOptionsUtils');
+
+class Process extends EventEmitter {
+    constructor() {
+        super();
+        this.stdout = new EventEmitter();
+        this.stderr = new EventEmitter();
+    }
+    setCode(code) {
+        this.code = code;
+    }
+    kill() {
+        this.emit('close', this.code);
+    }
+}
 
 describe('LambdatestService', () => {
+    let sandbox;
     let lambdatestService;
     beforeEach(() => {
         lambdatestService = new LambdatestService();
+        sandbox = sinon.createSandbox();
+    });
+    afterEach(() => {
+        sandbox.restore();
     });
 
     describe('isLambdatestGrid', () => {
@@ -86,8 +113,240 @@ describe('LambdatestService', () => {
             lambdatestService.isActive = false;
             expect(lambdatestService.getSessionRetries).to.be.equal(null);
         });
+
+        it('should not return lt special selenium capabilities when inactove', () => {
+            lambdatestService.isActive = false;
+            expect(lambdatestService.getCapabilities({})).to.eql({});
+        });
+
+        it('should return lt selenium capabilities', () => {
+            const browser = utils.guid();
+            const executionId = utils.guid();
+            const testResultId = utils.guid();
+            const testName = utils.guid();
+
+            lambdatestService.isActive = true;
+            LambdatestService.lambdatestConfig = {
+                CAPABILITIES: { [browser]: { specificBrowserCaps: 123 } },
+            };
+
+            expect(lambdatestService.getCapabilities({}, browser, executionId, testResultId, testName)).to.shallowDeepEqual({
+                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,
+                specificBrowserCaps: 123,
+                console: true,
+                queueTimeout: 300,
+            });
+        });
+
+        it('should return lt tunnel name as part of selenium capabilities', () => {
+            lambdatestService.isActive = true;
+            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
+            LambdatestService.tunnelName = utils.guid();
+
+            expect(lambdatestService.getCapabilities({})).to.shallowDeepEqual({
+                tunnel: true,
+                tunnelName: LambdatestService.tunnelName,
+            });
+        });
+
+        it('should load testim extension when it is not set', () => {
+            lambdatestService.isActive = true;
+            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
+            LambdatestService.tunnelName = utils.guid();
+
+            expect(lambdatestService.getCapabilities({ mode: 'extension' }, 'chrome')).to.shallowDeepEqual({ loadExtension: [getExtensionsUrl({}, true).chrome] });
+            expect(lambdatestService.getCapabilities({ mode: 'extension' }, 'somOtherBrowser')).to.shallowDeepEqual({ loadExtension: [] });
+        });
+
+        it('should load testim extension when passing extensionPath flag', () => {
+            lambdatestService.isActive = true;
+            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
+            LambdatestService.tunnelName = utils.guid();
+
+            const extensionPath = 'http://localhost:1234/extension.zip';
+            expect(lambdatestService.getCapabilities({ mode: 'extension', extensionPath })).to.shallowDeepEqual({ loadExtension: [extensionPath] });
+        });
+
+        it('should load testim extension when passing installCustomExtension flag', () => {
+            lambdatestService.isActive = true;
+            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
+            LambdatestService.tunnelName = utils.guid();
+
+            const installCustomExtension = 'http://localhost:1234/extension.zip';
+            expect(lambdatestService.getCapabilities({ mode: 'extension', installCustomExtension })).to.shallowDeepEqual({ loadExtension: [installCustomExtension] });
+        });
+    });
+
+    describe('prepareTunnel', () => {
+        it('should do nothing when tunnel binary already exists', async () => {
+            sandbox.stub(fse, 'pathExists').resolves(true);
+            const chmod = sandbox.stub(fse, 'chmodSync');
+            await LambdatestService.prepareTunnel();
+            expect(chmod).not.to.have.been.called;
+        });
+
+        it('should throw when unsupported os', async () => {
+            sandbox.stub(fse, 'pathExists').resolves(false);
+            sandbox.stub(os, 'platform').returns('wtf');
+            sandbox.stub(os, 'arch').returns('wtf');
+
+            await expect(LambdatestService.prepareTunnel()).to.be.rejectedWith(Error, 'tunnel on wtfwtf platform is not supported.');
+        });
+
+        it('should download and extract tunnel binary', async () => {
+            sandbox.stub(fse, 'pathExists').resolves(false);
+            sandbox.stub(os, 'platform').returns('win32');
+            sandbox.stub(os, 'arch').returns('x64');
+
+            const download = sandbox.stub(utils, 'downloadAndSave');
+            const unzip = sandbox.stub(utils, 'unzipFile').resolves();
+
+            await LambdatestService.prepareTunnel();
+            sinon.assert.calledOnce(unzip);
+            sinon.assert.calledOnce(download);
+            expect(download.args[0][0]).to.startWith('https://downloads.lambdatest.com/tunnel/');
+        });
     });
 
     describe('connectTunnel', () => {
+        let prepareTunnelStub;
+        let spawnStub;
+        let credentials;
+        let httpGetStub;
+        let processMock;
+
+        beforeEach(() => {
+            processMock = new Process();
+            credentials = { gridUsername: utils.guid(), gridPassword: utils.guid() };
+            sandbox.stub(portfinder, 'getPortPromise').resolves(1234);
+            prepareTunnelStub = sandbox.stub(LambdatestService, 'prepareTunnel');
+            spawnStub = sandbox.stub(childProcess, 'spawn').returns(processMock);
+            httpGetStub = sandbox.stub(httpRequest, 'get').resolves({});
+        });
+
+        it('should do nothing when using externalLambdatestTunnelId', async () => {
+            await LambdatestService.connectTunnel({ externalLambdatestTunnelId: 123 });
+            sinon.assert.neverCalledWith(prepareTunnelStub);
+            sinon.assert.neverCalledWith(spawnStub);
+        });
+
+        it('should prepare the tunnel', async () => {
+            await LambdatestService.connectTunnel({ ...credentials });
+            sinon.assert.calledOnce(prepareTunnelStub);
+        });
+
+        it('should reject when no credentials', async () => {
+            await expect(LambdatestService.connectTunnel({ })).to.be.rejectedWith(Error, 'tunnel requires username and password');
+        });
+
+        it('should spawn the tunnel process', async () => {
+            await LambdatestService.connectTunnel({ ...credentials });
+            sinon.assert.calledOnce(spawnStub);
+            expect(spawnStub.args[0][1]).to.eql([
+                '--tunnelName', LambdatestService.tunnelName, '--infoAPIPort', 1234,
+                '--user', credentials.gridUsername, '--key', credentials.gridPassword,
+            ]);
+        });
+
+        it('should accept tunnelUser and tunnelKey on gridData', async () => {
+            credentials = { gridData: { tunnelUser: utils.guid(), tunnelKey: utils.guid() } };
+            await LambdatestService.connectTunnel({ ...credentials });
+            sinon.assert.calledOnce(spawnStub);
+            expect(spawnStub.args[0][1]).to.eql([
+                '--tunnelName', LambdatestService.tunnelName, '--infoAPIPort', 1234,
+                '--user', credentials.gridData.tunnelUser, '--key', credentials.gridData.tunnelKey,
+            ]);
+        });
+
+        it('should allow using externalLambdatestUseWss', async () => {
+            await LambdatestService.connectTunnel({ ...credentials, externalLambdatestUseWss: true });
+            sinon.assert.calledOnce(spawnStub);
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--mode ws');
+        });
+
+        it('should allow using proxyUri', async () => {
+            global.proxyUri = 'http://localhost';
+            await LambdatestService.connectTunnel({ ...credentials });
+            sinon.assert.calledOnce(spawnStub);
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-host localhost');
+            global.proxyUri = undefined;
+        });
+
+        it('should allow using proxyUri port and credentials', async () => {
+            global.proxyUri = 'http://user:pass@localhost:1234';
+            await LambdatestService.connectTunnel({ ...credentials });
+            sinon.assert.calledOnce(spawnStub);
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-host localhost');
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-port 1234');
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-user user');
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-pass pass');
+            global.proxyUri = undefined;
+        });
+
+        it('should throw when proxyUri is invalid', async () => {
+            global.proxyUri = 'i am invalid';
+            await expect(LambdatestService.connectTunnel({ ...credentials })).to.be.rejectedWith(Error, 'proxy url is invalid');
+            global.proxyUri = undefined;
+        });
+
+        it('should allow using externalLambdatestDisableAutomationTunneling', async () => {
+            await LambdatestService.connectTunnel({ ...credentials, externalLambdatestDisableAutomationTunneling: true });
+            sinon.assert.calledOnce(spawnStub);
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--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');
+        });
+
+        it('should allow using externalLambdatestMitm', async () => {
+            await LambdatestService.connectTunnel({ ...credentials, externalLambdatestMitm: true });
+            sinon.assert.calledOnce(spawnStub);
+            expect(spawnStub.args[0][1].join(' ')).to.contain('--mitm');
+        });
+
+        it('should verify tunnel started', async () => {
+            await LambdatestService.connectTunnel({ ...credentials });
+            sinon.assert.calledOnce(httpGetStub);
+        });
+        it('should throw when tunnel did not start', async () => {
+            sandbox.stub(utils, 'runWithRetries').rejects(new Error('tunnel did not start'));
+            await expect(LambdatestService.connectTunnel({ ...credentials })).to.be.rejectedWith(Error, 'tunnel did not start');
+            processMock.stdout.emit('data', '');
+            processMock.stderr.emit('data', '');
+        });
+    });
+
+    describe('disconnectTunnel', () => {
+        let processMock;
+        let killStub;
+
+        beforeEach(() => {
+            processMock = new Process();
+            killStub = sandbox.stub(processMock, 'kill').callThrough();
+            sandbox.stub(childProcess, 'spawn').returns(processMock);
+            sandbox.stub(LambdatestService, 'prepareTunnel');
+            sandbox.stub(httpRequest, 'get').resolves({});
+        });
+
+        it('should kill the tunnel', async () => {
+            await LambdatestService.connectTunnel({ tunnel: true, company: {}, gridUsername: utils.guid(), gridPassword: utils.guid() });
+            await LambdatestService.disconnectTunnel({ company: {} });
+            sinon.assert.calledOnce(killStub);
+        });
+
+        it('should reject when killing the tunnel fails', async () => {
+            processMock.setCode(1);
+            await LambdatestService.connectTunnel({ tunnel: true, company: {}, gridUsername: utils.guid(), gridPassword: utils.guid() });
+            await expect(LambdatestService.disconnectTunnel({ company: {} })).to.be.rejectedWith(Error);
+            sinon.assert.calledOnce(killStub);
+        });
+
+        it('should do nothing when using externalLambdatestTunnelId', async () => {
+            await LambdatestService.disconnectTunnel({ externalLambdatestTunnelId: 123 });
+            sinon.assert.neverCalledWith(killStub);
+        });
     });
 });