@testim/testim-cli 3.253.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>;