@testim/testim-cli 3.252.0 → 3.254.0

package/reports/debugReporter.js

@@ -16,33 +16,48 @@ const MASK_OPTIONS = {
     testobjectSauce: undefined,
 };
 
-const DebugReporter = function (options) {
-    this.options = options;
-};
+class DebugReporter {
+    constructor(options) {
+        this.options = options;
+    }
 
-DebugReporter.prototype.onTestStarted = function (test, workerId) {
-    logger.info('Test Started', { testId: test.testId, testName: test.name, resultId: test.resultId, workerId });
-};
+    onTestStarted(test, workerId) {
+        logger.info('Test Started', { testId: test.testId, testName: test.name, resultId: test.resultId, workerId });
+    }
 
-DebugReporter.prototype.onTestFinished = function (test, workerId) {
-    const gridData = this.options.gridData || {};
-    const provider = gridData.provider;
-    const host = gridData.host;
-    const gridId = gridData.gridId;
-    const gridType = gridData.type;
-    const failedGetBrowserAttempts = gridData.failedGetBrowserAttempts;
-    logger.info('Test Finished', {
-        testId: test.testId,
-        testName: test.name,
-        resultId: test.resultId,
-        success: test.success,
-        duration: test.duration,
-        browser: this.options.browser,
-        companyId: this.options.company.companyId,
-        grid: { provider, host, failedGetBrowserAttempts, id: gridId, type: gridType },
-        workerId,
-    });
-};
+    onTestFinished(test, workerId) {
+        const gridData = this.options.gridData || {};
+        const provider = gridData.provider;
+        const host = gridData.host;
+        const gridId = gridData.gridId;
+        const gridType = gridData.type;
+        const failedGetBrowserAttempts = gridData.failedGetBrowserAttempts;
+        logger.info('Test Finished', {
+            testId: test.testId,
+            testName: test.name,
+            resultId: test.resultId,
+            success: test.success,
+            duration: test.duration,
+            browser: this.options.browser,
+            companyId: this.options.company.companyId,
+            grid: { provider, host, failedGetBrowserAttempts, id: gridId, type: gridType },
+            workerId,
+        });
+    }
+
+    onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName) {
+        const args = stripTokenFromConsoleArguments(process.argv);
+
+        logger.info('Test Plan Started', { executionId, testPlanName, isAnonymous, configName, options: Object.assign({}, this.options, MASK_OPTIONS), args });
+    }
+
+    onTestPlanFinished(testResults, testPlanName, duration, executionId, isAnonymous) {
+        const passed = Object.keys(testResults).filter(resultId => testResults[resultId].status === constants.runnerTestStatus.PASSED).length;
+        const failed = Object.keys(testResults).length - passed;
+
+        logger.info('Test Plan Finished', { isAnonymous, passed, failed, testPlanName, options: Object.assign({}, this.options, MASK_OPTIONS), duration, executionId });
+    }
+}
 
 function stripTokenFromConsoleArguments(args) {
     let indexOfTokenFlag = args.indexOf('--token');
@@ -57,24 +72,11 @@ function stripTokenFromConsoleArguments(args) {
 
             return newArgs;
         } catch (e) {
-
+            /* empty */
         }
     }
 
     return args;
 }
 
-DebugReporter.prototype.onTestPlanStarted = function (beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName) {
-    const args = stripTokenFromConsoleArguments(process.argv);
-
-    logger.info('Test Plan Started', { executionId, testPlanName, isAnonymous, configName, options: Object.assign({}, this.options, MASK_OPTIONS), args });
-};
-
-DebugReporter.prototype.onTestPlanFinished = function (testResults, testPlanName, duration, executionId, isAnonymous) {
-    const passed = Object.keys(testResults).filter(resultId => testResults[resultId].status === constants.runnerTestStatus.PASSED).length;
-    const failed = Object.keys(testResults).length - passed;
-
-    logger.info('Test Plan Finished', { isAnonymous, passed, failed, testPlanName, options: Object.assign({}, this.options, MASK_OPTIONS), duration, executionId });
-};
-
 module.exports = DebugReporter;

package/reports/jsonReporter.js

