@testim/testim-cli 3.261.0 → 3.262.0

package/workers/WorkerExtension.js

@@ -1,17 +1,19 @@
 'use strict';
 
-const Promise = require('bluebird');
-
-const { timeoutMessages, stepResult } = require('../commons/constants');
 const BaseWorker = require('./BaseWorker');
-const logger = require('../commons/logger').getLogger('worker-ext');
+const reporter = require('../reports/reporter');
 const perf = require('../commons/performance-logger');
 const ExtensionTestPlayer = require('../player/extensionTestPlayer');
 const ChromeLauncherTestPlayer = require('../player/chromeLauncherTestPlayer');
-const reporter = require('../reports/reporter');
+const { TimeoutError } = require('../errors');
+const { promiseTimeout } = require('../utils');
+const { getLogger } = require('../commons/logger');
+const { timeoutMessages, stepResult } = require('../commons/constants');
 
+const logger = getLogger('worker-ext');
 
 class WorkerExtension extends BaseWorker {
+    /** @override */
     initPlayer() {
         if (this.options.useChromeLauncher) {
             return new ChromeLauncherTestPlayer(this.id);
@@ -31,7 +33,7 @@ class WorkerExtension extends BaseWorker {
                 this.executionId,
                 this.testResultId,
                 testRunHandler.seleniumPerfStats,
-                this.options.lightweightMode && this.options.lightweightMode.general,
+                this.options.lightweightMode?.general,
                 this.lambdatestService
             );
         } catch (err) {
@@ -45,115 +47,139 @@ class WorkerExtension extends BaseWorker {
         }
     }
 
+    /** @override */
     async getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
         reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
         return this._getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo);
     }
 
