@testim/testim-cli 3.252.0 → 3.254.0

package/workers/WorkerAppium.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const jsdom = require('jsdom');
+const BaseWorker = require('./BaseWorker');
+const logger = require('../commons/logger').getLogger('worker-appium');
+const reporter = require('../reports/reporter');
+const AppiumTestPlayer = require('../player/appiumTestPlayer');
+const sessionPlayerInit = require('../commons/getSessionPlayerRequire');
+const AppiumApi = require('../commons/getSessionPlayerRequire').AppiumApi;
+const desiredCapabilitiesBuilder = require('../commons/testimDesiredCapabilitiesBuilder');
+
+class WorkerAppium extends BaseWorker {
+    constructor(...args) {
+        super(...args);
+        this.getBrowserOnce = Promise.method(this.getBrowserOnce);
+    }
+
+    initPlayer(testRunHandler) {
+        return new AppiumTestPlayer(this.id,
+            testRunHandler.getRunParams(),
+            this.options.shouldMonitorPerformance,
+            testRunHandler.getAutomationMode(),
+            undefined,
+            testRunHandler.getRetryCount(),
+            testRunHandler.getPreviousTestResultId());
+    }
+
+    async getBrowserOnce(testRunHandler, customExtensionLocalLocation, appiumTestPlayer, gridInfo) {
+        reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
+        const { driver } = appiumTestPlayer;
+        const nativeApp = testRunHandler.getNativeAppData();
+        const projectType = this.options.projectData.type;
+        const capabilities = desiredCapabilitiesBuilder.buildAppiumOptions({ projectType, gridInfo, testRunConfig: this.testRunConfig, nativeApp });
+        try {
+            //we assume the application is installed on the device. (all headspin allocated devices)
+            const activeSession = await driver.remote(capabilities);
+            driver.activeSession = activeSession;
+            logger.info(`init new appium session testName: ${this.testName}`, { sessionId: activeSession.sessionId, testResultId: this.testResultId, nativeApp });
+        } catch (err) {
+            //TODO:  catch app status validation
+            logger.error('failed to start application', { err });
+            throw err;
+        }
+    }
+
+    getServerAddressFromGrid(testRunHandler) {
+        const { _options: { gridData: { host, port, accessToken } } } = testRunHandler;
+        return `https://${host}:${port}/v0/${accessToken}/wd/hub`;
+    }
+
+    getDirectAddressConnection(activeSessionCapabilities) {
+        const { directConnectProtocol: protocol, directConnectHost: host, directConnectPort: port, directConnectPath: path } = activeSessionCapabilities;
+        if (protocol && host && port && path) {
+            return `${protocol}://${host}:${port}${path}`;
+        }
+        return undefined;
+    }
+
+    async runTestOnce(testRunHandler, appiumTestPlayer) {
+        const { driver, sessionPlayer } = appiumTestPlayer;
+        const version = sessionPlayerInit.manifestVersion || 'runner';
+
+        reporter.onWaitToTestComplete(this.id, this.isCodeMode);
+
+        sessionPlayer.playbackManager.executionId = testRunHandler.getExecutionId();
+        sessionPlayer.playbackManager.executionName = testRunHandler.getExecutionName();
+
+        const serverAddress = this.getDirectAddressConnection(driver.activeSession.capabilities) || this.getServerAddressFromGrid(testRunHandler);
+        const DOMParser = new (jsdom.JSDOM)('').window.DOMParser;
+        sessionPlayer.playbackManager.appiumApi = new AppiumApi(serverAddress, driver.activeSession.sessionId, DOMParser);
+
+
+        if (sessionPlayerInit.localAssetService) {
+            sessionPlayerInit.localAssetService.initialize({ serverUrl: this.options.localRCASaver });
+        }
+        async function runAppiumTest() {
+            try {
+                const INCOGNITO = false;
+                const testResult = await (new Promise((resolve, reject) =>
+                    // eslint-disable-next-line no-promise-executor-return
+                    sessionPlayer.playByTestId(
+                        this.testId,
+                        this.executionId,
+                        this.testResultId,
+                        this.baseUrl,
+                        this.userData,
+                        version,
+                        resolve,
+                        false,
+                        this.overrideTestConfigId,
+                        this.branch,
+                        INCOGNITO,
+                        testRunHandler.getRemoteRunId(),
+                        undefined,
+                        undefined,
+                        undefined,
+                    )));
+                if (sessionPlayerInit.localAssetService) {
+                    await sessionPlayerInit.localAssetService.drain();
+                }
+                testResult.stepsResults = null;
+                testResult.resultId = this.testResultId;
+                const resultWithStats = { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
+                return resultWithStats;
+            } catch (err) {
+                //TODO: add test timeout and handle Timeout Error TBD
+                // if (err instanceof TimeoutError && sessionPlayer.stopPlayingOnTestTimeout) {
+                //     sessionPlayer.stopPlayingOnTestTimeout();
+                // }
+                logger.error('error while running appium tests', { err });
+                throw err;
+            }
+        }
+        try {
+            await super.runTestOnce(testRunHandler, appiumTestPlayer);
+            return await runAppiumTest.call(this);
+        } catch (err) {
+            logger.error('failed to run test once', { err });
+            throw err;
+        }
+    }
+}
+module.exports = WorkerAppium;

package/workers/WorkerExtensionSingleBrowser.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Bluebird = require('bluebird');
+const { delay } = require('../utils');
 const { releasePlayer } = require('./workerUtils');
 const WorkerExtension = require('./WorkerExtension');
 const perf = require('../commons/performance-logger');
@@ -14,7 +14,7 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
         if (!this.testPlayer) {
             return;
         }
-        await releasePlayer(this.id, this.releaseSlotOnTestFinished, this.userData && this.userData.projectId, this.testPlayer);
+        await releasePlayer(this.id, this.releaseSlotOnTestFinished, this.userData?.projectId, this.testPlayer);
         this.testPlayer = null;
     }
 
@@ -58,8 +58,8 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
             await this.onQueueCompleted();
             return;
         }
-        if (this.options.lightweightMode && this.options.lightweightMode.general) {
-            await Bluebird.delay(DELAY_BETWEEN_TESTS);
+        if (this.options.lightweightMode?.general) {
+            await delay(DELAY_BETWEEN_TESTS);
         }
     }
 }

package/workers/WorkerSelenium.js

@@ -92,12 +92,15 @@ class WorkerSelenium extends BaseWorker {
         sessionPlayer.playbackManager.executionName = testRunHandler.getExecutionName();
 
         sessionPlayer.setLightweightMode(this.options.lightweightMode);
+        if (testRunHandler.getSfdcCredential()) {
+            sessionPlayer.setSfdcCredential(testRunHandler.getSfdcCredential());
+        }
         if (sessionPlayerInit.localAssetService) {
             sessionPlayerInit.localAssetService.initialize({ serverUrl: this.options.localRCASaver });
         }
 
         let preloadedTest = null;
-        if (this.options.lightweightMode && this.options.lightweightMode.preloadTests) {
+        if (this.options.lightweightMode?.preloadTests) {
             const preloadedTests = await preloadTests(this.options);
             preloadedTest = preloadedTests[this.testId];
         }
@@ -208,7 +211,7 @@ class WorkerSelenium extends BaseWorker {
 function setupCliPerformanceMonitoring(sessionPlayer) {
     const { playback } = sessionPlayerInit.commonConstants;
     function monitorEvent(event) {
-        sessionPlayer.playbackManager.on(event, (...args) => {
+        sessionPlayer.playbackManager.on(event, () => {
             perf.log(`Got event ${event}`);
         });
     }