@@ -1,52 +1,55 @@
-var JsonReporter = function (options) {
-    this.options = options;
-};
-
-JsonReporter.prototype.onTestStarted = function(test, workerId) {
-    var event = {
-        name: "testStarted",
-        data: {
-            test: test,
-            workerId: workerId
-        }
-    };
-
-    console.log(JSON.stringify(event));
-};
-
-JsonReporter.prototype.onTestFinished = function(test, workerId) {
-    var event = {
-        name: "testFinished",
-        data: {
-            test: test,
-            workerId: workerId
-        }
-    };
-
-    console.log(JSON.stringify(event));
-};
-
-JsonReporter.prototype.onTestPlanStarted = function(beforeTests, tests, afterTests, testPlanName, executionId) {
-    const event = {
-        name: "suiteStarted",
-        data: {
-            projectId: this.options.project,
-            executionId: executionId
-        }
-    };
-
-    console.log(JSON.stringify(event));
-};
-
-JsonReporter.prototype.onTestPlanFinished = function(testResults) {
-    var event = {
-        name: "suiteFinished",
-        data: {
-            testResults: testResults
-        }
-    };
-
-    console.log(JSON.stringify(event));
-};
+/* eslint-disable no-console */
+class JsonReporter {
+    constructor(options) {
+        this.options = options;
+    }
+
+    onTestStarted(test, workerId) {
+        const event = {
+            name: 'testStarted',
+            data: {
+                test,
+                workerId,
+            },
+        };
+
+        console.log(JSON.stringify(event));
+    }
+
+    onTestFinished(test, workerId) {
+        const event = {
+            name: 'testFinished',
+            data: {
+                test,
+                workerId,
+            },
+        };
+
+        console.log(JSON.stringify(event));
+    }
+
+    onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId) {
+        const event = {
+            name: 'suiteStarted',
+            data: {
+                projectId: this.options.project,
+                executionId,
+            },
+        };
+
+        console.log(JSON.stringify(event));
+    }
+
+    onTestPlanFinished(testResults) {
+        const event = {
+            name: 'suiteFinished',
+            data: {
+                testResults,
+            },
+        };
+
+        console.log(JSON.stringify(event));
+    }
+}
 
 module.exports = JsonReporter;

package/reports/junitReporter.js

@@ -5,11 +5,10 @@
 const xml2js = require('xml2js');
 const Promise = require('bluebird');
 const fs = Promise.promisifyAll(require('fs'));
-const utils = require('../utils.js');
+const utils = require('../utils');
 const {
     isAbortedTest, isSkippedTest, getFailedTests, isFailedTest, getFailureEvaluatingCount, getSkippedCount, getAbortedTests,
 } = require('./reporterUtils');
