@testim/testim-cli 3.254.0 → 3.255.0

package/reports/reporter.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const logger = require('../commons/logger').getLogger('reporter');
-const Promise = require('bluebird');
 
 class Reporter {
     setOptions(options, branchToUse) {
@@ -46,7 +45,7 @@ class Reporter {
         }
     }
 
-    onTestPlanFinished(testResults, testPlanName, startTime, executionId, isAnonymous, isCodeMode, childTestResults) {
+    async onTestPlanFinished(testResults, testPlanName, startTime, executionId, isAnonymous, isCodeMode, childTestResults) {
         let results = {};
 
         // TODO: remove mutation of testResults from the Reporter
@@ -68,62 +67,55 @@ class Reporter {
         } else {
             results = testResults;
         }
-
-        return Promise.each(this.reporters, reporter => {
+        for (const reporter of this.reporters) {
             if (reporter?.onTestPlanFinished) {
                 const duration = Date.now() - (startTime || 0);
-                return reporter.onTestPlanFinished(results, testPlanName, duration, executionId, isAnonymous, isCodeMode);
+                await reporter.onTestPlanFinished(results, testPlanName, duration, executionId, isAnonymous, isCodeMode);
             }
-            return undefined;
-        });
+        }
     }
 
-    onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode) {
-        return Promise.each(this.reporters, reporter => {
+    async onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode) {
+        for (const reporter of this.reporters) {
             if (reporter?.onTestPlanStarted) {
-                return reporter.onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
+                await reporter.onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
             }
-            return undefined;
-        });
+        }
     }
 
-    onGetSlot(workerId, browser) {
-        return Promise.each(this.reporters, reporter => {
+    async onGetSlot(workerId, browser) {
+        for (const reporter of this.reporters) {
             if (reporter?.onGetSlot) {
-                return reporter.onGetSlot(workerId, browser);
+                await reporter.onGetSlot(workerId, browser);
             }
-            return undefined;
-        });
+        }
     }
 
-    onGetSession(workerId, testName, mode) {
-        return Promise.each(this.reporters, reporter => {
+    async onGetSession(workerId, testName, mode) {
+        for (const reporter of this.reporters) {
             if (reporter?.onGetSession) {
-                return reporter.onGetSession(workerId, testName, mode);
+                await reporter.onGetSession(workerId, testName, mode);
             }
-            return undefined;
-        });
+        }
     }
 
-    onWaitToTestComplete(workerId, isCodeMode, debuggerAddress) {
-        return Promise.each(this.reporters, reporter => {
+    async onWaitToTestComplete(workerId, isCodeMode, debuggerAddress) {
+        for (const reporter of this.reporters) {
             if (reporter?.onWaitToTestComplete) {
-                return reporter.onWaitToTestComplete(workerId, isCodeMode, debuggerAddress);
+                await reporter.onWaitToTestComplete(workerId, isCodeMode, debuggerAddress);
             }
-            return undefined;
-        });
+        }
     }
 
-    onWaitToTestStart(workerId) {
-        return Promise.each(this.reporters, reporter => {
+    async onWaitToTestStart(workerId) {
+        for (const reporter of this.reporters) {
             if (reporter?.onWaitToTestStart) {
-                return reporter.onWaitToTestStart(workerId);
+                await reporter.onWaitToTestStart(workerId);
             }
-            return undefined;
-        });
+        }
     }
 
-    onAllTestPlansFinished(testPlanResults) {
+    async onAllTestPlansFinished(testPlanResults) {
         // TODO: remove mutation of testPlanResults from the Reporter
         for (const result of testPlanResults) {
             if (result.childTestResults) {
@@ -140,18 +132,21 @@ class Reporter {
             }
         }
 
-        return Promise.each(this.reporters, reporter => {
+        for (const reporter of this.reporters) {
             if (reporter?.onAllTestPlansFinished) {
-                return reporter.onAllTestPlansFinished(testPlanResults);
+                await reporter.onAllTestPlansFinished(testPlanResults);
             }
-            return undefined;
-        });
+        }
     }
 }
 
 function addHook(name) {
-    Reporter.prototype[name] = function (...args) {
-        return Promise.filter(this.reporters, reporter => reporter?.[name]).each(reporter => reporter[name](...args));
+    Reporter.prototype[name] = async function (...args) {
+        for (const reporter of this.reporters) {
+            if (reporter?.[name]) {
+                await reporter[name](...args);
+            }
+        }
     };
 }
 

package/runOptions.d.ts

@@ -0,0 +1,260 @@
+interface LoginModeOptions {
+    loginMode: true;
+}
+
+interface InitModeOptions {
+    initCodimMode: true;
+    initTestProject: string;
+}
+
+interface AgentModeOptions {
+    agentMode: true;
+    project?: string;
+    token?: string;
+    agentPort: number;
+    agentBind?: string;
+    openEditor?: boolean;
+    installPlaygroundPlaywrightDeps: boolean;
+    installPlaygroundPuppeteerDeps: boolean;
+    installPlaygroundSeleniumDeps: boolean;
+    startTestimBrowser: boolean;
+    ext?: string;
+    extensionPath?: string;
+    playerLocation: string;
+    canary?: boolean;
+    playerPath?: string;
+    playerRequirePath?: string;
+    downloadBrowser: boolean;
+}
+
+interface TunnelDaemonOptions {
+    tunnelOnlyMode: true;
+    tunnelRoutes: string[];
+    tunnelRoutesOutput: string;
+    tunnelHostHeader?: string;
+    tunnelRegion?: string;
+}
+interface NgrokTunnelOptions {
+    tunnelPort: number;
+    tunnelDiagnostics?: boolean;
+}
+
+type TunnelOptions = (TunnelDaemonOptions | NgrokTunnelOptions) & {
+    tunnel: true;
+    tunnelUseHttpAddress?: boolean;
+    token: string;
+    project: string;
+};
+
+type CodeCoverageReporter = 'clover' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
+
+interface LightweightSettings {
+    type: 'lightweight' | 'turboMode';
+    general: boolean;
+    disableLabs: boolean;
+    disableFeatureFlags: boolean;
+    disableAssets: boolean;
+    disablePixelValidation: boolean;
+    disableResults: boolean;
+    disableStepDelay: boolean;
+    disableRemoteStep: boolean;
+    assumePreloadedSharedSteps: boolean;
+    disableVisibilityCheck: boolean;
+    disableLocators: boolean;
+    bypassSetup: boolean;
+    disableAutoImprove: boolean;
+    disableQuotaBlocking: boolean;
+    onlyTestIdsNoSuite: boolean;
+    uploadAssetsAndResultsOnFailure: boolean;
+    preloadTests: boolean;
+    disableProjectDefaults: boolean;
+}
+
+// TODO: consider typing better, based on the validations we do (example: must have one of grid/grid-id/host&port/test plan)
+interface RunnerOptions extends Partial<Omit<TunnelOptions, 'tunnelOnlyMode' | 'tunnel'>> {
+    token: string;
+    project: string;
+    user?: string;
+    webpackConfig?: string;
+    headless?: boolean;
+    disableNativeEvents?: boolean;
+    baseUrl?: string;
+    branch: string;
+    autoDetect: boolean;
+    userParamsData: object;
+    mode: 'selenium' | 'extension';
+    isRegressionBaselineRun?: boolean;
+    canary?: boolean;
+    rerunFailedByRunId?: string;
+    disableTimeoutRetry?: boolean;
+    resultLabels: string[];
+    path?: string;
+    protocol?: string;
+    testobjectSauce: { testobjectApiKey?: string };
+    overrideExecutionName?: string;
+    passZeroTests: boolean;
+    runQuarantinedTests: boolean;
+    downloadBrowser: boolean;
+    disableSockets: boolean;
+    disableCookiesSameSiteNoneRequiresSecure: boolean;
+    shouldMonitorPerformance?: boolean;
+    exitCodeIgnoreFailingTests?: boolean;
+    seleniumCapsFileContent: object;
+    retentionDays?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+    retries?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;
+
+    // #region What to execute
+    testId: string[];
+    name: string[];
+    label: string[];
+    suites: string[];
+    suiteIds: string[];
+    testPlan: string[];
+    testPlanIds: string[];
+    files: string[];
+    // #endregion
+
+    // #region Test config to use
+    testConfigNames?: string[];
+    testConfigIds?: string[];
+    // #endregion
+
+    // #region Grid details
+    grid?: string;
+    gridId?: string;
+    host?: string;
+    port?: number;
+    gridUsername?: string;
+    gridPassword?: string;
+    useLocalChromeDriver?: boolean;
+    chromeBinaryLocation?: string;
+    useChromeLauncher?: boolean;
+
+    disableGridCheck: boolean;
+    browser?: 'ie11' | 'ie' | 'internet explorer' | 'edge' | 'edge-chromium' | 'firefox' | 'safari' | 'chrome';
+
+    proxyForGrid: string;
+
+    experitestToken?: string;
+    saucelabs: { username: string; accessKey: string };
+    perfecto: { securityToken?: string; location?: string };
+    browserstack: { 'browserstack.user': string; 'browserstack.key': string };
+    // #endregion
+
+    // #region Report settings
+    reportFile?: string;
+    reportFileClassname?: string;
+    reporters?: string[];
+    // #endregion
+
+    // #region Parallel settings
+    beforeParallel: number;
+    parallel: number;
+    afterParallel: number;
+    //#endregion
+
+    // #region TMS
+    tmsSuppressReporting: boolean;
+    tmsRunId?: string;
+    tmsCustomFields?: string;
+    // #endregion
+
+    // #region Extension debugging
+    ext?: string;
+    extensionLocation?: string[];
+    extensionPath?: string;
+    // #endregion
+
+    // #region Session Player debugging
+    playerLocation: string;
+    playerPath?: string;
+    playerRequirePath?: string;
+    // #endregion
+
+    // #region Tunnel
+    tunnel?: boolean;
+    externalLambdatestTunnelId?: string;
+    externalLambdatestUseWss?: string;
+    externalLambdatestDisableAutomationTunneling: boolean;
+    externalLambdatestMitm: boolean;
+    // #endregion
+
+    // #region Hooks
+    beforeTest?: Function;
+    afterTest?: Function;
+    beforeSuite?: Function;
+    afterSuite?: Function;
+    // #endregion
+
+    // #region Timeouts
+    testStartTimeout: number;
+    timeout: number;
+    timeoutWasGiven: boolean;
+    browserTimeout: number;
+    newBrowserWaitTimeout: number;
+    getBrowserTimeout: number;
+    getBrowserRetries: number;
+    getSessionTimeout: number;
+    getSessionRetries: number;
+    driverRequestTimeout: number;
+    driverRequestRetries: number;
+    // #endregion
+
+    // #region Mock network
+    overrideMappingFile?: string;
+    mockNetworkRules?: object;
+    disableMockNetwork?: boolean;
+    // #endregion
+
+    // #region Code coverage
+    codeCoverageUrlFilter?: string;
+    collectCodeCoverage?: boolean;
+    codeCoverageReportPath?: string;
+    codeCoverageSourceMapPath?: string;
+    codeCoverageReporter: CodeCoverageReporter[];
+    codeCoverageInclude: string[];
+    // #endregion
+
+    // #region Remote run options
+    executionId?: string;
+    remoteRunId?: string;
+    schedulerId?: string;
+    source?: string;
+    resultId?: string;
+    // #endregion
+
+    // #region Customer Extension
+    installCustomExtension?: string;
+    // #endregion
+
+    // #region Capabilities format
+    w3cCapabilities: boolean;
+    oldCapabilities: boolean;
+    // #endregion
+
+    // #region Chrome specific settings
+    chromeBlockLocation: boolean;
+    chromeUserDataDir: false | string;
+    chromeExtraPrefs: object;
+    chromeExtraArgs: string[];
+    // #endregion
+
+    // #region Lightweight / Turbo Mode
+    lightweightMode?: LightweightSettings;
+    createPrefechedData?: boolean;
+    saveRCALocally?: boolean | string;
+    // #endregion
+
+    // #region intersections
+    intersections: { labels?: string[]; suiteNames?: string[]; suiteIds?: string[] };
+    // #endregion
+}
+
+type Options = |
+    LoginModeOptions |
+    InitModeOptions |
+    AgentModeOptions |
+    TunnelOptions |
+    RunnerOptions;
+
+export function process(): Promise<Options>;

package/runOptions.js

@@ -2,22 +2,20 @@
 
 'use strict';
 
-const { CLI_MODE } = require('./commons/constants');
-const { EDGE_CHROMIUM_MIN_VERSION } = require('./player/constants');
-const program = require('commander');
 const fs = require('fs');
 const ms = require('ms');
-const Promise = require('bluebird');
-const NoArgsError = require('./errors.js').NoArgsError;
-const ArgError = require('./errors.js').ArgError;
 const url = require('url');
 const _ = require('lodash');
 const path = require('path');
+const chalk = require('chalk');
+const program = require('commander');
 const utils = require('./utils');
-const runOptionsAgentFlow = require('./runOptionsAgentFlow');
 const runOptionsUtils = require('./runOptionsUtils');
+const runOptionsAgentFlow = require('./runOptionsAgentFlow');
 const localRunnerCache = require('./commons/runnerFileCache');
-const chalk = require('chalk');
+const { CLI_MODE } = require('./commons/constants');
+const { NoArgsError, ArgError } = require('./errors');
+const { EDGE_CHROMIUM_MIN_VERSION } = require('./player/constants');
 
 const camelizeHyphenValues = (prop) => prop.replace(/-([a-z])/g, (m, w) => w.toUpperCase());
 
@@ -114,6 +112,10 @@ const printUsage = () => {
         return line.includes('--high-speed'); // high speed mode was renamed to turbo mode
     }
 
+    function isTestStartTimeout(line) {
+        return line.includes('--test-start-timeout');
+    }
+
     program.help((txt) => {
         const lines = txt.split('\n');
         return lines
@@ -129,7 +131,8 @@ const printUsage = () => {
                     !isWebdriverTimeout(ln) &&
                     !isSaveRCALocally(ln) &&
                     !isExitCodeIgnoreFailingTests(ln) &&
-                    !isDeprecatedHighSpeed(ln)
+                    !isDeprecatedHighSpeed(ln) &&
+                    !isTestStartTimeout(ln)
             )
             .join('\n');
     });
@@ -217,17 +220,18 @@ program
     .option('--file-cache-location [directory]', ' internal CLI file caching location')
 
     // Timeout
-    .option('--timeout [test-timeout]', 'test run timeout in milliseconds')
-    .option('--browser-timeout [open-browser-timeout]', 'get browser from grid timeout in milliseconds')
-    .option('--new-browser-wait-timeout [max-wait-to-browser]', 'maximum get browser wait in minutes')
+    .option('--test-start-timeout [test-start-timeout]', 'The time to wait for a test to start after getting a browser session', Number, Number(process.env.TESTIM_TEST_START_TIMEOUT) || (2 * 60 * 1000))
+    .option('--timeout [test-timeout]', 'Test run timeout in milliseconds', Number)
+    .option('--browser-timeout [open-browser-timeout]', 'Get browser from grid timeout in milliseconds', Number)
+    .option('--new-browser-wait-timeout [max-wait-to-browser]', 'Maximum get browser wait in minutes', Number)
 
     // New Timeouts
-    .option('--get-browser-timeout [get-browser-timeout]', 'Timeout for a single attempt to get browser from the grid configured in the project\'s plan') // getBrowserTimeout
-    .option('--get-browser-retries [get-browser-retries]', 'Number of attempts to get browser from the grid configured in the project\'s plan') // getBrowserRetries
-    .option('--get-session-timeout [get-session-timeout]', 'Timeout for "/session" request to the selenium server', ms('90s')) // getSessionTimeout
-    .option('--get-session-retries [get-session-retries]', 'Retries for "/session" request to the selenium server', 3) // getSessionRetries
-    .option('--driver-request-timeout [driver-request-timeout]', 'Timeout for any WebDriver request to the grid server', ms('90s')) // driverRequestTimeout
-    .option('--driver-request-retries [driver-request-retries]', 'Retries for any WebDriver request to the grid server', 3) // driverRequestRetries
+    .option('--get-browser-timeout [get-browser-timeout]', 'Timeout for a single attempt to get browser from the grid configured in the project\'s plan', Number) // getBrowserTimeout
+    .option('--get-browser-retries [get-browser-retries]', 'Number of attempts to get browser from the grid configured in the project\'s plan', Number) // getBrowserRetries
+    .option('--get-session-timeout [get-session-timeout]', 'Timeout for "/session" request to the selenium server', Number, ms('90s')) // getSessionTimeout
+    .option('--get-session-retries [get-session-retries]', 'Retries for "/session" request to the selenium server', Number, 3) // getSessionRetries
+    .option('--driver-request-timeout [driver-request-timeout]', 'Timeout for any WebDriver request to the grid server', Number, ms('90s')) // driverRequestTimeout
+    .option('--driver-request-retries [driver-request-retries]', 'Retries for any WebDriver request to the grid server', Number, 3) // driverRequestRetries
 
     // Run chrome ext mode locally
     .option('--use-local-chrome-driver [use-local-chrome-driver]', 'use a local ChromeDriver instance instead of a selenium grid')
@@ -510,8 +514,10 @@ module.exports = {
         try {
             let options = {};
             if (program.configFile) {
+                // eslint-disable-next-line import/no-dynamic-require
                 options = require(path.join(process.cwd(), program.configFile)).config;
             } else if (program.optionsFile) {
+                // eslint-disable-next-line import/no-dynamic-require
                 options = require(path.join(process.cwd(), program.optionsFile));
             }
 
@@ -546,19 +552,20 @@ module.exports = {
         }
 
 
-        const isTestConfigSpecified = (program.testConfig && program.testConfig.length) || (program.testConfigId && program.testConfigId.length);
-        const isTestPlanSpecified = (program.testPlan && program.testPlan.length) || (program.testPlanId && program.testPlanId.length);
-        const isSuiteSpecified = (program.suite && program.suite.length) || (program.suiteId && program.suiteId.length);
+        const isTestConfigSpecified = program.testConfig?.length || program.testConfigId?.length;
+        const isTestPlanSpecified = program.testPlan?.length || program.testPlanId?.length;
+        const isSuiteSpecified = program.suite?.length || program.suiteId?.length;
 
         if (program.seleniumCapsFile) {
             try {
+                // eslint-disable-next-line import/no-dynamic-require
                 seleniumCapsFileContent = require(path.join(process.cwd(), program.seleniumCapsFile));
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to parse selenium caps file file error: ${err.message}`));
+                throw new ArgError(`Failed to parse selenium caps file file error: ${err.message}`);
             }
         }
 
-        if (program.reporters && program.reporters.includes('junit') && !program.reportFile) {
+        if (program.reporters?.includes('junit') && !program.reportFile) {
             console.log('Warning: please define --report-file option for JUnit reporter');
         }
 
@@ -575,9 +582,10 @@ module.exports = {
         }
         if (program.chromeExtraPrefs) {
             try {
+                // eslint-disable-next-line import/no-dynamic-require
                 chromeExtraPrefs = require(path.join(process.cwd(), program.chromeExtraPrefs));
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to read/open chrome extra prefs file error: ${err.message}`));
+                throw new ArgError(`Failed to read/open chrome extra prefs file error: ${err.message}`);
             }
         }
 
@@ -598,9 +606,10 @@ module.exports = {
 
         if (program.paramsFile) {
             try {
+                // eslint-disable-next-line import/no-dynamic-require
                 userParamsData = Object.assign({}, userParamsData, require(path.join(process.cwd(), program.paramsFile)));
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to read/open params file error: ${err.message}`));
+                throw new ArgError(`Failed to read/open params file error: ${err.message}`);
             }
         }
 
@@ -608,7 +617,7 @@ module.exports = {
             try {
                 userParamsData = Object.assign({}, userParamsData, JSON.parse(program.params));
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to parse params string error: ${err.message}`));
+                throw new ArgError(`Failed to parse params string error: ${err.message}`);
             }
         }
 
@@ -627,6 +636,7 @@ module.exports = {
 
         if (program.sauceOptions) {
             try {
+                // eslint-disable-next-line import/no-dynamic-require
                 const sOptions = require(path.join(process.cwd(), program.sauceOptions));
                 const isMobile = sOptions.platformName && ['ios', 'android'].includes(sOptions.platformName.toLowerCase());
                 if (sOptions.browserName) {
@@ -649,12 +659,12 @@ module.exports = {
 
                 const isBadVersion = parseFloat(sOptions.version) < 50 && !['dev', 'beta'].includes(sOptions.version);
                 if (!isMobile && program.browser === 'chrome' && isBadVersion) {
-                    return Promise.reject(new ArgError('The minimum chrome supported version is 50.0'));
+                    throw new ArgError('The minimum chrome supported version is 50.0');
                 }
 
                 program.saucelabs = Object.assign({}, program.saucelabs, sOptions);
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to parse saucelabs options file error: ${err.message}`));
+                throw new ArgError(`Failed to parse saucelabs options file error: ${err.message}`);
             }
         }
 
@@ -672,6 +682,7 @@ module.exports = {
 
         if (program.browserstackOptions) {
             try {
+                // eslint-disable-next-line import/no-dynamic-require
                 const bsOptions = require(path.join(process.cwd(), program.browserstackOptions));
                 const isMobile = bsOptions.platform && ['mac', 'android'].includes(bsOptions.platform.toLowerCase());
                 if (bsOptions.browserName) {
@@ -683,12 +694,12 @@ module.exports = {
                 }
 
                 if (!isMobile && parseFloat(bsOptions.browser_version) < 50 && program.browser === 'chrome') {
-                    return Promise.reject(new ArgError('The minimum chrome supported version is 50.0'));
+                    throw new ArgError('The minimum chrome supported version is 50.0');
                 }
 
                 program.browserstack = Object.assign({}, program.browserstack, bsOptions);
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to parse browserstack options file error: ${err.message}`));
+                throw new ArgError(`Failed to parse browserstack options file error: ${err.message}`);
             }
         }
 
@@ -700,11 +711,12 @@ module.exports = {
 
         if (program.perfectoOptions) {
             try {
+                // eslint-disable-next-line import/no-dynamic-require
                 const perfectoOptions = require(path.join(process.cwd(), program.perfectoOptions));
                 const DEFAULTS = { location: 'US East', securityToken: program.perfectoToken };
                 program.perfecto = Object.assign({}, DEFAULTS, perfectoOptions);
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to parse perfecto options file error: ${err.message}`));
+                throw new ArgError(`Failed to parse perfecto options file error: ${err.message}`);
             }
         }
 
@@ -716,11 +728,12 @@ module.exports = {
 
         if (program.testobjectOptions) {
             try {
+                // eslint-disable-next-line import/no-dynamic-require
                 const testobjectOptions = require(path.join(process.cwd(), program.testobjectOptions));
                 const DEFAULTS = { testobjectApiKey: program.testobjectKey };
                 program.testobjectSauce = Object.assign({}, DEFAULTS, testobjectOptions);
             } catch (err) {
-                return Promise.reject(new ArgError(`Failed to parse test object options file error: ${err.message}`));
+                throw new ArgError(`Failed to parse test object options file error: ${err.message}`);
             }
         }
 
@@ -751,8 +764,8 @@ module.exports = {
         }
 
         program.retries = !program.retries || typeof program.retries === 'boolean' ? 1 : Number(program.retries) + 1;
-        program.browserTimeout = !program.browserTimeout || typeof program.browserTimeout === 'boolean' ? 60 * 1000 : Number(program.browserTimeout);
-        program.newBrowserWaitTimeout = !program.newBrowserWaitTimeout || typeof program.newBrowserWaitTimeout === 'boolean' ? 10 * 60 * 1000 : Number(program.newBrowserWaitTimeout * 60 * 1000);
+        program.browserTimeout = !program.browserTimeout || typeof program.browserTimeout === 'boolean' ? 60 * 1000 : program.browserTimeout;
+        program.newBrowserWaitTimeout = !program.newBrowserWaitTimeout || typeof program.newBrowserWaitTimeout === 'boolean' ? 10 * 60 * 1000 : program.newBrowserWaitTimeout * 60 * 1000;
 
         if (!program.getBrowserTimeout) {
             program.getBrowserTimeout = program.browserTimeout;
@@ -764,7 +777,7 @@ module.exports = {
         program.driverRequestTimeout = program.browserTimeout < program.driverRequestTimeout ? program.driverRequestTimeout : program.browserTimeout;
 
         const timeoutWasGiven = Boolean(program.timeout);
-        program.timeout = !program.timeout || typeof program.timeout === 'boolean' ? 10 * 60 * 1000 : Number(program.timeout);
+        program.timeout = !program.timeout || typeof program.timeout === 'boolean' ? 10 * 60 * 1000 : program.timeout;
         program.beforeParallel = !program.beforeParallel || typeof program.beforeParallel === 'boolean' ? 1 : Number(program.beforeParallel);
         program.parallel = !program.parallel || typeof program.parallel === 'boolean' ? 1 : Number(program.parallel);
         program.afterParallel = !program.afterParallel || typeof program.afterParallel === 'boolean' ? 1 : Number(program.afterParallel);
@@ -901,7 +914,7 @@ module.exports = {
             throw new ArgError('please define exactly one of --grid or --grid-id or --host');
         }
 
-        if (program.host && program.host.includes('/')) {
+        if (program.host?.includes('/')) {
             if (!/^(f|ht)tps?:\/\//i.test(program.host)) {
                 program.host = `http://${program.host}`;
             }
@@ -1009,7 +1022,7 @@ module.exports = {
                 const fileContent = fs.readFileSync(program.tmsFieldFile);
                 program.tmsCustomFields = JSON.parse(fileContent);
             } catch (err) {
-                return Promise.reject(new ArgError(`failed to parse field file error: ${err.message}`));
+                throw new ArgError(`failed to parse field file error: ${err.message}`);
             }
         }
 
@@ -1046,7 +1059,7 @@ module.exports = {
                 const lightweightModeOptions = typeof program.lightweightMode === 'string' ? JSON.parse(program.lightweightMode) : {};
                 program.lightweightMode = Object.assign({}, DEFAULTS, lightweightModeOptions);
             } catch (err) {
-                return Promise.reject(new ArgError(`failed to parse lightweightMode settings error: ${err.message}`));
+                throw new ArgError(`failed to parse lightweightMode settings error: ${err.message}`);
             }
         } else if (program.turboMode && program.mode === CLI_MODE.EXTENSION) {
             program.lightweightMode = {
@@ -1179,6 +1192,8 @@ module.exports = {
             driverRequestTimeout: program.driverRequestTimeout,
             driverRequestRetries: program.driverRequestRetries,
 
+            testStartTimeout: program.testStartTimeout,
+
             testConfigNames: program.testConfig,
             testConfigIds: program.testConfigId,