@testim/testim-cli 3.254.0 → 3.256.0

package/player/webdriver.js

@@ -1,9 +1,9 @@
-/* eslint-disable no-var */
+/* eslint-disable arrow-body-style, no-shadow, @typescript-eslint/prefer-optional-chain, comma-spacing, no-empty, padded-blocks, semi, indent, unicorn/no-useless-promise-resolve-reject, default-param-last, comma-dangle, semi-style, consistent-return, radix, prefer-template, prefer-const, object-shorthand, no-trailing-spaces, operator-linebreak, no-else-return, unicorn/prefer-includes, prefer-arrow-callback, max-len, no-var */
 
 'use strict';
 
+const _ = require('lodash');
 const logger = require('../commons/logger').getLogger('webdriver');
-const Promise = require('bluebird');
 const parser = require('ua-parser-js');
 const desiredCapabilitiesBuilder = require('../commons/testimDesiredCapabilitiesBuilder');
 const { SeleniumError, SeleniumCrashError, IeError } = require('../errors');
@@ -13,7 +13,7 @@ const doubleClick = require('./stepActions/scripts/doubleClick');
 const dispatchFocus = require('./stepActions/scripts/focusElement');
 const { isOldProtocol } = require('./webDriverUtils');
 const featureFlags = require('../commons/featureFlags');
-const _ = require('lodash');
+const { W3C_ELEMENT_ID } = require('./constants');
 
 const [LEFT, RIGHT] = [0, 2];
 const { extractElementId, getCdpAddressForHost } = utils;
@@ -202,7 +202,8 @@ class WebDriver extends WebDriverApi {
     switchToLocatedFrame(locatedElement) {
         return this.getElement(locatedElement)
             .then(async el => {
-                await this.switchToFrame(el.value);
+                const elementId = extractElementId(el.value);
+                await this.switchToFrame({ ELEMENT: elementId, [W3C_ELEMENT_ID]: elementId });
                 return el;
             });
     }
@@ -213,7 +214,7 @@ class WebDriver extends WebDriverApi {
 
     switchToTopFrame() {
         return this.frame().catch(err => {
-            if (err.message && err.message.includes('ECONNREFUSED')) {
+            if (err.message?.includes('ECONNREFUSED')) {
                 throw new SeleniumCrashError();
             }
             throw err;
@@ -221,11 +222,11 @@ class WebDriver extends WebDriverApi {
     }
 
     /**
-     * @returns {Promise<{ value: HTMLElement }>}
+     * @returns {Promise<{ value: HTMLElement | { [W3C_ELEMENT_ID]: string } | { ELEMENT: string } }>}
     */
     getElement(locatedElement) {
         const perfId = this.seleniumPerfStats.markStart(SELENIUM_PERF_MARKS.GET_ELEMENT);
-        if (typeof locatedElement === 'string' || typeof locatedElement === 'number') { // support testimId in the meanwhile for backwards compatability
+        if (typeof locatedElement === 'string' || typeof locatedElement === 'number') { // support testimId in the meanwhile for backwards compatibility
             return this.getElementBySelector(`[testim_dom_element_id='${locatedElement}']`)
                 .finally(() => this.seleniumPerfStats.markEnd(perfId, SELENIUM_PERF_MARKS.GET_ELEMENT));
         }
@@ -452,10 +453,10 @@ class WebDriver extends WebDriverApi {
                     throw testimInternalError;
                 }
                 return this.executeJS('return navigator.userAgent;')
-                    .catch(() => Promise.reject(testimInternalError))
+                    .catch(() => { throw testimInternalError; })
                     .then(ua => {
                         const error = this.isUsingUnsupportedCompabilityMode(ua.value) ? this.getIeError('Can’t run test in IE compatibility mode') : testimInternalError;
-                        return Promise.reject(error);
+                        throw error;
                     });
             });
     }
@@ -586,7 +587,7 @@ class WebDriver extends WebDriverApi {
                 userAgent: rawUserAgent,
                 browserVersion: parse.browser.version
             };
-            return Promise.resolve(this.browserAndOS);
+            return this.browserAndOS;
         });
     }
 
@@ -690,7 +691,7 @@ class WebDriver extends WebDriverApi {
                     this.unsupportedActions.move = true;
                     return this.rightClickWithActionsAPI(element, offsets);
                 }
-                return Promise.reject(err);
+                throw err;
             });
     }
 
@@ -704,7 +705,7 @@ class WebDriver extends WebDriverApi {
                     this.unsupportedActions.move = true;
                     return this.leftClickWithActionsAPI(element, offsets);
                 }
-                return Promise.reject(err);
+                throw err;
             });
     }
 
@@ -826,7 +827,7 @@ class WebDriver extends WebDriverApi {
                             this.unsupportedActions.move = true;
                             return this.dragWithActionsAPI(seleniumElement, xDiff, yDiff, midXRelative, midYRelative);
                         }
-                        return Promise.reject(err);
+                        throw err;
                     });
             });
     }
@@ -857,15 +858,17 @@ class WebDriver extends WebDriverApi {
         }, [{ x: Math.round(startLeft), y: Math.round(startTop) }]);
     }
 