-const featureFlags = require('../commons/featureFlags.js');
 const featureAvailabilityService = require('../commons/featureAvailabilityService');
 
 class JunitReporter {

package/reports/reporter.js

@@ -3,53 +3,155 @@
 const logger = require('../commons/logger').getLogger('reporter');
 const Promise = require('bluebird');
 
-const Reporter = function Reporter() {};
+class Reporter {
+    setOptions(options, branchToUse) {
+        this.reporters = [];
+        const optReporters = options.reporters;
 
-Reporter.prototype.setOptions = function (options, branchToUse) {
-    this.reporters = [];
-    const optReporters = options.reporters;
+        const DebugReporter = require('./debugReporter');
+        this.reporters.push(new DebugReporter(options));
 
-    const DebugReporter = require('./debugReporter');
-    this.reporters.push(new DebugReporter(options));
-
-    if (optReporters === undefined || optReporters.length === 0) {
-        const ConsoleReporter = require('./consoleReporter');
-        this.reporters.push(new ConsoleReporter(options, branchToUse));
-        if (options !== undefined && options.reportFile !== undefined) {
-            const JunitReporter = require('./junitReporter');
-            this.reporters.push(new JunitReporter(options, branchToUse));
-        }
-    } else {
-        if (optReporters.indexOf('teamcity') > -1) {
-            const TeamCityReporter = require('./teamCityReporter');
-            this.reporters.push(new TeamCityReporter(options));
-        }
-
-        if (optReporters.indexOf('console') > -1) {
+        if (optReporters === undefined || optReporters.length === 0) {
             const ConsoleReporter = require('./consoleReporter');
             this.reporters.push(new ConsoleReporter(options, branchToUse));
-        }
+            if (options?.reportFile !== undefined) {
+                const JunitReporter = require('./junitReporter');
+                this.reporters.push(new JunitReporter(options, branchToUse));
+            }
+        } else {
+            if (optReporters.includes('teamcity')) {
+                const TeamCityReporter = require('./teamCityReporter');
+                this.reporters.push(new TeamCityReporter(options));
+            }
+
+            if (optReporters.includes('console')) {
+                const ConsoleReporter = require('./consoleReporter');
+                this.reporters.push(new ConsoleReporter(options, branchToUse));
+            }
+
+            if (optReporters.includes('junit')) {
+                const JunitReporter = require('./junitReporter');
+                this.reporters.push(new JunitReporter(options, branchToUse));
+            }
+
+            if (optReporters.includes('json')) {
+                const JsonReporter = require('./jsonReporter');
+                this.reporters.push(new JsonReporter(options));
+            }
 
-        if (optReporters.indexOf('junit') > -1) {
-            const JunitReporter = require('./junitReporter');
-            this.reporters.push(new JunitReporter(options, branchToUse));
+            if (optReporters.includes('chrome')) {
+                const { ChromeReporter } = require('./chromeReporter');
+                this.reporters.push(new ChromeReporter(options, branchToUse));
+            }
         }
+    }
 
-        if (optReporters.indexOf('json') > -1) {
-            const JsonReporter = require('./jsonReporter');
-            this.reporters.push(new JsonReporter(options));
+    onTestPlanFinished(testResults, testPlanName, startTime, executionId, isAnonymous, isCodeMode, childTestResults) {
+        let results = {};
+
+        // TODO: remove mutation of testResults from the Reporter
+        if (childTestResults) {
+            const childValues = Object.values(childTestResults);
+            if (childValues.length > 0) {
+                for (const child of Object.values(childTestResults)) {
+                    results[child.id] = child;
+                }
+                for (const parent of Object.keys(testResults)) {
+                    if (!childValues.some(c => c.parentResultId !== parent)) {
+                        results[parent] = testResults[parent];
+                    }
+                }
+            } else {
+                logger.warn('childTestResults is not array');
+                results = testResults;
+            }
+        } else {
+            results = testResults;
         }
 
-        if (optReporters.indexOf('chrome') > -1) {
-            const { ChromeReporter } = require('./chromeReporter');
-            this.reporters.push(new ChromeReporter(options, branchToUse));
+        return Promise.each(this.reporters, reporter => {
+            if (reporter?.onTestPlanFinished) {
+                const duration = Date.now() - (startTime || 0);
+                return 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 => {
+            if (reporter?.onTestPlanStarted) {
+                return reporter.onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
+            }
+            return undefined;
+        });
+    }
+
+    onGetSlot(workerId, browser) {
+        return Promise.each(this.reporters, reporter => {
+            if (reporter?.onGetSlot) {
+                return reporter.onGetSlot(workerId, browser);
+            }
+            return undefined;
+        });
+    }
+
+    onGetSession(workerId, testName, mode) {
+        return Promise.each(this.reporters, reporter => {
+            if (reporter?.onGetSession) {
+                return reporter.onGetSession(workerId, testName, mode);
+            }
+            return undefined;
+        });
+    }
+
+    onWaitToTestComplete(workerId, isCodeMode, debuggerAddress) {
+        return Promise.each(this.reporters, reporter => {
+            if (reporter?.onWaitToTestComplete) {
+                return reporter.onWaitToTestComplete(workerId, isCodeMode, debuggerAddress);
+            }
+            return undefined;
+        });
+    }
+
+    onWaitToTestStart(workerId) {
+        return Promise.each(this.reporters, reporter => {
+            if (reporter?.onWaitToTestStart) {
+                return reporter.onWaitToTestStart(workerId);
+            }
+            return undefined;
+        });
+    }
+
+    onAllTestPlansFinished(testPlanResults) {
+        // TODO: remove mutation of testPlanResults from the Reporter
+        for (const result of testPlanResults) {
+            if (result.childTestResults) {
+                result.results = {};
+                const childValues = Object.values(result.childTestResults);
+                for (const child of childValues) {
+                    result.results[child.id] = child;
+                }
+                for (const parent of Object.keys(testPlanResults)) {
+                    if (!childValues.some(c => c.parentResultId !== parent)) {
+                        result.results[parent] = testPlanResults[parent];
+                    }
+                }
+            }
         }
+
+        return Promise.each(this.reporters, reporter => {
+            if (reporter?.onAllTestPlansFinished) {
+                return reporter.onAllTestPlansFinished(testPlanResults);
+            }
+            return undefined;
+        });
     }
-};
+}
 
 function addHook(name) {
     Reporter.prototype[name] = function (...args) {
-        return Promise.filter(this.reporters, reporter => reporter && reporter[name]).each(reporter => reporter[name](...args));
+        return Promise.filter(this.reporters, reporter => reporter?.[name]).each(reporter => reporter[name](...args));
     };
 }
 
@@ -66,107 +168,4 @@ addHook('onTestIgnored');
 addHook('onWaitToTestStart');
 addHook('onWaitToTestComplete');
 
-Reporter.prototype.onTestPlanFinished = function (testResults, testPlanName, startTime, executionId, isAnonymous, isCodeMode, childTestResults) {
-    let results = {};
-
-    // TODO: remove mutation of testResults from the Reporter
-    if (childTestResults) {
-        const childValues = Object.values(childTestResults);
-        if (childValues.length > 0) {
-            for (const child of Object.values(childTestResults)) {
-                results[child.id] = child;
-            }
-            for (const parent of Object.keys(testResults)) {
-                if (!childValues.some(c => c.parentResultId !== parent)) {
-                    results[parent] = testResults[parent];
-                }
-            }
-        } else {
-            logger.warn('childTestResults is not array');
-            results = testResults;
-        }
-    } else {
-        results = testResults;
-    }
-
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onTestPlanFinished) {
-            const duration = Date.now() - (startTime || 0);
-            return reporter.onTestPlanFinished(results, testPlanName, duration, executionId, isAnonymous, isCodeMode);
-        }
-        return undefined;
-    });
-};
-
-Reporter.prototype.onTestPlanStarted = function (beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode) {
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onTestPlanStarted) {
-            return reporter.onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
-        }
-        return undefined;
-    });
-};
-
-Reporter.prototype.onGetSlot = function (workerId, browser) {
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onGetSlot) {
-            return reporter.onGetSlot(workerId, browser);
-        }
-        return undefined;
-    });
-};
-
-Reporter.prototype.onGetSession = function (workerId, testName, mode) {
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onGetSession) {
-            return reporter.onGetSession(workerId, testName, mode);
-        }
-        return undefined;
-    });
-};
-
-Reporter.prototype.onWaitToTestComplete = function (workerId, isCodeMode, debuggerAddress) {
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onWaitToTestComplete) {
-            return reporter.onWaitToTestComplete(workerId, isCodeMode, debuggerAddress);
-        }
-        return undefined;
-    });
-};
-
-Reporter.prototype.onWaitToTestStart = function (workerId) {
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onWaitToTestStart) {
-            return reporter.onWaitToTestStart(workerId);
-        }
-        return undefined;
-    });
-};
-
-Reporter.prototype.onAllTestPlansFinished = function (testPlanResults) {
-    // TODO: remove mutation of testPlanResults from the Reporter
-    for (const result of testPlanResults) {
-        if (result.childTestResults) {
-            result.results = {};
-            const childValues = Object.values(result.childTestResults);
-            for (const child of childValues) {
-                result.results[child.id] = child;
-            }
-            for (const parent of Object.keys(testPlanResults)) {
-                if (!childValues.some(c => c.parentResultId !== parent)) {
-                    result.results[parent] = testPlanResults[parent];
-                }
-            }
-        }
-    }
-
-    return Promise.each(this.reporters, reporter => {
-        if (reporter && reporter.onAllTestPlansFinished) {
-            return reporter.onAllTestPlansFinished(testPlanResults);
-        }
-        return undefined;
-    });
-};
-
-
 module.exports = new Reporter();

