@testim/testim-cli 3.251.0 → 3.253.0

package/workers/BaseWorker.js

@@ -5,7 +5,7 @@ const moment = require('moment');
 const pRetry = require('p-retry');
 const ms = require('ms');
 
-const { timeoutMessages, testRunStatus, stepResult, runnerTestStatus } = require('../commons/constants');
+const { timeoutMessages, testRunStatus, stepResult, runnerTestStatus, CLI_MODE } = require('../commons/constants');
 const logger = require('../commons/logger').getLogger('base-worker');
 const testResultService = require('../commons/socket/testResultService');
 const remoteStepService = require('../commons/socket/remoteStepService');
@@ -110,8 +110,15 @@ class BaseWorker {
         return undefined;
     }
 
+    setSessionTimeout() {
+        if (this.options.mode === CLI_MODE.APPIUM) {
+            return Math.max(ms('180s'), this.options.getSessionTimeout);
+        }
+        return Math.max(this.lambdatestService.getSessionTimeout, this.options.getSessionTimeout);
+    }
+
     async getTestPlayer(testRunHandler, customExtensionLocalLocation) {
-        const projectId = this.userData && this.userData.projectId;
+        const projectId = this.userData?.projectId;
         let testPlayer;
 
         try {
@@ -148,7 +155,7 @@ class BaseWorker {
                     this.options.gridData.provider = gridInfo.provider;
                     this.options.gridData.host = gridInfo.host;
                     this.options.gridData.failedGetBrowserAttempts = failedGetBrowserAttempts;
-                    const getSessionTimeout = Math.max(this.lambdatestService.getSessionTimeout, this.options.getSessionTimeout);
+                    const getSessionTimeout = this.setSessionTimeout();
                     const getBrowserRes = await Bluebird.resolve()
                         .log('before getBrowserOnce')
                         .then(() => this.getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo))
@@ -186,7 +193,7 @@ class BaseWorker {
 
     async runTest(testRunHandler, customExtensionLocalLocation, shouldRerun) {
         perf.log('inside runTest');
-        const projectId = this.userData && this.userData.projectId;
+        const projectId = this.userData?.projectId;
         const quarantineResult = this.handleQuarantine(testRunHandler);
         if (quarantineResult) {
             return quarantineResult;
@@ -380,8 +387,8 @@ class BaseWorker {
             }
         };
 
-        const disableResults = this.options.disableSockets || (this.options.lightweightMode && this.options.lightweightMode.disableResults && (this.options.useChromeLauncher || this.options.mode !== 'extension'));
-        const disableRemoteStep = this.options.disableSockets || (this.options.lightweightMode && this.options.lightweightMode.disableRemoteStep);
+        const disableResults = this.options.disableSockets || (this.options.lightweightMode?.disableResults && (this.options.useChromeLauncher || this.options.mode !== 'extension'));
+        const disableRemoteStep = this.options.disableSockets || (this.options.lightweightMode?.disableRemoteStep);
 
         const runTestAndCalcResult = (testRunHandler, shouldRerun) => Promise.all([
             !disableRemoteStep && remoteStepService.joinToRemoteStep(this.testResultId),

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);
+            await runAppiumTest.call(this);
+        } catch (err) {
+            logger.error('failed to run test once', { err });
+            throw err;
+        }
+    }
+}
+module.exports = WorkerAppium;