-    runTestOnce(testRunHandler, player) {
+    /**
+     * @override
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {import('../player/extensionTestPlayer') | import('../player/chromeLauncherTestPlayer')} player
+     */
+    async runTestOnce(testRunHandler, player) {
         const { driver } = player;
         const { testResultId, executionId, testId } = this;
         perf.log('WorkerExtension runTestOnce');
 
-        const runExtTest = (testRunHandler) => {
+        const runViaCdpOrFallbackToAPI = async () => {
+            const testTimeout = this.options.timeoutWasGiven ? Math.max(10000, this.options.timeout) : this.options.testStartTimeout;
+            try {
+                return await promiseTimeout(testRunHandler.runTestUsingCDP(driver.cdpTestRunner), testTimeout, timeoutMessages.TEST_START_TIMEOUT_MSG);
+            } catch (err) {
+                if (!(err instanceof TimeoutError)) {
+                    throw err;
+                }
+                logger.warn('timeout while running test using CDP. Running checkViaRestAPIIfTestStarted', { testResultId });
+                return await testRunHandler.checkViaRestAPIIfTestStarted();
+            }
+        };
+        const navigateChromeSessionToRunTestim = async (url, startStatusDetails) => {
+            try {
+                const res = await driver.url(url);
+                startStatusDetails.driverUrlFinished = true;
+                return res;
+            } catch (err) {
+                logger.error('error from driver.url', { err, testResultId, executionId, testId, url, urlLength: url.length });
+                throw err;
+            }
+        };
+        const updateRunHandlerThatTestStartedAndChangeStatusDetails = async (startStatusDetails) => {
+            const res = await testRunHandler.onStarted(this.options.testStartTimeout);
+            startStatusDetails.testRunHandlerOnStartedHadFinished = true;
+            return res;
+        };
+
+        const runExtTest = async () => {
             perf.log('WorkerExtension runExtTest');
-            const disableRemoteStep = (this.options.lightweightMode && this.options.lightweightMode.disableRemoteStep) || this.options.disableSockets;
+            const disableRemoteStep = this.options.lightweightMode?.disableRemoteStep || this.options.disableSockets;
             if (!disableRemoteStep) {
                 testRunHandler.listenToRemoteStep(driver);
             }
             if (this.options.useChromeLauncher) {
-                const testTimeout = this.options.timeoutWasGiven ?
-                    Math.max(10000, this.options.timeout) :
-                    this.options.testStartTimeout;
-
                 reporter.onWaitToTestStart(this.id);
                 reporter.onWaitToTestComplete(this.id, this.isCodeMode);
-                return Promise.resolve(testRunHandler.runTestUsingCDP(driver.cdpTestRunner))
-                    .timeout(testTimeout, timeoutMessages.TEST_START_TIMEOUT_MSG)
-                    .catch(Promise.TimeoutError, () => {
-                        logger.warn('timeout while running test using CDP. Running checkViaRestAPIIfTestStarted', { testResultId });
-                        return testRunHandler.checkViaRestAPIIfTestStarted();
-                    })
-                    .then(testResult => ({ ...testResult, ...testRunHandler.seleniumPerfStats.getStats() }))
-                    .catch(err => {
-                        logger.warn('failed to run test via CDP', { err });
-                        throw err;
-                    });
+                try {
+                    const testResult = await runViaCdpOrFallbackToAPI();
+                    return { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
+                } catch (err) {
+                    logger.warn('failed to run test via CDP', { err });
+                    throw err;
+                }
             }
 
             const startStatusDetails = { driverUrlFinished: false, testRunHandlerOnStartedHadFinished: false }; //for logging / debugging purposes
-            return new Promise((resolve, reject) => testRunHandler.getRunTestUrl()
-                .then(url => {
-                    reporter.onWaitToTestStart(this.id);
-                    return Promise.all([
-                        driver.url(url).tap(() => { startStatusDetails.driverUrlFinished = true; }).catch(err => {
-                            logger.error('error from driver.url', { err, testResultId, executionId, testId, url, urlLength: url.length });
-                            throw err;
-                        }),
-                        testRunHandler.onStarted(this.options.testStartTimeout).tap(() => { startStatusDetails.testRunHandlerOnStartedHadFinished = true; }),
-                    ])
-                        .timeout(this.options.testStartTimeout, timeoutMessages.TEST_START_TIMEOUT_MSG)
-                        .catch(Promise.TimeoutError, () => {
-                            logger.warn('timeout occurred (see log\'s payload). Running checkViaRestAPIIfTestStarted', { testResultId, executionId, testId, ...startStatusDetails });
-                            return testRunHandler.checkViaRestAPIIfTestStarted();
-                        });
-                })
-                .then(() => {
-                    reporter.onWaitToTestComplete(this.id, this.isCodeMode);
-                    const onBrowserClosed = (err) => {
-                        testRunHandler.onCompletedCleanup();
-                        logger.warn('on browser closed error detected', { err, testResultId, executionId, testId });
-                        driver.unregisterToClosedBrowser(onBrowserClosed);
-                        err.type = stepResult.BROWSER_CLOSED;
-                        reject(err);
-                    };
-                    driver.registerToClosedBrowser(onBrowserClosed);
-                    return testRunHandler.onCompleted().timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
-                        .then(async testResult => {
-                            driver.unregisterToClosedBrowser(onBrowserClosed);
-                            if (this.lambdatestService.isLambdatestRun()) {
-                                await driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => { });
-                            }
-                            if (!driver.isAlive()) {
-                                logger.warn(`possible grid unresponsive for test ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
-                                testResult.gridIssues = 'could not validate grid is alive';
-                            }
-                            const maxKeepAliveGap = driver.maxKeepAliveGap();
-                            const MAX_KEEP_ALIVE_GAP = 30000;
-                            if (maxKeepAliveGap >= MAX_KEEP_ALIVE_GAP) {
-                                logger.warn(`possible browser keep alive issue ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
-                                testResult.keepAliveIssue = maxKeepAliveGap;
-                            }
-                            resolve({ ...testResult, ...testRunHandler.seleniumPerfStats.getStats() });
-                        })
-                        .catch(err => {
-                            logger.warn('timeout wait until test completed', { err, testResultId, executionId, testId });
-                            // complete time out
-                            reject(new Error(err));
-                        })
-                        .finally(() => {
-                            driver.unregisterToClosedBrowser(onBrowserClosed);
-                        });
-                })
-                .catch(err => {
-                    logger.warn('failed to start url', { err });
-                    reject(new Error(err));
-                }));
+
+            try {
+                const url = await testRunHandler.getRunTestUrl();
+                reporter.onWaitToTestStart(this.id);
+                try {
+                    await promiseTimeout(Promise.all([
+                        navigateChromeSessionToRunTestim(url, startStatusDetails),
+                        updateRunHandlerThatTestStartedAndChangeStatusDetails(startStatusDetails),
+                    ]), this.options.testStartTimeout, timeoutMessages.TEST_START_TIMEOUT_MSG);
+                } catch (err) {
+                    if (!(err instanceof TimeoutError)) {
+                        throw err;
+                    }
+                    logger.warn('timeout occurred (see log\'s payload). Running checkViaRestAPIIfTestStarted', { testResultId, executionId, testId, ...startStatusDetails });
+                    await testRunHandler.checkViaRestAPIIfTestStarted();
+                }
+
+                reporter.onWaitToTestComplete(this.id, this.isCodeMode);
+                const onBrowserClosed = (err) => {
+                    testRunHandler.onCompletedCleanup();
+                    logger.warn('on browser closed error detected', { err, testResultId, executionId, testId });
+                    driver.unregisterToClosedBrowser(onBrowserClosed);
+                    err.type = stepResult.BROWSER_CLOSED;
+                    throw err;
+                };
+                driver.registerToClosedBrowser(onBrowserClosed);
+                try {
+                    const testResult = await promiseTimeout(testRunHandler.onCompleted(), this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG);
+                    driver.unregisterToClosedBrowser(onBrowserClosed);
+                    if (this.lambdatestService.isLambdatestRun()) {
+                        await driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => { });
+                    }
+                    if (!driver.isAlive()) {
+                        logger.warn(`possible grid unresponsive for test ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
+                        testResult.gridIssues = 'could not validate grid is alive';
+                    }
+                    const maxKeepAliveGap = driver.maxKeepAliveGap();
+                    const MAX_KEEP_ALIVE_GAP = 30000;
+                    if (maxKeepAliveGap >= MAX_KEEP_ALIVE_GAP) {
+                        logger.warn(`possible browser keep alive issue ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
+                        testResult.keepAliveIssue = maxKeepAliveGap;
+                    }
+                    return { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
+                } catch (err) {
+                    logger.warn('timeout wait until test completed', { err, testResultId, executionId, testId });
+                    // complete time out
+                    throw new Error(err);
+                } finally {
+                    driver.unregisterToClosedBrowser(onBrowserClosed);
+                }
+            } catch (err) {
+                logger.warn('failed to start url', { err });
+                throw new Error(err);
+            }
         };
 
         driver.start();
 
-        return super.runTestOnce(testRunHandler, player)
-            .log('WorkerExtension super.runTestOnce')
-            .then(() => runExtTest(testRunHandler))
-            .catch(err => {
-                logger.error('failed to run test', {
-                    err,
-                    testId: testRunHandler.getTestId(),
-                    resultId: testRunHandler.getTestResultId(),
-                });
-                return Promise.reject(err);
+        try {
+            await super.runTestOnce(testRunHandler, player);
+            perf.log('WorkerExtension super.runTestOnce');
+            return await runExtTest();
+        } catch (err) {
+            logger.error('failed to run test', {
+                err,
+                testId: testRunHandler.getTestId(),
+                resultId: testRunHandler.getTestResultId(),
             });
+            throw err;
+        }
     }
 }
 

package/workers/WorkerSelenium.js

@@ -80,6 +80,10 @@ class WorkerSelenium extends BaseWorker {
         }
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {import('../player/seleniumTestPlayer')} seleniumTestPlayer
+     */
     async runTestOnce(testRunHandler, seleniumTestPlayer) {
         const { driver, sessionPlayer } = seleniumTestPlayer;
         const version = sessionPlayerInit.manifestVersion || 'runner';
@@ -111,10 +115,11 @@ class WorkerSelenium extends BaseWorker {
                 if (!sessionPlayer.callOrderScheduler) { // old session player
                     await testRunHandler.waitForExecutionStartedFinished();
                 } else {
-                    sessionPlayer.callOrderScheduler.schedule(() =>
+                    sessionPlayer.callOrderScheduler.schedule(
+                        () => testRunHandler.waitForExecutionStartedFinished(),
                         // this key is shared by clickim and this ensures that we do wait for the execution to be created before we do this.
-                        testRunHandler.waitForExecutionStartedFinished(),
-                    { key: `test-result:${this.userData.projectId}:${this.testResultId}` });
+                        { key: `test-result:${this.userData.projectId}:${this.testResultId}` }
+                    );
                 }
                 perf.log('right before playTestByCode');
                 return new Promise((resolve, reject) => sessionPlayer.playTestByCode(