package/runOptions.js

@@ -183,12 +183,12 @@ program
     .option('-h, --headless [headless]', 'run in headless mode')
     .option('-m, --mode [runner-mode]', 'use extension or selenium mode (extension/selenium/appium)')
     .option('--branch [branch]', 'branch name', null)
-    .option('--base-url [base-url]', 'change al test base-url to a specified url')
+    .option('--base-url [base-url]', 'change base-url to a specified url for all tests in current execution')
     .option('--token [token]', 'identification token to testim')
     .option('--is-regression-baseline-run', 'save doms and run results as regression baseline data')
-    .option('--parallel [number-of-tests]', 'number of tests to run on parallel')
-    .option('--before-parallel [number-of-tests]', 'number of tests to run on parallel in the before phase of a test plan')
-    .option('--after-parallel [number-of-tests]', 'number of tests to run on parallel in the after phase of a test plan')
+    .option('--parallel [number-of-tests]', 'number of tests to run in parallel')
+    .option('--before-parallel [number-of-tests]', 'number of tests to run in parallel during the before phase of a test plan')
+    .option('--after-parallel [number-of-tests]', 'number of tests to run in parallel during the after phase of a test plan')
     .option('--canary [canary-mode]', 'enable canary mode', false)
     .option('--test-plan [test-plan-name]', 'test plan to run', collect, [])
     .option('--test-plan-id [test-plan-id]', 'test plan to run', collect, [])