-    dragAndDropWithGeneratedMoves(sourceSeleniumElement, destinationSeleniumElement, rectsAndOffsets) {
+    async dragAndDropWithGeneratedMoves(sourceSeleniumElement, destinationSeleniumElement, rectsAndOffsets) {
         const { fromRect, fromX, fromY, toRect, toX, toY } = rectsAndOffsets;
         const moveSequence = this.getMoveRelativeSequence(fromRect.left + fromX, fromRect.top + fromY, toRect.left + toX, toRect.top + toY);
 
-        return this.moveTo(extractElementId(sourceSeleniumElement), Math.round(fromX), Math.round(fromY))
-            .then(() => this.buttonDown())
-            .then(() => Promise.each(moveSequence, movePosition => this.moveTo(null, movePosition.x, movePosition.y)))
-            .then(() => this.moveTo(extractElementId(destinationSeleniumElement), Math.round(toX), Math.round(toY)))
-            .then(() => this.buttonUp());
+        await this.moveTo(extractElementId(sourceSeleniumElement), Math.round(fromX), Math.round(fromY));
+        await this.buttonDown();
+        for (const movePosition of moveSequence) {
+            await this.moveTo(null, movePosition.x, movePosition.y);
+        }
+        await this.moveTo(extractElementId(destinationSeleniumElement), Math.round(toX), Math.round(toY));
+        return await this.buttonUp();
     }
 
     dragAndDropWithActionsAPIWithGeneratedMoves(rectsAndOffsets) {
@@ -900,7 +903,7 @@ class WebDriver extends WebDriverApi {
                         this.unsupportedActions.move = true;
                         return this.dragAndDropWithActionsAPIWithGeneratedMoves(rectsAndOffsets);
                     }
-                    return Promise.reject(err);
+                    throw err;
                 });
         }
         if (this.unsupportedActions.move) {
@@ -912,7 +915,7 @@ class WebDriver extends WebDriverApi {
                     this.unsupportedActions.move = true;
                     return this.dragAndDropWithActionsAPI(rectsAndOffsets);
                 }
-                return Promise.reject(err);
+                throw err;
             });
     }
 
@@ -934,7 +937,7 @@ class WebDriver extends WebDriverApi {
                     this.unsupportedActions.move = true;
                     return this.doubleClickFallback(element, eventData, offsets);
                 }
-                return Promise.reject(err);
+                throw err;
             });
     }
 

package/processHandler.js

@@ -7,6 +7,10 @@ const logger = require('./commons/logger').getLogger('process-handler');
 
 const exitHooks = [];
 
+/**
+ * @param {(e: any) => void} onExit
+ * @param {NodeJS.Process=} _process
+ */
 module.exports = function (onExit, _process = process) {
     async function cleanup(err) {
         // give cleanup and socket reports a chance to run

package/reports/junitReporter.js

@@ -3,8 +3,7 @@
 'use strict';
 
 const xml2js = require('xml2js');
-const Promise = require('bluebird');
-const fs = Promise.promisifyAll(require('fs'));
+const fsPromises = require('fs/promises');
 const utils = require('../utils');
 const {
     isAbortedTest, isSkippedTest, getFailedTests, isFailedTest, getFailureEvaluatingCount, getSkippedCount, getAbortedTests,
@@ -34,7 +33,7 @@ class JunitReporter {
             return undefined;
         }
         try {
-            await fs.writeFileAsync(reportFile, reportText);
+            await fsPromises.writeFile(reportFile, reportText);
             console.log('JUnit XML file saved to', reportFile);
             return testResults;
         } catch (err) {
@@ -55,7 +54,7 @@ function getPrintName(testResult) {
 }
 
 async function report(editorUrl, testPlanResults, projectId, branch, classname, options) {
-    function createTestCaseObject(testResult, projectId) {
+    function createTestCaseObject(testResult) {
         const testResultUrl = utils.getTestUrl(editorUrl, projectId, testResult.testId, testResult.resultId, branch);
         const testResultObject = {
             $: {
@@ -102,7 +101,7 @@ async function report(editorUrl, testPlanResults, projectId, branch, classname,
         }
         return {
             $: testSuiteAttributes,
-            testcase: Object.keys(testResults).map(resultId => createTestCaseObject(testResults[resultId], projectId)),
+            testcase: Object.keys(testResults).map(resultId => createTestCaseObject(testResults[resultId])),
         };
     }
 
@@ -130,9 +129,9 @@ async function report(editorUrl, testPlanResults, projectId, branch, classname,
     try {
         const builder = new xml2js.Builder();
         const jUnitXmlReporter = builder.buildObject(testResultObject);
-        return Promise.resolve(jUnitXmlReporter);
+        return jUnitXmlReporter;
     } catch (err) {
-        return Promise.resolve(createErrorjUnitReporter(err));
+        return createErrorjUnitReporter(err);
     }
 }
 

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,286 @@
+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;
+}
+
+type InitUserWithAuth = Awaited<ReturnType<typeof import('./commons/testimServicesApi')['initializeUserWithAuth']>>;
+interface ProjectData extends Pick<InitUserWithAuth['projectById'], 'type' | 'name' | 'defaults'> {
+    projectId: string;
+}
+
+// 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 Data set based on values from server
+    company: {
+        companyId: string;
+        onprem: boolean;
+        storageBaseUrl: string;
+        storageType: string;
+        name: string;
+        planType: 'pro' | 'free' | 'trial';
+        isPOC: boolean;
+        isStartUp: boolean;
+        activePlan: import('services/src/commons/mongo/db-dto-definitions/DbCompanyProjects').Plan;
+    };
+    gridData?: Awaited<ReturnType<typeof import('./services/gridService')['getGridData']>>;
+    sfdcCredential?: string;
+    editorUrl?: string;
+    allGrids?: InitUserWithAuth['allGrids'];
+    authData?: InitUserWithAuth['authData'];
+    projectData?: ProjectData;
+    // #endregion
+
+    // #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;
+    localRCASaver?: string;
+    // #endregion
+
+    // #region intersections
+    intersections: { labels?: string[]; suiteNames?: string[]; suiteIds?: string[] };
+    // #endregion
+}
+
+type Options = |
+    LoginModeOptions |
+    InitModeOptions |
+    AgentModeOptions |
+    TunnelOptions |
+    RunnerOptions;
+
+export function process(): Promise<Options>;