@testim/testim-cli 3.251.0 → 3.253.0

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/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

@@ -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/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');