@@ -203,7 +203,7 @@ program
     .option('--proxy-for-grid [proxy-for-grid]', 'used together with --proxy to also router grid traffic through a proxy')
     .option('--result-label [result-label]', 'result label', collect, [])
     .option('-oen --override-execution-name [execution-name]', 'override the default execution name', '')
-    .option('--retries [max_num_of_retries]', 'number of retires failure test defaults to not retrying', 0)
+    .option('--retries [max_num_of_retries]', 'number of retries on test failure, defaults to 0 (no retries)', 0)
     .option('--set-retention [retention-in-days]', 'set the number of days for results retention')
     .option('--user [user-id]', 'user ID for local Testim-CLI')
     .option('--pass-zero-tests', 'don\'t fail the run if no tests were found')
@@ -347,7 +347,7 @@ program
     .option('--use-prefeched-data [location]', 'use prefetched data from local cache file, and force using only cached data')
     .option('--save-rca-locally [path]', 'save root cause analysis assets locally')
 
-    .option('--exit-code-ignore-failing-tests', 'dont return non zero exit code when tests fail. non zero exit code will mean a real error occurred')
+    .option('--exit-code-ignore-failing-tests', 'return exit code of zero when tests fail. non zero exit code will mean a real error occurred')
 
     .option('--intersect-with-label [label]', 'Out of the execution\'s test list, run only those tests that have the specified label', collect, [])
     .option('--intersect-with-suite [suiteName]', 'Out of the execution\'s test list, run only those tests that are included in the specified suite (by suite name)', collect, [])
@@ -495,6 +495,7 @@ module.exports = {
             // non-proxy case
             global.SuperagentProxy = require('superagent-proxy');
             global.ProxyAgent = require('proxy-agent');
+            global.HttpsProxyAgent = require('https-proxy-agent');
         }
 
         if (program.proxyForGrid && !program.proxy) {
@@ -833,7 +834,7 @@ module.exports = {
             throw new ArgError('after-parallel could not be a negative number or not number, --after-parallel <number-of-tests>');
         }
 
-        if (![CLI_MODE.EXTENSION, CLI_MODE.SELENIUM].includes(program.mode)) {
+        if (![CLI_MODE.EXTENSION, CLI_MODE.SELENIUM, CLI_MODE.APPIUM].includes(program.mode)) {
             throw new ArgError(`runner mode <${program.mode}> is not supported`);
         }
 

package/runner.js

@@ -118,6 +118,14 @@ function setBranch(options, branchInfoFromServer) {
     }
 }
 
+async function setSfdcCredential(options) {
+    const { projectData: { projectId } } = options;
+    const branch = branchService.getCurrentBranch();
+    if (_.get(options, 'company.activePlan.premiumFeatures.ttaForSalesforce')) {
+        options.sfdcCredential = await servicesApi.loadSfdcCredential({ projectId, branch });
+    }
+}
+
 function setCompany(options, company) {
     const { onprem, id, storageBaseUrl, storageType, name, activePlan = {} } = company;
     if (onprem) {
@@ -194,6 +202,10 @@ async function setMockNetworkRules(options) {
     }
 }
 
+/**
+ * @param {Awaited<ReturnType<typeof import('./runOptions')['process']>>} options
+ * @param {string=} customExtensionLocalLocation
+ */
 async function runRunner(options, customExtensionLocalLocation) {
     perf.log('in runner.js runRunner');
 
@@ -265,6 +277,7 @@ async function init(options) {
     setBranch(options, branchName);
     setAllGrids(options, allGrids);
     setAuthData(options, authData);
+    await setSfdcCredential(options);
 
     if (!(options.lightweightMode && options.lightweightMode.disableLabs)) {
         await labFeaturesService.loadLabFeatures(projectById.id, companyByProjectId.activePlan);

package/runners/ParallelWorkerManager.js

@@ -23,6 +23,8 @@ class ParallelWorkerManager {
         switch (mode) {
             case CLI_MODE.SELENIUM:
                 return require('../workers/WorkerSelenium');
+            case CLI_MODE.APPIUM:
+                return require('../workers/WorkerAppium');
             default:
                 if (labFeaturesService.isFeatureAvailableForProject('useSameBrowserForMultiTests')) {
                     return require('../workers/WorkerExtensionSingleBrowser');